/* Smart Rover */

import java.awt.*;
import java.util.Vector;

public class Rover
{
public Polygon body;
public int width, height, angle, cmx, cmy;
private int myxpoints[] = new int [4];
private int myypoints[] = new int [4];
public Path myApplet;
    
public Rover(Path applet)
    {
	myApplet = applet;
	height = 20; width =30; angle = 0; cmx = 15; cmy = 10;
	myxpoints[0] = cmx - width/2;
	myxpoints[1] = cmx - width/2;
	myxpoints[2] = myxpoints[0] + width - 1;
	myxpoints[3] = myxpoints[1] + width - 1;
	myypoints[0] = cmy - height/2;
	myypoints[1] = cmy + height/2;
	myypoints[2] = myypoints[1];
	myypoints[3] = myypoints[0];
	Polygon tmp = new Polygon(myxpoints, myypoints, 4);
	// rotate by angle
	double f = angle * Math.PI / 180.0;
	for (int i=0;i<4;i++)
	{
	   myxpoints[i] += (tmp.xpoints[i] - cmx) * (Math.cos(f)-1)
	                 - (tmp.ypoints[i] - cmy) * Math.sin(f);
	   myypoints[i] += (tmp.xpoints[i] - cmx) * Math.sin(f)
	                 + (tmp.ypoints[i] - cmy) * (Math.cos(f)-1);
	}
	body = new Polygon(myxpoints, myypoints, 4);
    }

public void put
(int cmx, int cmy, int rover_width, int rover_height, int angle)
    {
	myxpoints[0] = cmx - rover_width/2;
	myxpoints[1] = cmx - rover_width/2;
	myxpoints[2] = myxpoints[0] + rover_width - 1;
	myxpoints[3] = myxpoints[1] + rover_width - 1;
	myypoints[0] = cmy - rover_height/2;
	myypoints[1] = cmy + rover_height/2;
	myypoints[2] = myypoints[1];
	myypoints[3] = myypoints[0];
	Polygon tmp = new Polygon(myxpoints, myypoints, 4);
	// rotate by angle
	double f = angle * Math.PI / 180.0;
	for (int i=0;i<4;i++)
	{
	   myxpoints[i] += (tmp.xpoints[i] - cmx) * (Math.cos(f)-1)
	                 - (tmp.ypoints[i] - cmy) * Math.sin(f);
	   myypoints[i] += (tmp.xpoints[i] - cmx) * Math.sin(f)
	                 + (tmp.ypoints[i] - cmy) * (Math.cos(f)-1);
	}
	this.cmx = cmx;
	this.cmy = cmy;
	this.angle = angle;
	body = new Polygon(myxpoints, myypoints, 4);
    }
    
public boolean move (int dx, int dy, D_Obstacle obstacles[], int num_obstacle)
    {
	// this rover automatically shuns all obstacles
	// returns if the move is successful
	int i, j;
	boolean success = true;
	if ((Math.abs(dx) > 1) || (Math.abs(dy) > 1)) return (false);
	for (i=0; i<4; i++)
	{
	   myxpoints[i] = body.xpoints[i] + dx;
	   myypoints[i] = body.ypoints[i] + dy;
	}
	Polygon trial = new Polygon(myxpoints, myypoints, 4);
	for (j=1; (j<num_obstacle) && success; j++)
	    success = !overlap (trial, obstacles[j].body);
	if (success)
	{
	    this.cmx += dx;
	    this.cmy += dy;
	    for (i=0;i<4;i++)
	    {
		this.body.xpoints[i] = myxpoints[i];
		this.body.ypoints[i] = myypoints[i];
	    }
	    myApplet.repaint();
	}
	return (success);
	
    }

public int rotate (int degree, D_Obstacle obstacles[], int num_obstacle)
    {
	// this rover automatically shuns all obstacles
	// returns the actual degree rotated.
	int i, j, real_degree;
	boolean success = true;
	real_degree = degree/5*5;
	double f = real_degree*Math.PI/180.0;
	for (i=0;i<4;i++)
	{
	   myxpoints[i] += (this.body.xpoints[i] - cmx) * (Math.cos(f)-1)
	       - (this.body.ypoints[i] - cmy) * Math.sin(f);
	   myypoints[i] += (this.body.xpoints[i] - cmx) * Math.sin(f)
	       + (this.body.ypoints[i] - cmy) * (Math.cos(f)-1);
	}
	Polygon trial = new Polygon(myxpoints, myypoints, 4);
	for (j=1; (j<num_obstacle) && success; j++)
	    success = !overlap (trial, obstacles[j].body);
	if (success)
	{
	    angle += real_degree;
	    for (i=0;i<4;i++)
	    {
		this.body.xpoints[i] = myxpoints[i];
		this.body.ypoints[i] = myypoints[i];
	    }
	    myApplet.repaint();
	    return (real_degree);
	}
	else return (0);
    }

public static boolean overlap (Polygon poly1, Polygon poly2)
    {
	//test if two polygons overlap    
	int j;
	boolean hit = false;

	// see if poly1 vertices are in poly2
	for (j=0; j<poly1.npoints; j++)
	{
	    hit = hit || poly2.contains(poly1.xpoints[j], poly1.ypoints[j]);
	    if (hit) return (hit);
	}

	// see if poly2 vertices are in poly1
	for (j=0; j<poly2.npoints; j++)
	{
	    hit = hit || poly1.contains(poly2.xpoints[j], poly2.ypoints[j]);
	    if (hit) return (hit);
	}
	return (false);
    }
    
public int hit_obstacle (D_Obstacle obstacles[], int num_obstacle)
    {
	int i,j;
	boolean hit = false;
	// loop over obstacles
	for (i=0; i<num_obstacle; i++)
	{
	    hit = hit || overlap(obstacles[i].body, body);
	    if (hit) break;
	}	    
	if (hit) return (i);  else return(-1);  
    }

public boolean hit_gem(D_Gem gem)
    {
	int i,j;
	boolean hit = false;
	hit = hit || gem.contains_poly(body);
	return hit;
    }
    
public int hit_gem(D_Gem gem[], int num_gem)
    {
	int i,j;
	boolean hit = false;
	// loop over gems
	for (i=0; i<num_gem; i++)
	{
	    hit = hit || gem[i].contains_poly(body);
	    if (hit) break;
	}
	if (hit) return (i);  else return(-1);  
    }
    
public int hit_gem(Vector gems)
    {
	int i,j;
	boolean hit = false;
	// loop over gems
	for (i=0; i<gems.size(); i++)
	{
	    hit = hit || ( (D_Gem)gems.elementAt(i) ).contains_poly(body);
	    if (hit) break;
	}
	if (hit) return (i);  else return(-1);  
    }    
public void show(Graphics g)
    {
	g.setColor(Color.blue);
	g.drawPolygon(this.body);
	// mark out the center of mass
	g.setColor(Color.blue);
	D_Gem.drawFilledCircle (g, cmx, cmy, 4);
    }

}     // class Rover ends