/***************************/
/* Path Finder V1.0 1997   */
/* for Java API 1.1.3      */ 
/* Qing Li <llysc@mit.edu> */
/***************************/

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;
import java.util.*;

public class Path extends Applet
{
    int num_obstacle = 3;
    int obstacle_size = 40;
    int obstacle_edges = 4;
    int num_gem = 3;
    int gem_radius = 10;
    int rover_width = 30;
    int rover_height = 20;
    int rover_angle = 0;
    double tmp;

    // create "more than enough" empty objects -- use "vector" later.
    D_Obstacle[] dressed_obstacles = {
	new D_Obstacle(), new D_Obstacle(), new D_Obstacle(),
	new D_Obstacle(), new D_Obstacle(), new D_Obstacle(),
	new D_Obstacle(), new D_Obstacle(), new D_Obstacle(),
	new D_Obstacle(), new D_Obstacle(), new D_Obstacle(),
	new D_Obstacle(), new D_Obstacle(), new D_Obstacle(),
	new D_Obstacle(), new D_Obstacle(), new D_Obstacle(),
	new D_Obstacle(), new D_Obstacle(), new D_Obstacle(),
    };
    D_Gem[] dressed_gems = {
	new D_Gem(), new D_Gem(), new D_Gem(), new D_Gem(),
	new D_Gem(), new D_Gem(), new D_Gem(), new D_Gem(),
	new D_Gem(), new D_Gem(), new D_Gem(), new D_Gem(),
	new D_Gem(), new D_Gem(), new D_Gem(), new D_Gem(),
	new D_Gem(), new D_Gem(), new D_Gem(), new D_Gem(),
	new D_Gem(), new D_Gem(), new D_Gem(), new D_Gem()
    };
    Rover rover = new Rover();
    
    public void init()
    {
	String arg;
	int i, j, k, x, y;
	boolean success;
	
	// get parameters from applet <param> tag fields
	arg = getParameter("num_obstacle");
	if (arg != null) num_obstacle = Integer.parseInt(arg);
	arg = getParameter("obstacle_size");
	if (arg != null) obstacle_size = Integer.parseInt(arg);
	arg = getParameter("obstacle_edges");
	if (arg != null) obstacle_edges = Integer.parseInt(arg);
	arg = getParameter("num_gem");
	if (arg != null) num_gem = Integer.parseInt(arg);
	arg = getParameter("gem_radius");
	if (arg != null) gem_radius = Integer.parseInt(arg);

	// create random obstacles
	int xpoints[] = new int [obstacle_edges];
	int ypoints[] = new int [obstacle_edges];
	double angle[] = new double [obstacle_edges];
	double alpha = 0.5;
	for (i=0; i<num_obstacle; i++)
	{
	
	    success = false;
	    while (!success)
	    {
		success = true;
		x = Boundary.minx + (int) Math.round((Boundary.maxx - Boundary.minx) * Math.random());
		y = Boundary.miny + (int) Math.round((Boundary.maxy - Boundary.miny) * Math.random());
		// generate random convex polygon touching a circle 
		for (j=0; j<obstacle_edges; j++)
		{
		    angle[j] = 2 * Math.PI * Math.random();
		    // sort the angles
		    for (k=j-1; k>=0; k--)
		    {
			if (angle[k+1] < angle[k])
			{
			    // swap the two angles
			    tmp = angle[k];
			    angle[k] = angle[k+1];
			    angle[k+1] = tmp;
			}
		    }
		}
		for (j=0; j<obstacle_edges; j++)
		    angle[j] = angle[j]*alpha + (1-alpha)* 2 * Math.PI * (j-1)/obstacle_edges;
		
		for (j=0; j<obstacle_edges; j++)
		{
		    xpoints[j] = x + (int) Math.round(obstacle_size * Math.cos(angle[j])/2);
		    ypoints[j] = y + (int) Math.round(obstacle_size * Math.sin(angle[j])/2);
		    success = success && Boundary.contains(xpoints[j], ypoints[j]);
		    
		}
		if (success)
		{
		    Polygon obstacle = new Polygon(xpoints, ypoints, obstacle_edges);
		    // Must doesn't touch previous obstacles
		    for (j=0; j<i; j++)
			success = success && (!Rover.overlap(dressed_obstacles[j].body, obstacle));
		    // dress the obstacle
		    if (success) dressed_obstacles[i].dress (obstacle, rover_width, rover_height);
		}
	    }
	}

	// create (dressed) gems
	for (i=0; i<num_gem; i++)
	{
	    D_Gem gem_tmp = new D_Gem();
	    success = false;
	    while (!success)
	    {
		success = true;
		x = Boundary.minx + gem_radius + 1 +
		    (int) Math.round((Boundary.maxx - Boundary.minx - 2*gem_radius -2) * Math.random());
		y = Boundary.miny + gem_radius + 1 + 
		    (int) Math.round((Boundary.maxy - Boundary.miny - 2*gem_radius -2) * Math.random());
		gem_tmp.dress(x, y, gem_radius, rover_width, rover_height);
		// see that the gem does not touch obstacles
		for (j=0; j<num_obstacle; j++)
		    success = success && (!gem_tmp.contains_poly(dressed_obstacles[j].body));
		// see that this gem does not touch previous gems
		for (j=i-1; j>=0; j--)
		    success = success && ( (gem_tmp.x-dressed_gems[j].x)*
				   (gem_tmp.x-dressed_gems[j].x)+ 
				   (gem_tmp.y-dressed_gems[j].y)*
				   (gem_tmp.y-dressed_gems[j].y) >
				   (gem_tmp.radius+dressed_gems[j].radius)*
				   (gem_tmp.radius+dressed_gems[j].radius) );
		if(success) dressed_gems[i].dress (x, y, gem_radius, rover_width, rover_height);
	    }
	}
	
	// create rover
	success = false;
	while (!success)
	    {
		success = true;
		x = Boundary.minx + (int) Math.round((Boundary.maxx - Boundary.minx) * Math.random());
		y = Boundary.miny + (int) Math.round((Boundary.maxy - Boundary.miny) * Math.random());
		int tmp_angle = (int) Math.round(360 * Math.random());
		rover.put (x, y, rover_width, rover_height, tmp_angle);
		// see that the rover is contained in the boundary
		success = success && Boundary.contains(rover.body);
		// see that the rover does not initially hit obstacles
		success = success && (rover.hit_obstacle(dressed_obstacles, num_obstacle) == -1);
		// see that the rover does not initially hit gems
		success = success && (rover.hit_gem(dressed_gems, num_gem) == -1);
	    }   
	repaint();
    }
    
public void paint(Graphics g)
    {
	int i;
	Boundary.show(g);
	rover.show(g);
	for (i=0; i<num_gem; i++) dressed_gems[i].show(g);
	for (i=0; i<num_obstacle; i++) dressed_obstacles[i].show(g);
    }

} // class Path ends