import java.applet.Applet;
import java.awt.*;
import java.util.Random;
import java.lang.Runnable;

public class Game extends Applet  {
	boolean loopFlag [] = {false, false, false, false};
	Graphics g;
//	Image offScrImage = createImage (size().width, size().height); //Image(size().width, size().height);
	int temp;
	int grid ; //how many pieces in the grid
	int square ; //how big is each one
	int score=0; //score this move
	int [] player = new int [2]; //player scores
	int whosegoisit=0;
	int length=0; //the thing which makes you get more points the longer your loop is
	int moves=0; //moves so far this game
	int [][] gateX = new int[4][2];
	int [][] gateY = new int[4][2];
	Piece [][] theGrid = new Piece [64][64];
	int xpiece, ypiece;
	int downX, downY;
	Graphics tempg;
	Image tempImage;
	boolean firstime = true;

//***********************************************************
// INIT  INIT  INIT  INIT  INIT  INIT  INIT  INIT  INIT  INIT

  public void init()  {
	  int tmp;
	  Random rnums = new Random();
	  g = getGraphics();
	  
	  tempImage=createImage (size().width, size().height);
	  tempg = tempImage.getGraphics();

//	  offScrg = offScrImage.getGraphics();
	  grid = Integer.parseInt(getParameter("squares"));
	  square = Integer.parseInt(getParameter("size"));


// Define shape of pieces
	  // down-to-the-right polygon
	  gateX[0][0] = square/2-square/6;
	  gateX[1][0] = square	 ;
	  gateX[2][0] = square/2+square/6;
	  gateX[3][0] = 1;

	  gateY[0][0] = 1;
	  gateY[1][0] = square/2-square/6;                                                                   ;
	  gateY[2][0] = square;
	  gateY[3][0] = square/2+square/6;

	  // up-to-the-left polygon
	  gateX[0][1] = square/2+square/6;
	  gateX[1][1] = square	 ;
	  gateX[2][1] = square/2-square/6;
	  gateX[3][1] = 1;

	  gateY[0][1] = 1;
	  gateY[1][1] = square/2+square/6;
	  gateY[2][1] = square;
	  gateY[3][1] = square/2-square/6;


// set starting colours
	  for (int i=0; i<grid; i++) {
		for (int j=0; j<grid; j++){
			theGrid[i][j] = new Piece();

			/*  unneccessaryy I recckon (hope)
			theGrid[i][j].hue[0]=rgbness();
			theGrid[i][j].hue[1]=rgbness();
			theGrid[i][j].hue[2]=rgbness();
			theGrid[i][j].hue[3]=rgbness();
*/

			if ((i==grid/2)&&(j==grid/2))   //  empty centre
				theGrid[i][j].Create(-1, -1, -1, -1, 0, false);
			else {
				switch (Math.abs(rnums.nextInt())%8) {
				case (0) : 	  //  diagonal
					theGrid[i][j].Create(1, 0, -1, -1, 1, false);
					break;

				case (1) : 	  //  diagonal
					theGrid[i][j].Create(1, 0, -1, -1, 1, false);
					break;
						 
				case (2) : 	  //   double diagonal
					theGrid[i][j].Create(1, 0, 3, 2, 2, false);
					break;

				case (3) : 	 //  double diagonal
					theGrid[i][j].Create(1, 0, 3, 2, 2, false);
					break;
						 
				case (4) : 	 //  double diagonal
					theGrid[i][j].Create(1, 0, 3, 2, 2, false);
					break;
						 
				case (5) : 	 //  double diagonal
					theGrid[i][j].Create(1, 0, 3, 2, 2, false);
					break;
						 
				case (6) : 	  //  cross
					theGrid[i][j].Create(2, 3, 0, 1, 2, true);
					break;
						 
				case (7) : 	 //  vertical line
					theGrid[i][j].Create(2, -1, 0, -1, 1, false);
					break;
						 
				default :
					theGrid[i][j].Create(-1, -1, -1, -1, 0, false);
					break;
				}

				theGrid[i][j].rotate(Math.abs(rnums.nextInt())%4);
			}	
		}
	}
	for ( int i=0; i<grid; i++) {
		for ( int j=0; j<grid; j++){
			for ( int gate=0; gate<4; gate++){
				if ((theGrid[i][j].hue[gate]==0) && (theGrid[i][j].conn[gate]!=-1)) {
					int rgb = rgbness();
					colourPath (i, j, gate, rgb,i, j, gate, 0);
					colourPath (i, j, theGrid[i][j].conn[gate], rgb, i, j, theGrid[i][j].conn[gate], 0 );
				}
			}
		}
	}


  }//end init


  /*
  ColourPath(int i, int j, int gate, int rgb, int p, int q, int r, int length) {
// may possibly return length if it's a loop, or -length if it's not.
	if ((length==0)||(i!=p)||(j!=q)||(theGrid[i][j].conn[gate]!=r))
		if ((length==0)||(i!=p)||(j!=q)||(gate!=r)) {


	// make it coloured
	theGrid[i][j].hue[gate]=rgb;
		int tmp = theGrid[i][j].conn[gate];
	// and colour it.
	if (tmp != -1)
		theGrid[i][j].hue[tmp]=rgb;
//	if (!(firstime))
		drawStep(tempg, i, j, gate);
		if (theGrid[i][j].cross)
			drawStep(tempg, i, j, (gate+1)%4);


	switch (theGrid[i][j].conn[gate]) {
		case -1 :
			// return (-length);
			break;
		case 0 :
			if (j != 0) {
			colourPath (i, j-1, 2, rgb, p, q, r, length);}
		break;
		case 1 :
			if (i != (grid-1)) {
			colourPath (i+1, j, 3, rgb, p, q, r, length);}
		break;
		case 2 :
			if (j != (grid-1)) {
			colourPath (i, j+1, 0, rgb, p, q, r, length);}
		break;
		case 3 :
			if (i != 0) {
			colourPath (i-1, j, 1, rgb, p, q, r, length);}
		break;
	}

	}

}
*/
//***************  colourPath
void colourPath(int i, int j, int gate, int rgb, int p, int q, int r, int delta) {
// may possibly return length if it's a loop, or -delta if it's not.

	if ((delta==0)||(i!=p)||(j!=q)||(theGrid[i][j].conn[gate]!=r))
		if ((delta==0)||(i!=p)||(j!=q)||(gate!=r)) {
		delta++; //and i'm not sure what happens to this.
		
	// make it coloured
	theGrid[i][j].hue[gate]=rgb;
	int tmp = theGrid[i][j].conn[gate];
	// and colour it.
	if (tmp != -1)
		theGrid[i][j].hue[tmp]=rgb;
//	if (!(firstime))
		drawStep(tempg, i, j, gate);
		if (theGrid[i][j].cross)
			drawStep(tempg, i, j, (gate+1)%4);

		// next piece
		if (tmp!=-1) {
			int [] link=nextGate(i,j,tmp);
			if (link[0]!=-1)
				colourPath(link[0], link[1], link[2], rgb, p, q, r, delta);
		}
		
	}
  }//end colourPath



void runPath(int i, int j, int gate, int rgb, int p, int q, int r, int length) {
// i,j = current piece. gate = outwards gate.  (rgb) p,q,r = original piece (so you kow when to stop)
// may possibly return length if it's a loop, or -length if it's not.
//I don't think this even gets called.
	if ((length==0)||(i!=p)||(j!=q)||(theGrid[i][j].conn[gate]!=r))
		if ((length==0)||(i!=p)||(j!=q)||(gate!=r)) {


	switch (theGrid[i][j].conn[gate]) {
		case -1 :
			// return (-length);
			break;
		case 0 :
			if (j != 0) {
			colourPath (i, j-1, 2, rgb, p, q, r, length);}
		break;
		case 1 :
			if (i != (grid-1)) {
			colourPath (i+1, j, 3, rgb, p, q, r, length);}
		break;
		case 2 :
			if (j != (grid-1)) {
			colourPath (i, j+1, 0, rgb, p, q, r, length);}
		break;
		case 3 :
			if (i != 0) {
			colourPath (i-1, j, 1, rgb, p, q, r, length);}
		break;
	}

	// after recursing back, check the other direction.
	gate = theGrid[i][j].conn[gate];
	if (gate != -1)
		theGrid[i][j].hue[gate] = rgb;
	// return length;
	}
// return length;  //hmm. return length again.

}

  /*****************MOUSEDOWN***************************/

  public boolean mouseDown (Event e, int x, int y) {
	  downX=x/square;
	  downY=y/square;
	  return true;
  }



  /****************MOUSEUP****************************/
  
  public boolean mouseUp (Event e, int x, int y) {
	  xpiece=x/square;
	  ypiece=y/square;
	  Piece tmpPiece;
		
		length=1;
		moves++;
	  
	  if ((xpiece==downX) && (ypiece==downY))

			theGrid[xpiece][ypiece].rotate(1);

	  else {
		  // if mousedown and mouseup in the same row or column,
		  if ( ((xpiece==downX) || (ypiece==downY)) && ((theGrid[downX][downY].roads<=0) || (theGrid[xpiece][ypiece].roads<=0)) ){
		    // make emptyX/Y the empty piece (because emptyPath needs its first piece to be empty)
			int fullX=downX;
			int fullY=downY;
			int emptyX=xpiece;
			int emptyY=ypiece;

			if (theGrid[downX][downY].roads<=0) {
				emptyX=downX; 
				emptyY=downY;
				fullX=xpiece;
				fullY=ypiece;	
			}
			
			if (emptyPath(emptyX, emptyY, fullX, fullY)) {
				//swap them
					tmpPiece = theGrid[xpiece][ypiece];
					theGrid[xpiece][ypiece] = theGrid[downX][downY];
					theGrid[downX][downY]=tmpPiece;
			  }
			 // else   
	  }
		  //else
	  }


		//*************************
	  // colour what new strings we've just made (or not)
	  for ( int gate=0; gate<4; gate++){

		if (theGrid[xpiece][ypiece].conn[gate]!=-1) {
			// colour the string from the current gate
			colourPath (xpiece, ypiece, gate, theGrid[xpiece][ypiece].hue[gate],xpiece, ypiece, gate,0);
			colourPath (xpiece, ypiece, theGrid[xpiece][ypiece].conn[gate], theGrid[xpiece][ypiece].hue[gate], xpiece, ypiece, theGrid[xpiece][ypiece].conn[gate], 0 );
		}
		
		if ((downX != xpiece) || ( downY != ypiece)) {
			if (theGrid[downX][downY].conn[gate]!=-1) {
				colourPath (downX, downY, gate, theGrid[downX][downY].hue[gate],downX, downY, gate,0);
				colourPath (downX, downY, theGrid[downX][downY].conn[gate], theGrid[downX][downY].hue[gate], downX, downY, theGrid[downX][downY].conn[gate], 0 );
			}
		}

	  }//finished colouring
	repaint();

	return true;
  } //     end mouseUp

	  
/*****************************************************/


boolean emptyPath (int i, int j, int p,int q) {
	//i and j are assumed empty, p and q are full.
	// plusx and plusy resolve to +1, -1, or (if divide by zero) 0
	int plusx=0;
	int plusy=0;
	if (p!=i)
		plusx=(p-i)/Math.abs(p-i);
	if (q!=j)
		plusy=(q-j)/Math.abs(q-j);

	boolean temp=false;

	if ((i+plusx==p) && (j+plusy==q)) 
			temp = true;
		
		else
			if (theGrid[i+plusx][j+plusy].roads<=0)
			temp=emptyPath(i+plusx,j+plusy, p, q);	


	return temp;
}

  /*****************************************************/
	//update, which calls paint and erases any whole loops
  
  public void update(Graphics g) {
	
	  //paint(g); I wonder why this was here?
	  int gridX = xpiece;
	  int gridY = ypiece;

	tempg.setColor(Color.black);
	for (int gate=0; gate<4; gate++)
		if (Loop(xpiece, ypiece, gate)) { //make it gone
			colourPath(gridX, gridY, gate,0, gridX, gridY, gate,0);
			eraseLoop(tempg, gate);
								  
  }
  paint(g);

  }
  
  /***********************************************/

  void checkSquare (int i, int j) {
	  		tempg.setColor(Color.black);
			tempg.fillRect(square*i+1, square*j+1, square-1, square-1);

			// empty square
			if (theGrid[i][j].roads<=0) {

				} else {
				for (int k=0; k<4; k++) {
					if (theGrid[i][j].conn[k]>k) {
						drawConnect(tempg,i,j,k, i, j, k);
					}
				}
			} 
  }


  /***********************************************/
  
  void checkBoard ()  {

	  if (firstime)  {
	  for (int i=0; i<grid; i++)  
		for (int j=0; j<grid; j++)   
			checkSquare(i,j);
	  }

	  else	{
		  checkSquare (xpiece,ypiece );
		  if (ypiece!=0) checkSquare (xpiece, ypiece-1);
		  if (ypiece!=grid-1) checkSquare (xpiece, ypiece+1);
		  if (xpiece!=0) checkSquare (xpiece-1,ypiece);
		  if (xpiece!=grid-1) checkSquare (xpiece+1, ypiece);

		  if ((downX != xpiece) || ( downY != ypiece)) {
			  checkSquare (downX, downY);
			  if (downY!=0) checkSquare (downX, downY-1);
			  if (downY!=grid-1) checkSquare (downX, downY+1);
			  if (downX!=0) checkSquare (downX-1,downY);
			  if (downX!=grid-1) checkSquare (downX+1, downY);

		  }



	  }

	firstime=false;
  }
		 


  /****************************************************/
  //PAINT  PAINT  PAINT  PAINT  PAINT  PAINT  PAINT  PAINT  
  
  public void paint (Graphics g)  {
	  int tmp1, i1, j1;
  

	checkBoard();
	player[whosegoisit]=player[whosegoisit]+score;
	score=0;
	
	whosegoisit++;  //  next player
	if (whosegoisit>1)
		whosegoisit=0;
		
		//now there should be some way of changing the cursur colour...
		
    //  draw current score
  tempg.setColor (Color.blue);
  tempg.fillRect(grid*square, 0,  200, 35);
  tempg.setColor (Color.black);
  tempg.fillRect(grid*square, 35,  200, 35);
  tempg.setColor (Color.red);
  tempg.fillRect(grid*square, 70,  200, 35);
  tempg.setFont (new Font("TimesRoman", Font.BOLD, 16));
  tempg.setColor (Color.black);
  tempg.drawString(String.valueOf(player[0]), grid*square+2, 20);
	if (whosegoisit==0)
	  tempg.setColor (Color.blue);
		else
	  tempg.setColor (Color.red);
	tempg.drawString(String.valueOf(moves), grid*square+10, 55);
  tempg.setColor (Color.black);
	tempg.drawString(String.valueOf(player[1]), grid*square+2, 90);
	

  g.drawImage (tempImage,0,0,null);
  }  //end of paint 
	
  /****************** nextGate ***************************/
 // which returns the address of the gate joining the one it is given.
  int [] nextGate (int i, int j, int gate) {
	  int [] temp = {-1, -1, -1};

	  	switch (gate) {
		case 0 : 
			if (j!=0) {
				temp[0]=i;
				temp[1]=j-1;
				temp[2]=2;
			}
			break;
		case 1 :
			if (i!=grid-1) {
				temp[0]=i+1;
				temp[1]=j;
				temp[2]=3;
			}
			break;
		case 2 :
			if (j!=grid-1) {
				temp[0]=i;
				temp[1]=j+1;
				temp[2]=0;
			}
			break;
		case 3 :
			if (i!=0) {
				temp[0]=i-1;
				temp[1]=j;
				temp[2]=1;	
			}
			break;
		default :
			break;
		}
		return temp;
  }
 
  
  
  
  /********************* drawStep *****************************/
// draw an actual line
  void drawStep(Graphics graf, int i, int j, int k) {
	int red, green, blue;
	int i1 = square*i;
	int j1 = square*j;
	if (theGrid[i][j].conn[k]!=-1) {
		int [] xarray = {i1+gateX[k][0], i1+gateX[k][1], i1+gateX[theGrid[i][j].conn[k]][0], i1+gateX[theGrid[i][j].conn[k]][1]};
		int [] yarray = {j1+gateY[k][0], j1+gateY[k][1], j1+gateY[theGrid[i][j].conn[k]][0], j1+gateY[theGrid[i][j].conn[k]][1]};

	red= theGrid[i][j].hue[k] /0x10000;
	green= theGrid[i][j].hue[k] %0x10000 /0x100;
	blue= theGrid[i][j].hue[k] %0x100;
	graf.setColor(new Color(red, green, blue));
	graf.fillPolygon(xarray, yarray, 4);

   	}

  }//end drawstep


  /**************************************************/
  
  boolean Loop (int i, int j, int gate) {
		boolean lflag = false;

		if (theGrid[i][j].conn[gate]!=-1) {
			int [] link = nextGate(i,j,gate);
			if (link[0]!=-1)        // ie there is a next gate
				lflag = Connect(link[0], link[1], link[2], i, j, gate);
		}

		return lflag;  //which is the same as cflag in Connect(...)
	}


  /*****************************************************/
  
  //  The recursive thing which runs around loops.
  //  i,j are the current square, g is the gate we're checking
  //  p, q 
  
  boolean Connect (int i, int j, int g, int p, int q, int r) {
		boolean cflag = false;

		if (((i==p)&&(j==q))&&(theGrid[i][j].conn[g]==r))
			cflag=true;	//  this is the original square. LOOP!
		else if (((i==p)&&(j==q))&&(g==r))
			cflag=true;	//  this is the original square. LOOP!
		else {
			int [] link = nextGate(i,j,theGrid[i][j].conn[g]);
			if (link[0]!=-1)
				cflag = Connect(link[0], link[1], link[2], p, q, r);	
		}
		return cflag;

	}



/****************************************************/

void drawLoop (Graphics g, int gate) {
	int i = xpiece;
	int j = ypiece;
	int tmp = 3;

	if (theGrid[i][j].conn[gate]!=-1) {
		drawStep(g, i, j, gate);
		int [] link = nextGate(i, j, gate);
		if (link[0] != -1)
			colourPath(link[0], link[1], link[2],theGrid[i][j].hue[gate], i, j, gate,0);

	}
//	how to find out if this score is changing?
//	score = score +(tmp*tmp);
}
	
/****************************************************/

void eraseLoop (Graphics g, int gate) {
	int i = xpiece;
	int j = ypiece;
	score++;

	if (theGrid[i][j].conn[gate]!=-1) {
		theGrid[i][j].conn[theGrid[i][j].conn[gate]]=-1;
		theGrid[i][j].conn[gate]=-1;
		theGrid[i][j].roads--;
		theGrid[i][j].cross=false;
				
		int [] link = nextGate(i, j, gate);
		if (link[0] != -1)  // ie there is a link
				eraseConnect(g, link[0], link[1], link[2], i, j, gate);
	}
}
	

/****************************************************/

void drawConnect(Graphics g, int i, int j, int gate, int p, int q, int r) {
//  i,j, gate is where we are now; p, q, r is where we started. maybe

	drawStep(g, i, j, gate);

	if ((i!=p)||(j!=q)||(theGrid[i][j].conn[gate]!=r))
		if ((i!=p)||(j!=q)||(gate!=r)) {
			int [] link = nextGate(i, j, theGrid[i][j].conn[gate]);
			if (link[0]!=-1)
					drawConnect(g, link[0], link[1], link[2], p,q,r);
		}
		
	}


/****************************************************/

void eraseConnect(Graphics g, int i, int j, int gate, int p, int q, int r) {
	int temp;
	// temp and gate are the two ends of the line
	temp=theGrid[i][j].conn[gate];
	if (temp!=-1) {
		theGrid[i][j].conn[temp]=-1;
		theGrid[i][j].conn[gate]=-1;
		theGrid[i][j].roads--;
		theGrid[i][j].cross=false;
		
		length++;  //exponential score increase
		if (length>4)
			score=score+((length-3)/2);

		if ((i!=p)||(j!=q)||(temp!=r))
			if ((i!=p)||(j!=q)||(gate!=r)) {
				int [] link = nextGate(i, j, temp);
				if (link[0]!=-1)
					eraseConnect(g, link[0], link[1], link[2], p,q,r);
			}
	}
}

/***********************************************************/

//random colours
 int rgbness()  {//random colours 

	 float hue = (float)(Math.random());
	 float saturation = (float) (0.9+Math.random()/10.0);
	 float brightness = (float) (0.75+Math.random()/4.0);//(1.0-Math.pow(Math.random(),3.0));//

return (Color.HSBtoRGB(hue, saturation, brightness));

}
}   /***  end Game ***/


/****************************************************/


class Piece extends Game {
	int roads;
	boolean cross;
	int [] conn = new int[4];
	int [] hue = {0,0,0,0};
	int [] tempConn = new int[4];
	int [] tempHue = new int[4];

	void rotate (int rotation) {
	  for (int i=0; i<4; i++) {
		  if (conn[((i-rotation)+32)%4] == -1) 
			tempConn[i] = -1;
			else 
				tempConn[i] = (conn[((i-rotation)+32)%4]+rotation)%4;
		tempHue[(i+rotation+64)%4]=hue[i];
	  }
	  for (int i=0; i<4; i++) {
		  conn[i] = tempConn[i];
		  hue[i] = tempHue[i];
	  }
	}

	//************* Create
	//sets up a piece
	void Create(int i, int j, int m, int n, int r, boolean c) {
		conn[0] = i;
		conn[1] = j;
		conn[2] = m;
		conn[3] = n;
		cross=c;
		roads=r;

		/*for (int gate=0; gate<3; gate++) {
			if (conn[gate]!=-1) {
				hue[conn[gate]]=hue[gate];
			}
	
	  }
*/
	} //end create




} //end Piece