//  1.124 Final Project
//  Group: Evidence

import java.awt.*;
import java.applet.Applet;
import java.awt.image.*;
import java.util.*;
import java.lang.Math;
import java.awt.event.*; 

public class Path_finder extends Applet implements Runnable {
    Image mBackgroundImage, mRoverImage;
    boolean mbBackgroundComplete = false, mbRoverComplete = false;
    boolean mbBackgroundDrawn = false, tmp =false;
    Image mOffScreenImage;
    Graphics mOffScreenGraphics;
    Rover mRover;
    Button mStartButton, mStopButton;
    Thread mRunner = null;
    static final int iWidth=512, iHeight=512;
    static final int North=0,South=4,East=2,West=6,NE=1,NW=7,SE=3,SW=5;
    static final int Positive = 1, Negative = -1;
    //definition of data structure for gems and obstacles
    public Vector gem[]=new Vector [1000]; //each vector for one gem
    //    public Vector obstacle[]=new Vector [1000]; //each vector for one obstacle  
    public int pickedup[]=new int [20]; //flags of pickup
    int gemnum=0,obsnum=0;;
    int accvalue=0; //accumulated gems value picked up
    Point deadpoint[]=new Point [50000], path[]=new Point [50000], ttmp[]=new Point [50000];
    int pd=0, pp=0,pt=0,prev=0;
    //int[] iPixels = new int[iWidth * iHeight]; ;
    //end of definition of data structure for gems and obstacles


    
    public Path_finder() {
	setLayout(new BorderLayout());
	Panel panel = new Panel();
	mStopButton = new Button("Stop");
	panel.add(mStopButton);
	add("South", panel);
    }

    public void init() {
	// Get a handle on the images.
        mBackgroundImage = getImage(getCodeBase(), "mars.gif");
        //mRoverImage = getImage(getCodeBase(), "rover.gif");

	// Create the rover.
	mRover = new Rover(this);

	// Create an offscreen buffer.
	mOffScreenImage = createImage(512, 512);
	mOffScreenGraphics = mOffScreenImage.getGraphics();
	//Scan gems and obstacles
	tmp=ScanObj();		
	mRunner = new Thread(this);
	mRunner.setPriority(Thread.MAX_PRIORITY);
	mRunner.start();
    }

    // The update method is called by the AWT whenever we make a repaint()
    // request.  The default implementation of update() clears the background
    // before calling paint(), which leads to flashing.  To avoid flashing,
    // we provide our own implementation of update.
    public void update(Graphics g) {
	
	if (!mbBackgroundDrawn) { 
            mOffScreenGraphics.drawImage(mBackgroundImage, 0, 0,
					 this); 
            if (mbBackgroundComplete) 
                mbBackgroundDrawn = true; 
        } 

	mRover.show(mOffScreenGraphics);

	if (mbBackgroundComplete) { 
	    g.drawImage(mOffScreenImage, 0, 0, null);}

    } //end of update

    // We still need a paint method, because paint() is called directly by
    // the AWT when a window is hidden and re-exposed.
    public void paint(Graphics g) {
	update(g);
    }

       // The imageUpdate method belongs to the ImageObserver
    // interface, 
    // which is implemented by all AWT components.  We override
    //the 
    // imageUpdate method, so that we track the loading of images. 
    public synchronized boolean imageUpdate(Image image, int flags,

                                            int x, int y, 
                                            int width, int height) { 
        boolean done = ((flags & ALLBITS) != 0); 
  
        // If the image has finished loading, record this fact. 
        if (done) { 
            System.out.println("Loaded image."); 
            if (image == mBackgroundImage) {
                mbBackgroundComplete = true; 
                repaint(); }
        } 
  
        return !done; 
    } 
    // The action method allows us to respond to the Start and Stop buttons.
    public boolean action(Event event, Object obj) {
	if (obj.equals("Stop")) {
	    if (mRunner != null) {
		mRunner.stop();
		mRunner = null;
		//mOffScreenGraphic.dispose();
		//mOffScreenImage.flush();
	    }
	}
	return true;
    }


    //+++++++++++++++++++++++++++++++++++++==
    public void run() {
	int i,j,ingem=0;
	int iVX = 1, iVY = 1;
	boolean bHitObject,checkgem;
	int dir=SE;
	Point p1=new Point() ,p2=new Point(); //p1:rover;   p2: current gem 
	int olddir[]=new int [50];
	int old_pointer=0;
	int kkk, jjj;	
	int td, dis;
	
	    while (mRunner != null) {
		for(jjj=0; jjj<gemnum;jjj++){
		j=jjj;
		p1.x=mRover.cmx;
		p1.y=mRover.cmy;
		dis = Integer.MAX_VALUE;
		for( kkk=0;kkk<gemnum;kkk++){
		    if(pickedup[kkk]==0){
			p2=(Point)(gem[kkk].elementAt(gem[kkk].size()/2));
			td=(p2.x-p1.x)*(p2.x-p1.x)+
			    (p2.y-p1.y)*(p2.y-p1.y);
			if (dis>td){
			    dis=td;
			    j=kkk;
			}
		    }
		}
		p2=(Point)(gem[j].elementAt(gem[j].size()/2));
		pd=0;
		
		if(jjj>0)
		    dir=(choose_dir(p1,(Point)(gem[j].elementAt(gem[j].size()/2)))+4)%8;		
		boolean success=s_path(p1,p2,j,dir);
		//System.out.println(j+" "+success);
		while ( ! success){
		    int back=30;
		    if(pp/4<30) back=pp/4;
		    if (back<1) back =1;
		    p1.x=mRover.cmx;
		    p1.y=mRover.cmy;
		    if ((pp) <=0) {
			System.out.println("give up gem["+j+"]");
			break;
		    }
		    dir=(choose_dir(p1,path[pp-back])+4)%8;
		    success=s_path(p1,path[pp-back],prev,dir);
		    //p1=path[pp-back];
		    p1.x = mRover.cmx;
		    p1.y = mRover.cmy;

		    dir=(choose_dir(p1,(Point)(gem[j].elementAt(gem[j].size()/2)))+4)%8;
		    success=s_path(p1,(Point)(gem[j].elementAt(gem[j].size()/2)),j,dir);
		    pp=pp-back;
		   
		}
		prev=j;
		//end of j cycle
		    
		if(jjj==gemnum-1){
		    System.out.println("Mission Completed");
		    if (mRunner != null) {
			mRunner.stop();
			mRunner = null;}
		}
		}
	    }
    } //end of run()
    //+++++++++++++++++++++++++++++++++++++++++++++++++
boolean hitGem(Rover mRover, int index)
    {
	int i, x, y;
	
	if (pickedup[index]==0)
	{
	    for(i=0; i<gem[index].size(); i++){
		//Point p = new Point();
		x = ((Point)gem[index].elementAt(i)).x;
		y = ((Point)gem[index].elementAt(i)).y;
		if (mRover.contains(x,y)) {
		    System.out.println("Got one");
		    accvalue=accvalue+gem[index].size();
		    System.out.println("Total Gem Value =  "+accvalue);
		    pickedup[index]=1;
		    //--
		    pp=0;
		    for(int ll=0;ll<pt;ll++){
			path[pp]=ttmp[ll];
			pp++;}
		    return true;}
	    }
	}
	return false;
    }
    
    
    // Check whether background image has any red pixels in the given area.
    boolean checkPixels(int p1x,int p1y,int iX, int iY, int iWidth, int iHeight, int color, int index) {
	//color =0 : red;      1:green
	int i, j, iPixel, iRed, iGreen, iBlue;
	int[] iPixels;
	Point p1=new Point(p1x,p1y);
	
	if(color==0){
 if (((iX + iWidth >= 511) || (iX <=0)) ||
		((iY + iHeight >= 511) || (iY<= 0)))
 {  if((iX!=0) || (iY!=0)){ deadpoint[pd]=p1;pd++;
     return true; //collision with walls
 }
 }
	}
	
	// Grab the pixels in the given area.
	iPixels = new int[iWidth * iHeight];
	PixelGrabber pg = new PixelGrabber(mBackgroundImage, iX, iY, iWidth,
					   iHeight, iPixels, 0, iWidth);
	try {
	    pg.grabPixels();
	}
	catch (InterruptedException e) {
	    System.out.println("Interrupted waiting for pixels.");
	    return true;	// Err on the safe side.
	}
	if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
	    System.out.println("Image fetch aborted.");
	    return true;	// Err on the safe side.
	}

	// Check for any red pixels.
	//check left and right lines
		i=0;
	for (j = 0; j < iHeight; j++) {
	    iPixel = iPixels[j * iWidth + i];
	    iRed = (iPixel >> 16) & 0xff;
		iGreen = (iPixel >> 8) & 0xff;
		iBlue = iPixel & 0xff;
		if (color==1){		
		//dealing with gem pickup
		    	if (iRed == 0 && iGreen == 255 && iBlue == 0) {
			    //	    for( int k1=0;k1<gemnum;k1++){
		    int k1=index;
			for(int k2=0; k2<gem[k1].size();k2++){
  if((((Point)gem[k1].elementAt(k2)).x==i+iX) && (((Point)gem[k1].elementAt(k2)).y==j+iY))
  {   if (pickedup[k1]==0) {
      System.out.println("Got one");
      accvalue=accvalue+gem[k1].size();
       System.out.println("Total Gem Value =  "+accvalue);
      pickedup[k1]=1;
      //--
      pp=0;
      for(int ll=0;ll<pt;ll++){
	  path[pp]=ttmp[ll];
	  pp++;
      }
      //--
      return true;
      }
  
  }
			}
			
			}
		   
			    //}
		//   end of dealing with gem pickup
 		}
		else
		{
		if (iRed == 255 && iGreen == 0 && iBlue == 0) {
		    //		    System.out.println("Collision detected.");
		    return true;
		}
		}
	}
	//---
	i=iWidth-1;
	for (j = 0; j < iHeight; j++) {
	    iPixel = iPixels[j * iWidth + i];
	    iRed = (iPixel >> 16) & 0xff;
		iGreen = (iPixel >> 8) & 0xff;
		iBlue = iPixel & 0xff;

		if (color==1){
				//dealing with gem pickup
		if (iRed == 0 && iGreen == 255 && iBlue == 0) {
		    //	    for( int k1=0;k1<gemnum;k1++){
			 int k1=index;
			for(int k2=0; k2<gem[k1].size();k2++){
  if((((Point)gem[k1].elementAt(k2)).x==i+iX) && (((Point)gem[k1].elementAt(k2)).y==j+iY))
  {   if (pickedup[k1]==0) {
      System.out.println("Got one");
      accvalue=accvalue+gem[k1].size();
       System.out.println("Total Gem Value =  "+accvalue);
      pickedup[k1]=1;
            pp=0;

      for(int ll=0;ll<pt;ll++){
	  path[pp]=ttmp[ll];
	  pp++;
      }
      return true;
  }
  
  }
			}
			
			//}
		   
		}
		//   end of dealing with gem pickup
 		}
		else {
		if (iRed == 255 && iGreen == 0 && iBlue == 0) {
		    // System.out.println("Collision detected.");
		    		    return true;
		}
		}
	}
	//----------------------
	//check top and bottom lines
	j=0;
	for (i = 0; i < iWidth; i++) {
	    iPixel = iPixels[j * iWidth + i];
	    iRed = (iPixel >> 16) & 0xff;
		iGreen = (iPixel >> 8) & 0xff;
		iBlue = iPixel & 0xff;
		if (color==1){
		//dealing with gem pickup
		if (iRed == 0 && iGreen == 255 && iBlue == 0) {
		    //	    for( int k1=0;k1<gemnum;k1++){
		     int k1=index;
			for(int k2=0; k2<gem[k1].size();k2++){
  if((((Point)gem[k1].elementAt(k2)).x==i+iX) && (((Point)gem[k1].elementAt(k2)).y==j+iY))
  {   if (pickedup[k1]==0) {
      System.out.println("Got one");
      accvalue=accvalue+gem[k1].size();
       System.out.println("Total Gem Value =  "+accvalue);
      pickedup[k1]=1;
            pp=0;

      for(int ll=0;ll<pt;ll++){
	  path[pp]=ttmp[ll];
	  pp++;
      }

      return true;
      }
  
  }
			}
			
			//}
		   
		}
		//   end of dealing with gem pickup
		}
		else {
		if (iRed == 255 && iGreen == 0 && iBlue == 0) {
		    //	    System.out.println("Collision detected.");
		    return true;
		}
		}
	}
	//--
	j=iHeight-1;
	for (i = 0; i < iWidth; i++) {
	    iPixel = iPixels[j * iWidth + i];
	    iRed = (iPixel >> 16) & 0xff;
		iGreen = (iPixel >> 8) & 0xff;
		iBlue = iPixel & 0xff;
		if (color==1){
		//dealing with gem pickup
		if (iRed == 0 && iGreen == 255 && iBlue == 0) {
		    //    for( int k1=0;k1<gemnum;k1++){
		     int k1=index;
			for(int k2=0; k2<gem[k1].size();k2++){
  if((((Point)gem[k1].elementAt(k2)).x==i+iX) && (((Point)gem[k1].elementAt(k2)).y==j+iY))
  {   if (pickedup[k1]==0) {
      System.out.println("Got one");
      accvalue=accvalue+gem[k1].size();
       System.out.println("Total Gem Value =  "+accvalue);
      pickedup[k1]=1;
            pp=0;

      for(int ll=0;ll<pt;ll++){
	  path[pp]=ttmp[ll];
	  pp++;
      }
      return true;
      }
  
  }
			}
			
			//	    }
		   
		}
		//   end of dealing with gem pickup
		}
		else {
		if (iRed == 255 && iGreen == 0 && iBlue == 0) {
		    //	    System.out.println("Collision detected.");
		    return true;
		}
		}
	}
	//--------------
	
	
	return false;		// No collision.
    }

    
        // Scan Objectives-- gems(green),obstacles(red)-- in the whole image.
    boolean  ScanObj() {
	int i, j, iPixel, iRed, iGreen, iBlue;
	int k,kk,kk0,kk1,k3;
	int[] iPixels;	
	Object pp=null;
	int bb=0,ll=0;
	int tt[]=new int [1000];
	int tnum=0;
	// Grab the pixels in the given area.
	iPixels = new int[iWidth * iHeight];
	PixelGrabber pg = new PixelGrabber(mBackgroundImage, 0, 0, iWidth,
					   iHeight, iPixels, 0, iWidth);
	try {
	    pg.grabPixels();
	}
	catch (InterruptedException e) {
	    System.out.println("Interrupted waiting for pixels.");
	    return false;	// Err on the safe side.
	}
	if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
	    System.out.println("Image fetch aborted.");
	    return false; 	// Err on the safe side.
	}
	// Check for any green pixels---gems.
	for (j = 0; j < iHeight; j++) {
	    for (i = 0; i < iWidth; i++) {
		iPixel = iPixels[j * iWidth + i];
		iRed = (iPixel >> 16) & 0xff;
		iGreen = (iPixel >> 8) & 0xff;
		iBlue = iPixel & 0xff;
		if (iRed == 0 && iGreen == 255 && iBlue == 0) {
		    //----
		    pp = (Object)new Point(0,0);
		    Point point=(Point) pp;
		    point.x = i; 
		    point.y = j; 
		    if (ll==0){gemnum++;
		    gem[gemnum-1] = new Vector(30); 
		    gem[gemnum-1].addElement(pp); pp=null;
		    //    System.out.println(gemnum);
		    ll=1;
		    }
		    else{
			int x0=((Point)(gem[gemnum-1].lastElement())).x;
			int y0=((Point)(gem[gemnum-1].lastElement())).y;
			int x1=point.x;
			int y1=point.y;
		if (  (Math.abs(x0-x1)<=1) && (y0==y1)){
gem[gemnum-1].addElement(pp); //put the current point into the right gem Vector
				     pp=null;
		}   
			
			else {
			    gemnum++;
			    gem[gemnum-1] = new Vector(30);			    
			    gem[gemnum-1].addElement(pp); //start a new gem
			     pp=null;
			     //         System.out.println(gemnum);
			}
		    }
		    //----
		    
		}
	    }
	    ll=0;
	} // end of pixel scanning

	//begining of combination of pseudo objects
	bb=0;
	for( k=1;k<gemnum;k++)
	{
	    for( j=0;j<k;j++)
	    {
		int yy0=((Point)(gem[j].lastElement())).y;
		int yy1=((Point)(gem[k].firstElement())).y;
		if(Math.abs(yy1-yy0)<=1) { 
	    for( kk1=0;kk1<gem[k].size();kk1++){
		for( kk0=0;kk0<gem[j].size();kk0++){
		    
		int x0=((Point)(gem[j].elementAt(kk0))).x;
		int x1=((Point)(gem[k].elementAt(kk1))).x;
		
		
				if ((Math.abs(x0-x1)<=1)){
		    for( k3=0;k3<gem[k].size();k3++){
			gem[j].addElement(gem[k].elementAt(k3));}
		    tt[tnum]=k;
		    tnum++;
		    bb=1;
		    break;
		}
		}
		if(bb==1){break;}
	    } //end of kk1 cycle
	    }
	    if(bb==1){bb=0;break;}
		
	} //end of j cycle

	} //end of k cycle

	if (tnum>0){
	    for ( k=0;k<tnum;k++){
		for( kk=tt[k];kk<gemnum;kk++)
		{
		    gem[kk]=gem[kk+1];
		}
		gemnum--;
		for( j=k+1;j<tnum;j++) tt[j]--;
	    }
			
	} //end of if

	//end of combination of pseudo objects
	//System.out.println(gemnum);
	//System.out.println("scanning ends");
	return true;
    } //end of scanobj


    //------ function of determining direction
int choose_dir(Point p1,Point p2)
    {
	int ivx=1,ivy=1;
	
	 if (p2.x==p1.x) ivx=0;
	 else if(p2.x>p1.x) ivx=1;
	       else ivx=-1;
	 if (p2.y==p1.y) ivy=0;
	 else if(p2.y>p1.y) ivy=1;
	       else ivy=-1;

	 switch(ivx){
	 case 0: if(ivy==1) return South;
	         else if(ivy==-1) return North;
	 case 1: switch (ivy){
	          case 0: return East;
		      //case 1: return SE;
	          case 1: return SE;
		      //case -1: return NE;
		  case -1: return NE;
	          default : break;
                        	 }
	 case -1: switch (ivy){
	          case 0: return West;
	          case 1: return SW; //SW;
	          case -1: return NW; //NW
	          default : break;
                        	 }
	 default : break;
 
	     
	 }
 return SE;
    }
    //-----

    //--searching path
    boolean s_path(Point p1,Point p2, int jj,int olddir){
	boolean finish=true,bHitObject=true;
	Point np1=new Point();
	int iVX=0,iVY=0;
	int Counter=0;
	int firstdir;
	int mod_dir[] =new int [8];
	int dead=0, theta=0;
	mod_dir[0]=0;mod_dir[2]=1;mod_dir[1]=-1;mod_dir[4]=2;mod_dir[3]=-2;mod_dir[6]=3;mod_dir[5]=-3;mod_dir[7]=4;
	
	
	if((p1.x==p2.x)&&(p1.y==p2.y)) {
	    System.out.println("Got one");
	    accvalue=accvalue+gem[jj].size();
	    System.out.println("Total Gem Value =  "+accvalue);
	    pickedup[jj]=1;
	    //--
	    pp=0;
	    for(int ll=0;ll<pt;ll++){
		path[pp]=ttmp[ll];
		pp++;}
	    return true;
	}
	/*
	if(checkPixels(mRover.mX, mRover.mY,mRover.mX, mRover.mY,
		       mRover.mWidth, mRover.mHeight,1,jj)) {
	    return true;
	}*/

	//System.out.println("in s_path");
	if( hitGem(mRover, jj)) return true;
	//System.out.println("in s_path, not hit gem");
	firstdir=choose_dir(p1,p2);
	
	for(int i=0;i<8;i++){
	    dead=0;
	    firstdir=(firstdir+mod_dir[i]+8)%8;
	    if((firstdir+8-olddir)%8!=4){
		switch (firstdir){
		case North : iVX=0; iVY=-1;  break;
		case South : iVX=0; iVY=1;  break;
		case East :  iVX=1; iVY=0;  break;
		case West :  iVX=-1; iVY=0;  break;
		case NE :    iVX=1; iVY=-1;  break;
		case NW :    iVX=-1; iVY=-1;  break;
		case SW :   iVX=-1; iVY=1; break;
		case SE:        iVX=1; iVY=1; break;
		default: break;    
		}

		bHitObject = checkPixels(p1.x+iVX,p1.y+iVY,mRover.mX+iVX,
					 mRover.mY+iVY,
					 mRover.mWidth, mRover.mHeight,0,1);
		
		if(!bHitObject){
		    
		    for(int j=0;j<pd;j++){
			if((deadpoint[j].x==p1.x+iVX)&&
			   (deadpoint[j].y==p1.y+iVY))
			    dead=1;
		    }
		    if(dead==0){
			
			ttmp[pt]=p1;pt++;
			mRover.move(firstdir);
			
			// here should have sleep
			np1.x=mRover.cmx;
			np1.y=mRover.cmy;
			if (s_path(np1,p2,jj,firstdir)) return true;
		    }
		}
	    }
	    
	} //end of i cycle
	deadpoint[pd]=p1;
	pd++;
	return false;
    } //end of s_path
    //end of searching path


    //**************************
} //end of applet

// A simple Rover class.
class Rover {
    //mX, mY is the point of the left corner
    // cmx, cmy is the point of the center
    // angle is the current angle relative to the original one.
    // angle is in range [-90, 90]
    public int mX, mY, mWidth, mHeight, angle, cmx, cmy;
    public Polygon body;
    private int dia =18; // sqrt(w/2^2+ h/2^2)
    private int myxpoints[] = new int [4];
    private int myypoints[] = new int [4];
    
    Path_finder mApplet;
    static final int North=0,South=4,East=2,West=6,NE=1,NW=7,SE=3,SW=5;
    static final int Positive=1, Negative = -1;
    static final int  minx =0, maxx = 512, miny = 0, maxy = 512;
    
    public Rover(Path_finder applet) {
	mWidth = 30;
	mHeight = 20;
	mX = 0; mY = 0;
	cmx = 15; cmy = 10;
	angle = 0;
	mApplet = applet;
	myxpoints[0] = mX;
	myxpoints[1] = mX;
	myxpoints[2] = myxpoints[0] + mWidth - 1;
	myxpoints[3] = myxpoints[1] + mWidth - 1;
	myypoints[0] = mY;
	myypoints[1] = mY+ mHeight - 1;
	myypoints[2] = myypoints[1];
	myypoints[3] = myypoints[0];
	body = new Polygon(myxpoints, myypoints, 4);
    }

    public boolean move(int dir) {
	int dx=0, dy=0, i;
	
	switch (dir){
	case North : mY--; dy=-1; break;
	case South : mY++; dy =1; break;
	case East :  mX++; dx = 1; break;
	case West :  mX--; dx =-1; break;
	case NE :    mX++;  mY--; dx=1; dy=-1; break;
	case NW :    mX--; mY--; dx=-1; dy=-1; break;
	case SW :    mX--; mY++; dx=-1; dy=1;break;
	case SE:     mX++; mY++; dx=1; dy=1; break;     
	default: break;    
	}

	cmx += dx;
	cmy += dy;

	for (i=0;i<4;i++)
	{
	    this.body.xpoints[i] += dx;
	    this.body.ypoints[i] += dy;
	}
	
	mApplet.repaint();
	return (true);
    }

    // return false, if hit obs or boundary, 
    // else return true 
public boolean rotate (int P_N, Image BackGroundImage, int[] iPixels)
    {
	//P_N is either 1 or -1;
	int i, j, k, real_degree, angle_tmp;
	real_degree = P_N*5;
	double f1, f2;

	// make sure the angle is in [-90, 90]
	angle_tmp = angle+real_degree;
	if ( angle_tmp > 90) angle_tmp -= 180;
	if ( angle_tmp < -90) angle_tmp += 180;
	
	f1 = angle*Math.PI/180.0 + Math.atan(2./3.);
	f2 = angle*Math.PI/180.0 - Math.atan(2./3.); 
	myxpoints[0] = cmx - (int) (dia * Math.cos(f2));
	myypoints[0] = cmy - (int) (dia * Math.sin(f2));
	myxpoints[1] = cmx - (int) (dia * Math.cos(f1));
	myypoints[1] = cmy - (int) (dia * Math.sin(f1));
	myxpoints[2] = cmx + (int) (dia * Math.cos(f2));
	myypoints[2] = cmy + (int) (dia * Math.sin(f2));
	myxpoints[3] = cmx + (int) (dia * Math.cos(f1));
	myypoints[3] = cmy + (int) (dia * Math.sin(f1));

	// if hit boundary, can't rotate,  return false
	for(i=0; i<4; i++)
	    if ((myxpoints[i]<minx) || (myxpoints[i]>maxx)
		|| (myypoints[i]<miny) || (myypoints[i]>maxy))
	    { //System.out.println( "hit Wall"); return false;}

	// if hit an obs, can't rotate, return false
	int iPixel, iRed, iGreen, iBlue;
	int dx, dy;

	// from myxpoints[0] to myxpoints[1], left line;
	if (myxpoints[0] < myxpoints[1] ) dx = 1;
	if (myxpoints[0] > myxpoints[1] ) dx = -1;
	else dx =0;
	if (dx==0) dy =1;
	else
	    dy = (myypoints[1]-myypoints[0])/(myxpoints[1]-myxpoints[0])*dx+1;
	for(j=myxpoints[0], k=myypoints[0] ; k<=myypoints[1]; k+=dy)
	{
	    iPixel = iPixels[k*512+j];
	    iRed = (iPixel >> 16) & 0xff;
	    iGreen = (iPixel >> 8) & 0xff;
	    iBlue = iPixel & 0xff;
	    if (iRed == 255 && iGreen == 0 && iBlue == 0)
	    {System.out.println( "bottom hit obs"); return false;}
	    j += dx;
	}
	
	// from myxpoints[1] to myxpoints[2], bottom line;
	if (myypoints[1] < myypoints[2] ) dy = 1;
	if (myypoints[1] > myypoints[2] ) dy = -1;
	else dy =0;
	if (dy==0) dx =1;
	else
	    dx = (myxpoints[2]-myxpoints[1])/(myypoints[2]-myypoints[1])*dy+1;
	for(j=myxpoints[1], k=myypoints[1] ; j<=myxpoints[2]; j+=dx)
	{
	    iPixel = iPixels[k*512+j];
	    iRed = (iPixel >> 16) & 0xff;
	    iGreen = (iPixel >> 8) & 0xff;
	    iBlue = iPixel & 0xff;
	    if (iRed == 255 && iGreen == 0 && iBlue == 0) 
	    {System.out.println( "left hit obs"); return false;}
	    k += dy;
	}
	
	// from myxpoints[2] to myxpoints[3], right line;
	if (myxpoints[2] < myxpoints[3] ) dx = 1;
	if (myxpoints[2] > myxpoints[3] ) dx = -1;
	else dx =0;
	if (dx==0) dy =1;
	else
	    dy = (myypoints[3]-myypoints[2])/(myxpoints[3]-myxpoints[2])*dx+1;
	for(j=myxpoints[2], k=myypoints[2] ; k<=myypoints[3]; k+=dy)
	{
	    iPixel = iPixels[k*512+j];
	    iRed = (iPixel >> 16) & 0xff;
	    iGreen = (iPixel >> 8) & 0xff;
	    iBlue = iPixel & 0xff;
	    if (iRed == 255 && iGreen == 0 && iBlue == 0) 
	    {System.out.println( "right hit obs"); return false;}
	    j += dx;
	}

	// from myxpoints[3] to myxpoints[0], up line;
	if (myypoints[3] < myypoints[0] ) dy = 1;
	if (myypoints[3] > myypoints[0] ) dy = -1;
	else dy =0;
	if (dy==0) dx =1;
	else
	    dx = (myxpoints[0]-myxpoints[3])/(myypoints[0]-myypoints[3])*dy+1;
	for(j=myxpoints[3], k=myypoints[3] ; j<=myxpoints[0]; j+=dx)
	{
	    iPixel = iPixels[k*512+j];
	    iRed = (iPixel >> 16) & 0xff;
	    iGreen = (iPixel >> 8) & 0xff;
	    iBlue = iPixel & 0xff;
	    if (iRed == 255 && iGreen == 0 && iBlue == 0) 
	    {System.out.println( "up hit obs"); return false;}
	    k += dy;
	}

	// else then rotate succesfully;
	angle = angle_tmp;
	mX = myxpoints[0];
	mY = myypoints[0];
	for (i=0;i<4;i++)
	{
	    this.body.xpoints[i] = myxpoints[i];
	    this.body.ypoints[i] = myypoints[i];
	}
	mApplet.repaint();
	return (true);
	    }
	return false;
    }

public boolean contains(int x, int y)
    {
	if( (x>=mX) && (x<=mX+mWidth) && (y>=mY) && (y<=mY+mHeight))
	    return true;
	else return false;
    }
public void show(Graphics g)
    {
	try { 
	    Thread.sleep(1); 
	} 
	catch (InterruptedException e) { 
	} 
	g.fillPolygon(body);
    }

    }