//  1.124 Final Project
//Group: Evidence
//Authors: Haiyang Liu, Qing Li

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

public class pppp extends Applet implements Runnable {
    Image mBackgroundImage, mRoverImage;
    boolean mbBackgroundComplete = false, mbRoverComplete = false;
    boolean mbBackgroundDrawn = false,tmp;
    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=1,East=2,West=3,NE=4,NW=5,SE=6,SW=7;

    //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, gemFound = 0;
    int accvalue=0; //accumulated gems value picked up
  
    
    //end of definition of data structure for gems and obstacles


    
    public pppp() {
	setLayout(new BorderLayout());
	Panel panel = new Panel();
	panel.setLayout(new GridLayout(1,2));
	mStartButton = new Button("Start");
	panel.add(mStartButton);
	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();
    }

    // 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) {
	// Draw the background image into the offscreen buffer only once.
	// This allows us to keep a trail of where the rover has been.
	if (!mbBackgroundDrawn) {
	    mOffScreenGraphics.drawImage(mBackgroundImage, 0, 0, this);
	    if (mbBackgroundComplete)
		mbBackgroundDrawn = true;
	}

	// Draw the current Rover location into the offscreen buffer.
	mOffScreenGraphics.drawImage(mRoverImage, mRover.mX, mRover.mY,
				     this);

	// Copy the contents of the offscreen buffer onto the screen.
	if (mbBackgroundComplete && mbRoverComplete) {
	    g.drawImage(mOffScreenImage, 0, 0, null);
	}


	//beginning of indication of gems
	/*	 g.setColor(Color.black);
	 for(int k=0; k<gemnum;k++){
			    for( int kk=0;kk<gem[k].size();kk++){
		g.drawRect(((Point)(gem[k].elementAt(kk))).x ,((Point)(gem[k].elementAt(kk))).y,1,1);
		
			    }
		
	 }*/
	 //end of indication of gems


    } //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 action method allows us to respond to the Start and Stop buttons.
    public boolean action(Event event, Object obj) {
	if (obj.equals("Start")) {
	    if (mRunner == null) {
		mRunner = new Thread(this);
		mRunner.setPriority(Thread.MIN_PRIORITY);
		mRunner.start();
	    }
	}
	else if (obj.equals("Stop")) {
	    if (mRunner != null) {
		mRunner.stop();
		mRunner = null;
	    }
	}
	return true;
    }

    // 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) {
	    if (image == mBackgroundImage)
		mbBackgroundComplete = true;
	    else if (image == mRoverImage)
		mbRoverComplete = true;
	    if (mbBackgroundComplete && mbRoverComplete)
		repaint();
	}
	
	return !done;
    }

    public void run() {
	int i, j;
	double dis, dis_curr;
	int iVX , iVY , ddx , ddy, ddx_abs, ddy_abs;
	int Direction;
	boolean bHitObject, bbHitObject;
	Point p2 = new Point(), p_rover = new Point();;
	
	Object p_tmp, p_tmp1;
	//p1 is current position of rover and p2 is the
	// destination of gem
	for(j=0; j<gemnum; j++)
	//while (gemFound< gemnum)
	{
	    Vector last_p = new Vector(1000);
	    p_tmp1 = (Object)new Point();
	    Point p=(Point) p_tmp1;
	    p.x = mRover.mX;
	    p.y =  mRover.mY;
	    last_p.addElement(p_tmp1);
	    //j=0;
	    dis= 1E15;
	    /*
	    for (i=0; i<gemnum; i++)
	    {
		if (pickedup[i]==0){  
		p2.x = ((Point)gem[i].elementAt(0)).x;
		p2.y = ((Point)gem[i].elementAt(0)).y;
		dis_curr = dis_2(p2, p)/100000000;
		if (dis_curr< dis){ j = i; dis = dis_curr;}}
	    }*/
	    // j is the index of the gem that is closest to the rover			
		p2.x = ((Point)gem[j].elementAt(0)).x;
		p2.y = ((Point)gem[j].elementAt(0)).y;

		while (mRunner != null) {
		p_tmp = (Object)new Point();
		Point p1=(Point) p_tmp;
		p_rover.x = mRover.mX;
		p_rover.y = mRover.mY;
		if( checkPixels(mRover.mX, mRover.mY,
				mRover.mWidth, mRover.mHeight, 1, j) )
		{break;}
		ddx = p2.x - p_rover.x;
		ddy = p2.y - p_rover.y;
		ddx_abs = Math.abs(ddx);
		ddy_abs = Math.abs(ddy);
		if (ddx_abs==0) iVX = 0;
		else iVX = ddx/ddx_abs;
		if (ddy_abs==0) iVY = 0;
		else iVY = ddy/ddy_abs;

		bHitObject = true;
		while (bHitObject) {
		// Look where we are going to make sure we don't collide
		// with an obstacle.  Here, we just randomly reverse either
		// the x or the y velocity when a collision is detected.
		    if( (iVX!=0) && (iVY != 0))
		    {
			p1.x = mRover.mX+iVX;
			p1.y = mRover.mY+iVY;

			bHitObject = checkPixels(p1.x, p1.y,
					     mRover.mWidth, mRover.mHeight,0,0);
			if (bHitObject || last_p.contains(p_tmp)) {
			    bHitObject = true;
			    
			    p1.x = mRover.mX;
			    p1.y = mRover.mY+iVY;
			    bHitObject = checkPixels(p1.x, p1.y,
						 mRover.mWidth, mRover.mHeight,0,0);
			    if (bHitObject || last_p.contains(p_tmp)) {
				bHitObject = true;
				p1.x = mRover.mX+iVX;
				p1.y = mRover.mY;			    
				bHitObject = checkPixels(p1.x, p1.y,
							 mRover.mWidth, mRover.mHeight,0,0);
				if (bHitObject || last_p.contains(p_tmp)) {
				    p1.x = mRover.mX+iVX;
				    p1.y = mRover.mY-iVY;
				    bHitObject = true;
				    bHitObject = checkPixels(p1.x, p1.y,
							 mRover.mWidth, mRover.mHeight,0,0);
				  
				if (bHitObject || last_p.contains(p_tmp)) {
				    p1.x = mRover.mX-iVX;
				    p1.y = mRover.mY+iVY;
				    bHitObject = true;
				    bHitObject = checkPixels(p1.x, p1.y,
							     mRover.mWidth, mRover.mHeight,0,0);
				      
				    if (bHitObject || last_p.contains(p_tmp)) {
					p1.x = mRover.mX-iVX;
					p1.y = mRover.mY;
					bHitObject = true;
					bHitObject = checkPixels(p1.x, p1.y,
							     mRover.mWidth, mRover.mHeight,0,0);
					  
					if (bHitObject || last_p.contains(p_tmp)) {
					    p1.x = mRover.mX;
					    p1.y = mRover.mY-iVY;
					    bHitObject = true;
					    bHitObject = checkPixels(p1.x, p1.y,
							     mRover.mWidth, mRover.mHeight,0,0);
					      
					    if (bHitObject || last_p.contains(p_tmp)) {
						iVX = -iVX; iVY=-iVY;
					    }
					    else {iVX=0; iVY=-iVY;}
					    
					    
					}
					else {iVX = -iVX; iVY=0;}
				    }
				    
				    else iVX = -iVX;
				}
				else iVY=-iVY;
			    }
			    else iVY =0;
			}
			
			else iVX =0;
		    }
		    }
		    
		    if( (iVX==0) && (iVY != 0))
		    {
			p1.x = mRover.mX;
			p1.y = mRover.mY+iVY;
			bHitObject = checkPixels(p1.x, p1.y,
					     mRover.mWidth, mRover.mHeight,0,0);
			if (bHitObject || last_p.contains(p_tmp)) {
			    bHitObject = true;
			    p1.x = mRover.mX+1;
			    p1.y = mRover.mY+iVY;			
			    bHitObject = checkPixels(p1.x, p1.y,
						 mRover.mWidth, mRover.mHeight,0,0);

			  
			if (bHitObject || last_p.contains(p_tmp)) {
			    bHitObject = true;
			    p1.x = mRover.mX-1;
			    p1.y = mRover.mY+iVY;			    
			    bHitObject = checkPixels(p1.x, p1.y,
						     mRover.mWidth, mRover.mHeight,0,0);

			      
			    if (bHitObject || last_p.contains(p_tmp)) {
				bHitObject = true;
				p1.x = mRover.mX+1;
				p1.y = mRover.mY;
				bHitObject = checkPixels(p1.x, p1.y,
							 mRover.mWidth, mRover.mHeight,0,0);
				  
				if (bHitObject || last_p.contains(p_tmp)) {
				    bHitObject = true;
				    p1.x = mRover.mX-1;
				    p1.y = mRover.mY;
				    bHitObject = checkPixels(p1.x, p1.y,
							     mRover.mWidth, mRover.mHeight,0,0);
				      
				    if (bHitObject || last_p.contains(p_tmp)) {

					p1.x = mRover.mX+1;
					p1.y = mRover.mY-iVY;
					bHitObject = true;
					bHitObject = checkPixels(p1.x, p1.y,
							     mRover.mWidth, mRover.mHeight,0,0);
					  
					if (bHitObject || last_p.contains(p_tmp)) {
					    p1.x = mRover.mX-1;
					    p1.y = mRover.mY-iVY;
					    bHitObject = true;
					    bHitObject = checkPixels(p1.x, p1.y,
							     mRover.mWidth, mRover.mHeight,0,0);

					  
					if (bHitObject || last_p.contains(p_tmp)) {
						iVX = 0; iVY=-iVY;
					    }
					    else {iVX=-1; iVY=-iVY;}
					    
					    
					}
					else {iVX = +1; iVY=-iVY;}
				    }
				    
				    else {iVX = -1; iVY=0;}
				}
				else {iVX=1; iVY=0;}
			    }
			    else iVX =-1;
			}
			
			else iVX =1;
		    }
		    }

		    else
		    {
		    p1.x = mRover.mX+iVX;
		    p1.y = mRover.mY;
		    bHitObject = checkPixels(p1.x, p1.y,
					     mRover.mWidth, mRover.mHeight,0,0);
		      
		    if (bHitObject || last_p.contains(p_tmp)) {
			bHitObject = true;
			p1.x = mRover.mX+iVX;
			p1.y = mRover.mY+1;
			bHitObject = checkPixels(p1.x, p1.y, 
						 mRover.mWidth, mRover.mHeight,0,0);
			  
			if (bHitObject || last_p.contains(p_tmp)) {

			    bHitObject = true;
			    p1.x = mRover.mX+iVX;
			    p1.y = mRover.mY-1;
			    
			    bHitObject = checkPixels(p1.x, p1.y,
						     mRover.mWidth, mRover.mHeight,0,0);
			      
			    if (bHitObject || last_p.contains(p_tmp)) {
				bHitObject = true;
				p1.x = mRover.mX;
				p1.y = mRover.mY+1;
				bHitObject = checkPixels(p1.x, p1.y, 
							 mRover.mWidth, mRover.mHeight,0,0);
				  
				if (bHitObject || last_p.contains(p_tmp)) {
				    p1.x = mRover.mX;
				    p1.y = mRover.mY-1;
				    bHitObject = true;
				    bHitObject = checkPixels(p1.x, p1.y,
							     mRover.mWidth, mRover.mHeight,0,0);
				      
				    if (bHitObject || last_p.contains(p_tmp)) {
					bHitObject = true;
					p1.x = mRover.mX-iVX;
					p1.y = mRover.mY+1;
					bHitObject = checkPixels(p1.x, p1.y,
							     mRover.mWidth, mRover.mHeight,0,0);

					if (bHitObject || last_p.contains(p_tmp)) {
					    p1.x = mRover.mX-iVX;
					    p1.y = mRover.mY-1;
					    bHitObject = true;
					    bHitObject = checkPixels(p1.x, p1.y, 
							     mRover.mWidth, mRover.mHeight,0,0);

					      
					    if (bHitObject || last_p.contains(p_tmp)) {
						iVX = -iVX; iVY=0;
					    }
					    else {iVX=-iVX; iVY=-1;}
					    
					    
					}
					else {iVX = -iVX; iVY= +1;}
				    }
				    
				    else {iVX = 0; iVY=-1;}
				}
				else {iVX=0; iVY=1;}
			    }
			    else iVY =-1;
			}
			
			else iVX =1;
		    }
		    }
		    
		    /*
		    // Check whether we have reached the boundaries.
		    if ((mRover.mX + mRover.mWidth >= 511) || (mRover.mX <= 0))
		     iVX = -iVX;
		    if ((mRover.mY + mRover.mHeight >= 511) || (mRover.mY <= 0))
			iVY = -iVY;
			*/
		    Direction =0;
		    if( iVX==0 && iVY==-1) Direction = North;
		    if( iVX==0 && iVY==1) Direction = South;
		    if( iVX==1 && iVY==0) Direction = East;
		    if( iVX==-1 && iVY==0) Direction = West;
		    if( iVX==1 && iVY==-1) Direction = NE;		    
		    if( iVX==-1 && iVY==-1) Direction = NW;		    
		    if( iVX==-1 && iVY==1) Direction = SW;		    
		    if( iVX==1 && iVY==1) Direction = SE;

		    last_p.addElement(p_tmp);
		    //p_tmp = null;
		    mRover.move(Direction); // Calls repaint()

		}
		//last_p.removeAllElements();
	    // Go to sleep for a while.  This gives the User Interface
		// a chance to repaint itself.
	    }	    
	    
	}
    }
    
	
    // Check whether background image has any red(0) pixels or green(1) in the given area.
    boolean checkPixels(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;
	
        // 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");
      gemFound++;
      accvalue=accvalue+gem[k1].size();
       System.out.println("Total Gem Value =  "+accvalue);
      pickedup[k1]=1;
      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");
      gemFound++;
      accvalue=accvalue+gem[k1].size();
       System.out.println("Total Gem Value =  "+accvalue);
      pickedup[k1]=1;
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");
      gemFound++;
      accvalue=accvalue+gem[k1].size();
       System.out.println("Total Gem Value =  "+accvalue);
      pickedup[k1]=1;
      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");
      gemFound++;
      accvalue=accvalue+gem[k1].size();
       System.out.println("Total Gem Value =  "+accvalue);
      pickedup[k1]=1;
      return true;
      }
  
  }
                        }
 
                        //          }
                   
                }
                //   end of dealing with gem pickup
                }
                else {
                if (iRed == 255 && iGreen == 0 && iBlue == 0) {
                    //System.out.println("Collision detected.");
                    return true;
                }
                }
        }
        //--------------
        //
        /*
        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 == 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();
		    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");
	repaint(); 
	return true;
    } //end of scanobj
   
static public double dis_2(Point p1, Point p2)
    {
	return( (((double)p1.x - (double)p2.x)*((double)p1.x -(double) p2.x)+
		 ((double)p1.y - (double)p2.y)*((double)p1.y -(double) p2.y))*
		(((double)p1.x - (double)p2.x)*((double)p1.x -(double) p2.x)+
		 ((double)p1.y - (double)p2.y)*((double)p1.y -(double) p2.y))
		);
    } 
}
// A simple Rover class.
class Rover {
public int mX, mY, mWidth, mHeight;
    pppp mApplet;
    static final int North=0,South=1,East=2,West=3,NE=4,NW=5,SE=6,SW=7;
    
public Rover(pppp applet) {
	mX = mY = 0;
	mWidth = 30;
	mHeight = 20;
	mApplet = applet;
    }


    
public void move(int dir) {

	switch (dir){
	case North : mY--; break;
	case South : mY++; break;
	case East :  mX++; break;
	case West :  mX--; break;
	case NE :    mX++;  mY--; break;
	case NW :    mX--; mY--; break;
	case SW :    mX--; mY++; break;
	case SE :    mX++; mY++; break;
	default: break;    
	}
	
	mApplet.repaint();
    }
    
}