/*
Pente.java 	
This code was written by Chris Scott and Max Jacobs 
May 6, 1996.
*/

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

public class Pente extends Applet implements Runnable {

// MATRIX STATES
  final int BLUE =  1;	
  final int RED_TAN = -1;
  final int EMPTY =  0;
  final int ERASED = 2;

  protected Image[] images;
  protected MediaTracker tracker;

  boolean gameOver;
  boolean thirdMove;

  // Width of the board<br>
  final int WIDTH = 570;
    
  // Directions
  private final int UPPER 	= 0;
  private final int LOWER 	= 1;
  private final int RIGHT 	= 2;
  private final int LEFT  	= 3;
  private final int UPPERLEFT 	= 4;
  private final int UPPERRIGHT	= 5;
  private final int LOWERRIGHT	= 6;
  private final int LOWERLEFT	= 7;
  boolean direction[] = 
    {false, false, false, false, false, false, false, false};
  
  // Player Turn.
  public int turn;

  // count of captures
  public int paircount_blue;  
  public int paircount_red_tan;  

  public int f = 0, g = 0;



  //The board. 19 x 19 matrix
  protected int stone[][];


  // Computer player
  PentePlayer computer;


  Frame p;  //pop up window
  Panel P;  // panel in window

  boolean gameOne = true;

  int randomNum, x;
  Button button;  // reset button
  TextArea outputarea;  // text area
  final int fieldsize = 35;  // text area width in chars
//----------------------------------------------------
// do this once when Pente is started

  public void layoutStuff(){

    int x, y=1;
    outputarea = new TextArea(12, fieldsize);
    outputarea.setEditable(false);
 //   this.setLayout(new BorderLayout());
    p = new Frame("P E N T E    W I N D O W");    
    p.setLayout(new BorderLayout(2,1));
    P = new Panel();
    P.setLayout(new FlowLayout());
    button = new Button("Restart");
    this.add(p);
    P.add(button);
    p.add("North",outputarea);
    p.add("South",P);
    p.pack();
    p.show();
    outputarea.appendText("           Welcome to Pente v1.0 \n ------------------------------ \n\n ");
    outputarea.appendText(" RULE: You must move outside the\n     2-block radius of the initial blue \n     stone for your first move!\n\n");

// IMAGE STUFF
   tracker = new MediaTracker(this);
   images = new Image[5];
   for (x=0; x < 5; x++){
      images[x] = this.getImage(this.getDocumentBase(), y + ".gif");
      tracker.addImage(images[x], y);
      y++;
   }

  }



//----------------------------------------------------
  public void init() {
    AudioClip intro;

    gameOver = false;
    thirdMove = false;
    paircount_blue = 0;  
    paircount_red_tan = 0;  

    if (gameOne) {
	layoutStuff();
	gameOne = false;
    }
    stone = new int[19][19];

    int q,r;    
    for (q = 0; q < 19; q++) {
      for (r = 0; r < 19; r++) {
	stone[q][r] = ERASED;
      }
    }
    repaint();
    stone[9][9] = BLUE;    /* SET BLUE PIECE IN THE MIDDLE OF THE 
			       * BOARD; 4/29 
			       */  

    randomNum = (int)(Math.random() * 8);
    red_tanFirstMove(randomNum);
    thirdMove = true;

    turn = BLUE;		/* MAX CHANGED THIS FROM BLUE: 5/3 */
    
    computer = new PentePlayer(this);	
    intro = getAudioClip(getCodeBase(), "./play_a_g.au");

    intro.play();
  }
  
//----------------------------------------------------

  public void red_tanFirstMove(int randNum) {
  outputarea.appendText("\n Computer: 1st move \n\n");
    if (randNum == 0) {
	stone[8][8] = RED_TAN;
	f=8; g=8;
	}
    else if (randNum == 1) {
	stone[9][8] = RED_TAN;
	f=9; g=8;	
	}
    else if (randNum == 2) {
	stone[10][8] = RED_TAN;
	f=10; g=8;	
	}
    else if (randNum == 3) {
	stone[8][9] = RED_TAN;
	f=8;
	g=9;		}

    else if (randNum == 4) {
	stone[10][9] = RED_TAN;
	f=10;
	g=9;		}

    else if (randNum == 5) {
	stone[8][10] = RED_TAN;
	f=8;
	g=10;		}

    else if (randNum == 6) {
	stone[9][10] = RED_TAN;
	f=9;
	g=10;		}

    else if (randNum == 7){
	stone[10][10] = RED_TAN;
	f=10;
	g=10;		}
   }

//----------------------------------------------------
  public void paint(Graphics g) {

    drawBoard(g);  
    for(int i = 0; i < 19; i++){
      for(int j = 0; j < 19; j++){
	if (stone[i][j] != 0){
	  drawStone(i, j, g);
	  if (stone[i][j] == 2){
	    stone[i][j] = 0;
	  }
	}
      }
    }
    
    drawCountStone(g);

  }
  

//----------------------------------------------------
// Draw the Pente board<br>

  public void drawBoard (Graphics g) {
    g.setColor(new Color(179, 179, 126)); //color = khaki
    setBackground(g.getColor());
    
    g.setColor(Color.black);
    g.drawLine(0,0, 0,WIDTH);		
    g.drawLine(WIDTH,0, WIDTH,WIDTH);	
    g.drawLine(0,0, WIDTH,0);		
    g.drawLine(0,WIDTH, WIDTH,WIDTH);	

    g.setColor(Color.white);
    g.drawLine(0,1, 0,WIDTH+1);		
    g.drawLine(WIDTH,1, WIDTH,WIDTH+1);	
    g.drawLine(0,1, WIDTH,1);		
    g.drawLine(0,WIDTH+1, WIDTH,WIDTH+1);
    for(int i = 1; i < 19; i++){
      g.drawLine(WIDTH*i/19 + 1,0, WIDTH*i/19 + 1,WIDTH);
      g.drawLine(0,WIDTH*i/19 + 1, WIDTH,WIDTH*i/19 + 1);
    }
    g.setColor(Color.black);
    for(int i = 1; i < 19; i++){
      g.drawLine(WIDTH*i/19,0, WIDTH*i/19,WIDTH);
      g.drawLine(0,WIDTH*i/19, WIDTH,WIDTH*i/19);
    }
  }
  

//----------------------------------------------------
 // Paint stones on the board.<br>

  public void drawStone(int column, int row, Graphics g) {
  
   if (stone[column][row] != 2){
    if (!gameOver){
      if (stone[column][row] == RED_TAN){
          g.drawImage(images[1], column * WIDTH / 19 + 1, row * WIDTH/19 + 1, this);
      } else {
          g.drawImage(images[0], column * WIDTH / 19 + 1, row * WIDTH/19 + 1, this);
      }
    } else {  // the game is over --> darken all of the pieces.
      if (stone[column][row] == RED_TAN){
          g.drawImage(images[4], column * WIDTH / 19 + 1, row * WIDTH/19 + 1, this);
      } else {
          g.drawImage(images[3], column * WIDTH / 19 + 1, row * WIDTH/19 + 1, this);
      }
    }
   }else {
          g.setColor(new Color(179, 179, 126)); //color = khaki
          g.drawRect( column * WIDTH / 19 +2, row * WIDTH / 19 +2, 27, 27 );
          g.fillRect( column * WIDTH / 19 +2, row * WIDTH / 19 +2, 27, 27 );
   }
  }
  
  
  

//----------------------------------------------------
  //Display for the number of stones.<br>

  void drawCountStone(Graphics g){
    g.setColor(Color.white);
    g.fill3DRect(WIDTH+15, 160, 60,20, false); 
    g.fill3DRect(WIDTH+15, 410, 60,20, false); //30

    g.drawImage(images[0], WIDTH + 5, 130, this);
    g.drawImage(images[1], WIDTH + 5, 380, this);

     g.setColor(Color.black);
    g.drawString("captures", WIDTH+35, 397);		
    g.drawString("captures", WIDTH+35, 147);
	//---------------------------------------------------
if (paircount_blue == 1) {
		g.drawLine(WIDTH+27,165,WIDTH+25,175);}
	if (paircount_blue == 2) {
		g.drawLine(WIDTH+27,165,WIDTH+25,175);
		g.drawLine(WIDTH+37,165,WIDTH+35,175);}
	if (paircount_blue == 3) {
		g.drawLine(WIDTH+27,165,WIDTH+25,175);
		g.drawLine(WIDTH+37,165,WIDTH+35,175);
		g.drawLine(WIDTH+47,165,WIDTH+45,175);}
	if (paircount_blue == 4) {
		g.drawLine(WIDTH+27,165,WIDTH+25,175);
		g.drawLine(WIDTH+37,165,WIDTH+35,175);
		g.drawLine(WIDTH+47,165,WIDTH+45,175);
		g.drawLine(WIDTH+57,165,WIDTH+55,175);}
	if (paircount_blue > 4) {
		g.drawLine(WIDTH+27,165,WIDTH+25,175);
		g.drawLine(WIDTH+37,165,WIDTH+35,175);
		g.drawLine(WIDTH+47,165,WIDTH+45,175);
		g.drawLine(WIDTH+57,165,WIDTH+55,175);
		g.drawLine(WIDTH+21,166,WIDTH+64,174);}
    // Draw Computer Score
	if (paircount_red_tan == 1) {
		g.drawLine(WIDTH+27,415,WIDTH+25,425);}
	if (paircount_red_tan == 2) {
		g.drawLine(WIDTH+27,415,WIDTH+25,425);
		g.drawLine(WIDTH+37,415,WIDTH+35,425);}
	if (paircount_red_tan == 3) {
		g.drawLine(WIDTH+27,415,WIDTH+25,425);
		g.drawLine(WIDTH+37,415,WIDTH+35,425);
		g.drawLine(WIDTH+47,415,WIDTH+45,425);}
	if (paircount_red_tan == 4) {
		g.drawLine(WIDTH+27,415,WIDTH+25,425);
		g.drawLine(WIDTH+37,415,WIDTH+35,425);
		g.drawLine(WIDTH+47,415,WIDTH+45,425);
		g.drawLine(WIDTH+57,415,WIDTH+55,425);}
	if (paircount_red_tan > 4) {
		g.drawLine(WIDTH+27,415,WIDTH+25,425);
		g.drawLine(WIDTH+37,415,WIDTH+35,425);
		g.drawLine(WIDTH+47,415,WIDTH+45,425);
		g.drawLine(WIDTH+57,415,WIDTH+55,425);
		g.drawLine(WIDTH+21,416,WIDTH+64,424);}
	//---------------------------------------------------		
  }
  

  

//----------------------------------------------------
//----------------------------------------------------

    public boolean action(Event e, Object arg){
	switch(e.id){
	   case Event.ACTION_EVENT:
            if (e.target instanceof Button) {
              String label = (String)arg;
                if (label.equals ("Restart")){
		 init();
                }
	    return true;
	    }
	}
     return false;
     }


//----------------------------------------------------
//----------------------------------------------------
   public boolean mouseUp(Event e, int x, int y) {
    AudioClip winner;
    AudioClip loser;
    AudioClip capt;
    AudioClip mecapt;

    winner = getAudioClip(getCodeBase(), "./burns.au");
    loser = getAudioClip(getCodeBase(), "./nelson.au");
    capt = getAudioClip(getCodeBase(), "./doh.au");
    mecapt = getAudioClip(getCodeBase(), "./woohoo.au");

    int column = (int)(x / (WIDTH / 19));
    int row    = (int)(y / (WIDTH / 19));
    int temp = paircount_red_tan;
    int temp2 = paircount_blue;
    
    if (turn == BLUE) {
  
      if (!gameOver && checkSlot(column, row, turn)==true)
      {
        outputarea.appendText("Your move:  "+row+", "+column+"\n\n");	
        if(check_for_five(column, row, turn)){
	   gameOver=true;
	   winner.play();
           outputarea.appendText("Y O U   W I N! \n You had 5-in-a-row!\n\n");	
	   repaint(1);      
	   return true;
        }
        checkCapture(column, row, turn); 
        if (temp2 < paircount_blue && paircount_blue < 5){
	   mecapt.play();
        }	 
        if (paircount_blue > 4 || paircount_red_tan > 4) {
	   gameOver=true;
	   if (paircount_blue > 4) winner.play();
           outputarea.appendText("Y O U   W I N! \nYou captured 5 computer pairs!\n\n");	
	   repaint(1);   
	   return true;   
        }

	turn = - turn;	


	repaint(1);      
     }
    }

    if (turn == RED_TAN) {
      computer.makeMove(f,g);
      repaint(1);   
      if (temp < paircount_red_tan && paircount_red_tan < 5){
	 capt.play();
        }	 
      if (gameOver==true) loser.play();  

    }

    return true;
  }

//----------------------------------------------------
//----------------------------------------------------
   public boolean checkSlot(int column, int row, int turn)
   {
    if (stone[column][row]==EMPTY && !thirdMove)
    {
      stone[column][row] = turn;
      return true;
    }
    //IF IT'S THE THIRD MOVE, CANNOT PUT PIECE IN 2 SLOT RADIUS
    else if (stone[column][row]==EMPTY && ((column < 7 || column > 11) || 
		(row < 7 || row > 11))) {
      stone[column][row] = turn;
      thirdMove = false;
      return true;
    }
    outputarea.appendText("You have made an illegal move.\n");
    outputarea.appendText("Please choose another move.\n\n");

    return false;
   }

//----------------------------------------------------
   public void update(Graphics g) {
    paint(g);
  }

//----------------------------------------------------
//----------------------------------------------------
public void checkCapture(int col, int row, int color)
{
  if (row > 2 && stone[col][row-1] == -color && stone[col][row-2] == -color
	&& stone[col][row-3] == color)
  {
    changeCaptureCount(color);
    stone[col][row-1] = ERASED;
    stone[col][row-2] = ERASED;
  }
  if (row < 16 && stone[col][row+1] == -color && stone[col][row+2] == -color
	&& stone[col][row+3] == color)
  {		
    changeCaptureCount(color);
    stone[col][row+1] = ERASED;
    stone[col][row+2] = ERASED;
  }
  if (col > 2 && stone[col-1][row] == -color && stone[col-2][row] == -color
	&& stone[col-3][row] == color)
  {
    changeCaptureCount(color);
    stone[col-1][row] = ERASED;
    stone[col-2][row] = ERASED;
  }
  if (col < 16 && stone[col+1][row] == -color && stone[col+2][row] == -color
	&& stone[col+3][row] == color)
  {
    changeCaptureCount(color);
    stone[col+1][row] = ERASED;
    stone[col+2][row] = ERASED;
  }
  if (row > 2 && col > 2 && stone[col-1][row-1] == -color 
	&& stone[col-2][row-2] == -color && stone[col-3][row-3] == color)
  {
    changeCaptureCount(color);
    stone[col-1][row-1] = ERASED;
    stone[col-2][row-2] = ERASED;
  }
  if (row > 2 && col < 16 && stone[col+1][row-1] == -color 
	&& stone[col+2][row-2] == -color && stone[col+3][row-3] == color)
  {
    changeCaptureCount(color);
    stone[col+1][row-1] = ERASED;
    stone[col+2][row-2] = ERASED;
  }
  if (row < 16 && col > 2 && stone[col-1][row+1] == -color 
	&& stone[col-2][row+2] == -color && stone[col-3][row+3] == color)
  {
    changeCaptureCount(color);
    stone[col-1][row+1] = ERASED;
    stone[col-2][row+2] = ERASED;
  }
  if (row < 16 && col < 16 && stone[col+1][row+1] == -color 
	&& stone[col+2][row+2] == -color && stone[col+3][row+3] == color)
  {
    changeCaptureCount(color);
    stone[col+1][row+1] = ERASED;
    stone[col+2][row+2] = ERASED;
  }
}
//----------------------------------------------------
public void changeCaptureCount(int color)
{
  if (color == BLUE)
  {	
    paircount_blue++;
  }else{
    paircount_red_tan++;
  }
  
}

//----------------------------------------------------
   public boolean check_for_five(int column, int row, int color)
   {
	int dir;
   	int tcounter;
	int counter; 
        counter = 0;
	tcounter = 0;


	for (dir=0; dir<9; dir++)
	{
	if (dir == 1 && row > 3)
		counter = Traverse(column,row,dir,tcounter, color);
		if (counter > 4) return true;

	if (dir == 2 && row > 3 && column < 15)
		counter = Traverse(column,row,dir,tcounter, color);
		if (counter > 4) return true;

	if (dir == 3  && column < 15)
		counter = Traverse(column,row,dir,tcounter, color);
		if (counter > 4) return true;

	if (dir == 4 && row <15 && column <15)
		counter = Traverse(column,row,dir,tcounter, color);
		if (counter > 4) return true;
	if (dir == 5 && row < 15)
		counter = Traverse(column,row,dir,tcounter, color);
		if (counter > 4) return true;

	if (dir == 6 && column > 3 && row < 15)
		counter = Traverse(column,row,dir,tcounter, color);
		if (counter > 4) return true;

	if (dir == 7  && column > 3)
		counter = Traverse(column,row,dir,tcounter, color);
		if (counter > 4) return true;

	if (dir == 8 && row >3 && column >3)
		counter = Traverse(column,row,dir,tcounter, color);
		if (counter > 4) return true;

	}

     return false; 	
    }
  
   public int Traverse(int column,int row,int dir,int tcounter, int color)
   {
	int i,temp;
	i=0;
	temp=0;

/* CHECK UP, THEN CHECK DOWN */
	if (dir == 1)
 	{
		tcounter=0;
		for(i=row; tcounter < 5 && stone[column][i] == color; i--)
			tcounter++;
		temp = i+1;
		
		if (tcounter > 4)
			return tcounter;
		else {
		tcounter = 0;
		if (temp < 15) for(i=temp;tcounter < 5 && stone[column][i] == color;i++)
			tcounter++;
		      }
		return tcounter;
	}

/* CHECK UP-RIGHT, THEN CHECK LEFT-DOWN */
	if (dir == 2)
 	{
		tcounter=0;
		for(i=row;tcounter < 5 && stone[column][i] == color; i--)
			{
				tcounter++;
				column++;
			}
		temp = i+1;
		column--;

		if (tcounter > 4)
			return tcounter;
		else {
		tcounter = 0;
		if (column > 3 && temp < 15) for(i=temp;tcounter < 5 && stone[column][i] == color;i++)
			{
			tcounter++;
			column--;
			}
		      }
		return tcounter;
	} 

/* CHECK RIGHT, THEN CHECK LEFT */
	if (dir == 3)
 	{
		tcounter=0;
		for(i=column; tcounter < 5 && stone[i][row] == color; i++)
			tcounter++;
		temp = i-1;
		
		if (tcounter > 4)
			return tcounter;
		else {
		tcounter = 0;
		if (temp > 3) for(i=temp;tcounter < 5 && stone[i][row] == color;i--)
			tcounter++;
		      }
		return tcounter;
	}

/* CHECK DOWN-RIGHT, THEN CHECK UP-LEFT */
	if (dir == 4)
 	{
		tcounter=0;
		for(i=row; tcounter < 5 && stone[column][i] == color; i++)
			{
				tcounter++;
				column++;
			}
		temp = i-1;
		column--;
			
		if (tcounter > 4)
			return tcounter;
		else {
		tcounter = 0;
		if(temp >3 && column >3) for(i=temp;tcounter < 5 && stone[column][i] == color;i--)
			{
				tcounter++;
				column--;
			}
		      }
		return tcounter;
	} 

/* CHECK DOWN, THEN CHECK UP */
	if (dir == 5)
 	{
		tcounter=0;
		for(i=row;tcounter < 5 && stone[column][i] == color;i++)
			tcounter++;
		temp = i-1;
		
		if (tcounter > 4)
			return tcounter;
		else {
		tcounter = 0;
		if(temp >3) for(i=temp; tcounter < 5 && stone[column][i] == color; i--)
			tcounter++;
		      }
		return tcounter;
	}

/* CHECK UP-RIGHT, THEN CHECK LEFT-DOWN */
	if (dir == 6)
 	{
		tcounter=0;
		for(i=row;tcounter < 5 && stone[column][i] == color;i++)
			{
			tcounter++;
			column--;
			}
		temp = i-1;
		column++;

		if (tcounter > 4)
			return tcounter;
		else {
		tcounter = 0;
		if(temp > 3 && column < 15) for(i=temp; tcounter < 5 && stone[column][i] == color; i--)
			{
				tcounter++;
				column++;
			}
 		      }
		return tcounter;
	} 

/* CHECK RIGHT, THEN CHECK LEFT */
	if (dir == 7)
 	{
		tcounter=0;
		for(i=column;tcounter < 5 && stone[i][row] == color;i--)
			tcounter++;
		temp = i+1;
		
		if (tcounter > 4)
			return tcounter;
		else {
		tcounter = 0;
		if(temp < 15) for(i=temp; tcounter < 5 && stone[i][row] == color; i++)
			tcounter++;
 		      }
		return tcounter;
	}

/* CHECK DOWN-RIGHT, THEN CHECK UP-LEFT */
	if (dir == 8)
 	{
		tcounter=0;
	for(i=row;tcounter < 5 && stone[column][i] == color;i--)
			{
				tcounter++;
				column--;
			}
				temp = i+1;
		column++;
			
		if (tcounter > 4)
			return tcounter;
		else {
		tcounter = 0;
		if(temp < 15 && column < 15) for(i=temp; tcounter < 5 && stone[column][i] == color; i++)
			{
				tcounter++;
				column++;
			}
		      }
		return tcounter;
	} 
     return tcounter;
    }


//----------------------------------------------------
   public void run() {
    try {
      Thread.sleep(500);
    } catch (Exception e);
    }

//----------------------------------------------------
  //Check whether a stone can be put there.
  //  Return boolean true if you can put a stone there.
   
  public boolean checkStone(int column, int row, int color){
    
    int i, j;
    
    for (i = 0; i < 8; i++){
      direction[i] = false;
    }
    
    if(stone[column][row] != 0) {
      return false;
    } else { 
      if (column > 1 && stone[column-1][row] == -color) {
	for (i = column-2; i > 0 && stone[i][row] == -color; i--);
	if (stone[i][row] == color) {
	  direction[LEFT] = true;
	}
      }
      if (column < 17 && stone[column+1][row] == -color) {
	for (i = column+2; i < 18 && stone[i][row] == -color; i++);
	if (stone[i][row] == color) {
	  direction[RIGHT] = true;
	}
      } 
      if (row > 1 && stone[column][row-1] == -color) {
	for (j = row-2; j > 0 && stone[column][j] == -color; j--);
	if (stone[column][j] == color) {
	  direction[UPPER] = true;
	}
      }
      if (row < 17 && stone[column][row+1] == -color) {
	for (j = row+2; j < 18 && stone[column][j] == -color; j++);
	if (stone[column][j] == color) {
	  direction[LOWER] = true;
	}
      }
      if (column > 1 && row > 1 && stone[column-1][row-1] == -color) {
	for (i = column-2, j = row-2; i > 0 && j > 0 
	     && stone[i][j] == -color; i--, j--);
	if (stone[i][j] == color) {
	  direction[UPPERLEFT] = true;
	}
      }
      if (column < 17 && row > 1 && stone[column+1][row-1] == -color) {
	for (i = column+2, j = row-2; i < 18 && j > 0 
	     && stone[i][j] == -color; i++, j--);
	if (stone[i][j] == color) {
	  direction[UPPERRIGHT] = true;
	}
      }
      if (column < 17 && row < 17 && stone[column+1][row+1] == -color) {
	for (i = column+2, j = row+2; i < 18 && j < 18 
	     && stone[i][j] == -color; i++, j++);
	if (stone[i][j] == color) {
	  direction[LOWERRIGHT] = true;
	}
      }
      if (column > 1 && row < 17 && stone[column-1][row+1] == -color) {
	for (i = column-2, j = row+2; i > 0 && j < 18 
	     && stone[i][j] == -color; i--, j++);
	if (stone[i][j] == color) {
	  direction[LOWERLEFT] = true;
	}
      } 

      for (i = 0; i < 8; i++){
	if (direction[i] == true){
	  return true;
	}
      }

      return false;
    }
  }

} //end of class Pente

//----------------------------------------------------
//----------------------------------------------------
//----------------------------------------------------



class PentePlayer {
  Pente parent;

  final int BLUE =  1;	
  final int RED_TAN = -1;
  final int EMPTY =  0;
  final int ERASED = 2;

  public int xxx, yyy;
  int i,j;

  PentePlayer(Pente parent){
    this.parent = parent;
  }

//----------------------------------------------------
  void defaultComputerMove (int f, int g) {

    int i=0 ,j=0;
    int radius=1;
         do{ 

	i = (int)(Math.random() * 5);

	if (i==1 || i==3|| i==4) {

         // computer makes random move based on position of first move
	//DIR 1
	    if(parent.stone[f][g-radius] == EMPTY)
		{ i=f;
		  j=g-radius;
		} 
	//DIR 2
	    else if(parent.stone[f+radius][g-radius] == EMPTY) 
		{ i=f+radius;
		  j=g-radius;
		} 
	//DIR 3
	    else if(parent.stone[f+radius][g] == EMPTY)
		{ i=f+radius;
		  j=g;		
		} 
	//DIR 4
	    else if(parent.stone[f+radius][g+radius] == EMPTY) 
		{ i=f+radius;
		  j=g+radius;
		} 
	//DIR 5
	    else if(parent.stone[f][g+radius] == EMPTY) 
		{ i=f;
		  j=g+radius;
		} 
	//DIR 6
	    else if(parent.stone[f-radius][g+radius] == EMPTY) 
		{ i=f-radius;
		  j=g+radius;
		} 
	//DIR 7
	    else if(parent.stone[f-radius][g] == EMPTY) 
		{ i=f-radius;
		  j=g;
		} 
	//DIR 8
	    else if(parent.stone[f-radius][g-radius] == EMPTY) 
		{ i=f-radius;
		  j=g-radius;
		}  
			} //end of if

	else if (i==0 || i==2) {

		i = (int)(Math.random() * 19);
		j = (int)(Math.random() * 19);
	      } //end of else

		radius++;
           }while (!parent.checkSlot(i, j, RED_TAN));
   yyy = i;
   xxx = j;
   }



//----------------------------------------------------
  public void makeMove(int f, int g){

    if (Offense4()) {	// computer checks for outright win w/ 5-in-row
    } else if (parent.paircount_red_tan==4  && CapturePair(BLUE)) {
         // computer checks for win on 5th capture 
    } else if (Defense4()) {	 // computer defends against 5-in-row
    } else if (Defense3()) {    // computer defends against three piece combo
    } else if (parent.paircount_blue <= parent.paircount_red_tan && CapturePair(BLUE)){ 
		// computer tries for captures if it's leading or tied in count
    } else if (CapturePair(RED_TAN)) {  // computer defends against captures
    } else if (CapturePair(BLUE)) {   
		// computer tries for captures
    } else { 
        defaultComputerMove(f, g);
    }

/*    if (!Offense4())	// computer checks for outright win w/ 5-in-row
    if (parent.paircount_red_tan==4) 
    {
    if (!CapturePair(BLUE))  // computer checks for win on 5th capture 
    if (!Defense4())	 // computer defends against 5-in-row
    if (!Defense3())     // computer defends against three piece combo
    if (!CapturePair(RED_TAN))  // computer defends against captures
    if (!CapturePair(BLUE))    // computer tries for captures
      defaultComputerMove(f, g);
    } else {//+++++++++++++++++++++++++++++++++++++++++++++++++++
    if (!Defense4())	 // computer defends against 5-in-row
    if (!Defense3())     // computer defends against three piece combo
    if (!CapturePair(RED_TAN))  // computer defends against captures
    if (!CapturePair(BLUE))    // computer tries for captures
      defaultComputerMove(f, g);

    }
*/
      parent.outputarea.appendText("Computer move:  "+xxx+", "+yyy+"\n\n");	

       if(parent.check_for_five(yyy, xxx, RED_TAN)){
	   parent.gameOver=true;
	   parent.outputarea.appendText("Y O U   L O S E!\n  The computer had 5-in-a-row!\n\n");	
	   parent.repaint(1);      
        }
        parent.checkCapture(yyy, xxx, RED_TAN); 
        if (parent.paircount_blue > 4 || parent.paircount_red_tan > 4) {
	   parent.gameOver=true;
	   	   parent.outputarea.appendText("Y O U   L O S E!\n  The computer had 5 captured pairs!\n\n");
	   parent.repaint(1);   
        }


    parent.turn = BLUE;
   }

//----------------------------------------------------

   boolean EdgeCheck() {
     int col, row;
// top edge
     row = 3;
     for (col=0; col < 19; col++){
	if (parent.stone[col][row]==BLUE && parent.stone[col][row-1]==BLUE &&
	parent.stone[col][row-2]==BLUE && parent.stone[col][row-3]==BLUE &&
	(parent.stone[col][row+1]==EMPTY || parent.stone[col][row+1]==ERASED)){
	  parent.stone[col][row+1]=RED_TAN;
          yyy = col;
	  xxx = row+1;
	  return true;
        }
     }
     for (col=1; col < 16; col++){
	if (parent.stone[col][row]==BLUE && parent.stone[col+1][row-1]==BLUE &&
	parent.stone[col+2][row-2]==BLUE && parent.stone[col+3][row-3]==BLUE &&
	(parent.stone[col-1][row+1]==EMPTY || parent.stone[col-1][row+1]==ERASED)){
	  parent.stone[col-1][row+1]=RED_TAN;
          yyy = col-1;
	  xxx = row+1;
	  return true;
        }
     }
     for (col=3; col < 18; col++){
	if (parent.stone[col][row]==BLUE && parent.stone[col-1][row-1]==BLUE &&
	  parent.stone[col-2][row-2]==BLUE && parent.stone[col-3][row-3]==BLUE &&
	(parent.stone[col+1][row+1]==EMPTY || parent.stone[col+1][row+1]==ERASED)){
	  parent.stone[col+1][row+1]=RED_TAN;
          yyy = col+1;
	  xxx = row+1;
	  return true;
        }
     }
// bottom edge
     row = 18;
     for (col=0; col < 19; col++){
	if (parent.stone[col][row]==BLUE && parent.stone[col][row-1]==BLUE &&
	    parent.stone[col][row-2]==BLUE && parent.stone[col][row-3]==BLUE&&
	(parent.stone[col][row-4]==EMPTY || parent.stone[col][row-4]==ERASED)){
	  parent.stone[col][row-4]=RED_TAN;
          yyy = col;
	  xxx = row-4;
	  return true;
        }
     }
     for (col=0; col < 15; col++){
	if (parent.stone[col][row]==BLUE && parent.stone[col+1][row-1]==BLUE &&
	  parent.stone[col+2][row-2]==BLUE && parent.stone[col+3][row-3]==BLUE&&
	(parent.stone[col+4][row-4]==EMPTY || parent.stone[col+4][row-4]==ERASED)){
	  parent.stone[col+4][row-4]=RED_TAN;
          yyy = col+4;
	  xxx = row-4;
	  return true;
        }
     }
     for (col=4; col < 19; col++){
	if (parent.stone[col][row]==BLUE && parent.stone[col-1][row-1]==BLUE &&
	  parent.stone[col-2][row-2]==BLUE && parent.stone[col-3][row-3]==BLUE&&
	(parent.stone[col-4][row-4]==EMPTY || parent.stone[col-4][row-4]==ERASED)){
	  parent.stone[col-4][row-4]=RED_TAN;
          yyy = col-4;
	  xxx = row-4;
	  return true;
        }
     }

// left edge
     col = 3;
     for (row=0; row < 19; row++){
	if (parent.stone[col][row]==BLUE && parent.stone[col-1][row]==BLUE &&
	    parent.stone[col-2][row]==BLUE && parent.stone[col-3][row]==BLUE&&
	(parent.stone[col+1][row]==EMPTY || parent.stone[col+1][row]==ERASED)){
	  parent.stone[col+1][row]=RED_TAN;
          yyy = col+1;
	  xxx = row;
	  return true;
        }
     }
     for (row=1; row < 16; row++){
	if (parent.stone[col][row]==BLUE && parent.stone[col-1][row+1]==BLUE &&
	  parent.stone[col-2][row+2]==BLUE && parent.stone[col-3][row+3]==BLUE&&
	(parent.stone[col+1][row-1]==EMPTY || parent.stone[col+1][row-1]==ERASED)){
	  parent.stone[col+1][row-1]=RED_TAN;
          yyy = col+1;
	  xxx = row-1;
	  return true;
        }
     }
     for (row=3; row < 18; row++){
	if (parent.stone[col][row]==BLUE && parent.stone[col-1][row-1]==BLUE &&
	  parent.stone[col-2][row-2]==BLUE && parent.stone[col-3][row-3]==BLUE&&
	(parent.stone[col+1][row+1]==EMPTY || parent.stone[col+1][row+1]==ERASED)){
	  parent.stone[col+1][row+1]=RED_TAN;
          yyy = col+1;
	  xxx = row+1;
	  return true;
        }
     }
// right edge
     col = 18;
     for (row=0; row < 19; row++){
	if (parent.stone[col][row]==BLUE && parent.stone[col-1][row]==BLUE &&
	    parent.stone[col-2][row]==BLUE && parent.stone[col-3][row]==BLUE&&
	(parent.stone[col-4][row]==EMPTY || parent.stone[col-4][row]==ERASED)){
	  parent.stone[col-4][row]=RED_TAN;
          yyy = col-4;
	  xxx = row;
	  return true;
        }
     }
     for (row=0; row < 15; row++){
	if (parent.stone[col][row]==BLUE && parent.stone[col-1][row+1]==BLUE &&
	  parent.stone[col-2][row+2]==BLUE && parent.stone[col-3][row+3]==BLUE&&
	(parent.stone[col-4][row+4]==EMPTY || parent.stone[col-4][row+4]==ERASED)){
	  parent.stone[col-4][row+4]=RED_TAN;
          yyy = col-4;
	  xxx = row+4;
	  return true;
        }
     }
     for (row=4; row < 19; row++){
	if (parent.stone[col][row]==BLUE && parent.stone[col-1][row-1]==BLUE &&
	  parent.stone[col-2][row-2]==BLUE && parent.stone[col-3][row-3]==BLUE&&
	(parent.stone[col-4][row-4]==EMPTY || parent.stone[col-4][row-4]==ERASED)){
	  parent.stone[col-4][row-4]=RED_TAN;
          yyy = col-4;
	  xxx = row-4;
	  return true;
        }
     }


    return false;
    }

//----------------------------------------------------
   public boolean Defense4()
   {
    int dir, column, row;
    int counter = 0;

    if (EdgeCheck())
	return true;


    for (column=0; column < 19; column++)
     for (row=0; row < 19; row++)
       if (parent.stone[column][row]==RED_TAN)
	for (dir=1; dir<9; dir++)
	{
	if (dir == 1 && row > 4)
		if (find4(column,row-1,dir,BLUE)){
		  parent.stone[column][row-5] = RED_TAN;
		  yyy = column;
		  xxx = row-5;
		  return true;
		}
	if (dir == 5 && row < 14)
		if (find4(column,row+1,dir,BLUE)){
		  parent.stone[column][row+5] = RED_TAN;
		  yyy = column;
		  xxx = row+5;
		  return true;
		}
	if (dir == 3 && column < 14)
		if (find4(column+1,row,dir,BLUE)){
		  parent.stone[column+5][row] = RED_TAN;
		  yyy = column+5;
		  xxx = row;
		  return true;
		}
	if (dir == 7 && column > 4)
		if (find4(column-1,row,dir,BLUE)){
		  parent.stone[column-5][row] = RED_TAN;
		  yyy = column-5;
		  xxx = row;
		  return true;
		}
	if (dir == 2 && row > 4 && column < 14)
		if (find4(column+1,row-1,dir,BLUE)){
		  parent.stone[column+5][row-5] = RED_TAN;
		  yyy = column+5;
		  xxx = row-5;
		  return true;
                }
	if (dir == 4 && row < 14 && column < 14)
		if (find4(column+1,row+1,dir,BLUE)){
		  parent.stone[column+5][row+5] = RED_TAN;
		  yyy = column+5;
		  xxx = row+5;
		  return true;
                }
	if (dir == 6 && column > 4 && row < 14)
		if (find4(column-1,row+1,dir,BLUE)){
		  parent.stone[column-5][row+5] = RED_TAN;
		  yyy = column-5;
		  xxx = row+5;
		  return true;
                }
	if (dir == 8 && row > 4 && column > 4)
		if (find4(column-1,row-1,dir,BLUE)){
		  parent.stone[column-5][row-5] = RED_TAN;
		  yyy = column-5;
		  xxx = row-5;
		  return true;
                }
	}

     return false; 	
    }
 

//--------------------------------------------------
    public boolean find4(int column, int row, int dir, int color) {
	int i=0, temp=0, Count=0;
	int j=0;


/* CHECK UP*/
	if (dir == 1)
 	{
		for(i=row; Count < 4 && parent.stone[column][i] == color; i--)
			Count++;	
		if (Count == 4 && (parent.stone[column][i] == EMPTY || 
			parent.stone[column][i] == ERASED))
			return true;
	        return false;
	}
/* CHECK DOWN*/
	if (dir == 5)
 	{
		for(i=row; Count < 4 && parent.stone[column][i] == color; i++)
			Count++;	
		if (Count == 4 && (parent.stone[column][i] == EMPTY || 
			parent.stone[column][i] == ERASED))
			return true;
	        return false;
	}

/* CHECK RIGHT */
	if (dir == 3)
 	{
		for(i=column; Count < 4 && parent.stone[i][row] == color; i++)
			Count++;	
		if (Count == 4 && (parent.stone[i][row] == EMPTY || 
			parent.stone[i][row] == ERASED))
			return true;
	        return false;
	}
/* CHECK LEFT */
	if (dir == 7)
 	{
		for(i=column; Count < 4 && parent.stone[i][row] == color; i--)
			Count++;	
		if (Count == 4 && (parent.stone[i][row] == EMPTY || 
			parent.stone[i][row] == ERASED))
			return true;
	        return false;
	}

/* CHECK DOWN-AND-LEFT */
	if (dir == 4)
 	{
		j = row;
		for(i=column; Count < 4 && parent.stone[i][j] == color; i++){
			j++;
			Count++;
		}	
		if (Count == 4 && (parent.stone[i][j] == EMPTY || 
			parent.stone[i][j] == ERASED))
			return true;
	        return false;
	}

/* CHECK UP-AND-RIGHT */
	if (dir == 2)
 	{
		j = row;
		for(i=column; Count < 4 && parent.stone[i][j] == color; i++){
			j--;
			Count++;
		}	
		if (Count == 4 && (parent.stone[i][j] == EMPTY || 
			parent.stone[i][j] == ERASED))
			return true;
	        return false;
	}

/* CHECK DOWN-AND-LEFT */
	if (dir == 6)
 	{
		j = row;
		for(i=column; Count < 4 && parent.stone[i][j] == color; i--){
			j++;
			Count++;
		}	
		if (Count == 4 && (parent.stone[i][j] == EMPTY || 
			parent.stone[i][j] == ERASED))
			return true;
	        return false;
	}

/* CHECK UP-AND-LEFT */
	if (dir == 8)
 	{
		j = row;
		for(i=column; Count < 4 && parent.stone[i][j] == color; i--){
			j--;
			Count++;
		}	
		if (Count == 4 && (parent.stone[i][j] == EMPTY || 
			parent.stone[i][j] == ERASED))
			return true;
	        return false;
	}




    return false;
    }

//----------------------------------------------------
   public boolean Defense3()
   {
    int dir, column, row;
    int counter = 0;


    for (column=0; column < 19; column++)
     for (row=0; row < 19; row++)
       if (parent.stone[column][row]==EMPTY)
	for (dir=1; dir<9; dir++)
	{
	if (dir == 1 && row > 4 && parent.stone[column][row-1]==BLUE)
		if (find3(column,row-2,dir)){
		  return true;
		}
	if (dir == 5 && row < 14 && parent.stone[column][row+1]==BLUE)
		if (find3(column,row+2,dir)){
		  return true;
		}
	if (dir == 3 && column < 14 && parent.stone[column+1][row]==BLUE)
		if (find3(column+2,row,dir)){
		  return true;
		}
	if (dir == 7 && column > 4 && parent.stone[column-1][row]==BLUE)
		if (find3(column-2,row,dir)){
		  return true;
		}
	if (dir == 2 && row > 4 && column < 14 && 
		parent.stone[column+1][row-1]==BLUE)
		if (find3(column+2,row-2,dir)){
		  return true;
                }
	if (dir == 4 && row < 14 && column < 14 && 
		parent.stone[column+1][row+1]==BLUE)
		if (find3(column+2,row+2,dir)){
		  return true;
                }
	if (dir == 6 && column > 4 && row < 14 && 
		parent.stone[column-1][row+1]==BLUE)
		if (find3(column-2,row+2,dir)){
		  return true;
                }
	if (dir == 8 && row > 4 && column > 4 && 
		parent.stone[column-1][row-1]==BLUE)
		if (find3(column-2,row-2,dir)){
		  return true;
                }
	}
     
     return false; 	
    }
 
//--------------------------------------------------
    public boolean find3(int column, int row, int dir) {
	int i=0, temp=0, Count=1;
	int j=0, spaceRow = 0, spaceCol = 0, spaceCount = 0;


/* CHECK UP*/
	if (dir == 1)
 	{
		for(i=row; Count < 3 && (parent.stone[column][i] == BLUE ||
		    parent.stone[column][i] == EMPTY) && spaceCount < 2; i--) {
		   if (parent.stone[column][i] == BLUE)
			Count++;	
		   else {
			spaceCount++;
			spaceCol = column;
			spaceRow = i;
		   }
			
                }
		if (Count == 3 && (parent.stone[column][i] == EMPTY || 
		   parent.stone[column][i] == ERASED || 
		   parent.stone[column][i] == BLUE) && spaceCount == 1){
			yyy = spaceCol;
			xxx = spaceRow;
			parent.stone[spaceCol][spaceRow] = RED_TAN;
			return true;
		   } else if (Count == 3 && 
			(parent.stone[column][i] == EMPTY || 
		         parent.stone[column][i] == ERASED)){
			yyy = column;
			xxx = i;
			parent.stone[column][i] = RED_TAN;
			return true;
		   }

	  return false;
	}

	if (dir == 5)
 	{
		for(i=row; Count < 3 && (parent.stone[column][i] == BLUE ||
		    parent.stone[column][i] == EMPTY) && spaceCount < 2; i++) {
		   if (parent.stone[column][i] == BLUE)
			Count++;	
		   else {
			spaceCount++;
			spaceCol = column;
			spaceRow = i;
		   }
			
                }
		if (Count == 3 && (parent.stone[column][i] == EMPTY || 
		   parent.stone[column][i] == ERASED || 
		   parent.stone[column][i] == BLUE) && spaceCount == 1){
			yyy = spaceCol;
			xxx = spaceRow;
			parent.stone[spaceCol][spaceRow] = RED_TAN;
			return true;
		   } else if (Count == 3 && 
			(parent.stone[column][i] == EMPTY || 
		         parent.stone[column][i] == ERASED)){
			yyy = column;
			xxx = i;
			parent.stone[column][i] = RED_TAN;
			return true;
		   }
	        return false;
	}

	if (dir == 3)
 	{
		for(i=column; Count < 3 && (parent.stone[i][row] == BLUE ||
		    parent.stone[i][row] == EMPTY) && spaceCount < 2; i++) {
		   if (parent.stone[i][row] == BLUE)
			Count++;	
		   else {
			spaceCount++;
			spaceCol = i;
			spaceRow = row;
		   }
			
                }
		if (Count == 3 && (parent.stone[i][row] == EMPTY || 
		   parent.stone[i][row] == ERASED || 
		   parent.stone[i][row] == BLUE) && spaceCount == 1){
			yyy = spaceCol;
			xxx = spaceRow;
			parent.stone[spaceCol][spaceRow] = RED_TAN;
			return true;
		   } else if (Count == 3 && 
			(parent.stone[i][row] == EMPTY || 
		         parent.stone[i][row] == ERASED)){
			yyy = i;
			xxx = row;
			parent.stone[i][row] = RED_TAN;
			return true;
		   }
	        return false;
	}

	if (dir == 7)
 	{
		for(i=column; Count < 3 && (parent.stone[i][row] == BLUE ||
		    parent.stone[i][row] == EMPTY) && spaceCount < 2; i--) {
		   if (parent.stone[i][row] == BLUE)
			Count++;	
		   else {
			spaceCount++;
			spaceCol = i;
			spaceRow = row;
		   }
			
                }
		if (Count == 3 && (parent.stone[i][row] == EMPTY || 
		   parent.stone[i][row] == ERASED || 
		   parent.stone[i][row] == BLUE) && spaceCount == 1){
			yyy = spaceCol;
			xxx = spaceRow;
			parent.stone[spaceCol][spaceRow] = RED_TAN;
			return true;
		   } else if (Count == 3 && 
			(parent.stone[i][row] == EMPTY || 
		         parent.stone[i][row] == ERASED)){
			yyy = i;
			xxx = row;
			parent.stone[i][row] = RED_TAN;
			return true;
		   }
	        return false;
	}

	if (dir == 2)
 	{
		j = row;
		for(i=column; Count < 3 && (parent.stone[i][j] == BLUE ||
		    parent.stone[i][j] == EMPTY) && spaceCount < 2; i++) {
		   if (parent.stone[i][j] == BLUE)
			Count++;	
		   else {
			spaceCount++;
			spaceCol = i;
			spaceRow = j;
		   }
		j--;
                }
		if (Count == 3 && (parent.stone[i][j] == EMPTY || 
		   parent.stone[i][j] == ERASED || 
		   parent.stone[i][j] == BLUE) && spaceCount == 1){
			yyy = spaceCol;
			xxx = spaceRow;
			parent.stone[spaceCol][spaceRow] = RED_TAN;
			return true;
		   } else if (Count == 3 && 
			(parent.stone[i][j] == EMPTY || 
		         parent.stone[i][j] == ERASED)){
			yyy = i;
			xxx = j;
			parent.stone[i][j] = RED_TAN;
			return true;
		   }
	        return false;
	}

	if (dir == 4)
 	{
		j = row;
		for(i=column; Count < 3 && (parent.stone[i][j] == BLUE ||
		    parent.stone[i][j] == EMPTY) && spaceCount < 2; i++) {
		   if (parent.stone[i][j] == BLUE)
			Count++;	
		   else {
			spaceCount++;
			spaceCol = i;
			spaceRow = j;
		   }
		j++;
                }
		if (Count == 3 && (parent.stone[i][j] == EMPTY || 
		   parent.stone[i][j] == ERASED || 
		   parent.stone[i][j] == BLUE) && spaceCount == 1){
			yyy = spaceCol;
			xxx = spaceRow;
			parent.stone[spaceCol][spaceRow] = RED_TAN;
			return true;
		   } else if (Count == 3 && 
			(parent.stone[i][j] == EMPTY || 
		         parent.stone[i][j] == ERASED)){
			yyy = i;
			xxx = j;
			parent.stone[i][j] = RED_TAN;
			return true;
		   }
	        return false;
	}


	if (dir == 6)
 	{
		j = row;
		for(i=column; Count < 3 && (parent.stone[i][j] == BLUE ||
		    parent.stone[i][j] == EMPTY) && spaceCount < 2; i--) {
		   if (parent.stone[i][j] == BLUE)
			Count++;	
		   else {
			spaceCount++;
			spaceCol = i;
			spaceRow = j;
		   }
		j++;
                }
		if (Count == 3 && (parent.stone[i][j] == EMPTY || 
		   parent.stone[i][j] == ERASED || 
		   parent.stone[i][j] == BLUE) && spaceCount == 1){
			yyy = spaceCol;
			xxx = spaceRow;
			parent.stone[spaceCol][spaceRow] = RED_TAN;
			return true;
		   } else if (Count == 3 && 
			(parent.stone[i][j] == EMPTY || 
		         parent.stone[i][j] == ERASED)){
			yyy = i;
			xxx = j;
			parent.stone[i][j] = RED_TAN;
			return true;
		   }
	        return false;
	}

	if (dir == 8)
 	{
		j = row;
		for(i=column; Count < 3 && (parent.stone[i][j] == BLUE ||
		    parent.stone[i][j] == EMPTY) && spaceCount < 2; i--) {
		   if (parent.stone[i][j] == BLUE)
			Count++;	
		   else {
			spaceCount++;
			spaceCol = i;
			spaceRow = j;
		   }
		j--;
                }
		if (Count == 3 && (parent.stone[i][j] == EMPTY || 
		   parent.stone[i][j] == ERASED || 
		   parent.stone[i][j] == BLUE) && spaceCount == 1){
			yyy = spaceCol;
			xxx = spaceRow;
			parent.stone[spaceCol][spaceRow] = RED_TAN;
			return true;
		   } else if (Count == 3 && 
			(parent.stone[i][j] == EMPTY || 
		         parent.stone[i][j] == ERASED)){
			yyy = i;
			xxx = j;
			parent.stone[i][j] = RED_TAN;
			return true;
		   }
	        return false;
	}



    return false;
    }


//----------------------------------------------------
   public boolean CapturePair(int color)
   {
/*
    This code serves the dual purpose of capturing pairs for the computer
    player as well as defending the computer player against captures.
*/

    int dir, column, row;
 //   int counter = 0;


    for (column=0; column < 19; column++)
     for (row=0; row < 19; row++)
       if (parent.stone[column][row]==-color)
	for (dir=1; dir<9; dir++)
	{
	if (dir == 1 && row > 2 && 
		parent.stone[column][row-1] == color &&
		parent.stone[column][row-2] == color &&
		(parent.stone[column][row-3] == EMPTY ||
		parent.stone[column][row-3] == ERASED)){
		  parent.stone[column][row-3] = RED_TAN;
		  yyy = column;
		  xxx = row-3;
		  return true;
		}
	if (dir == 5 && row < 16 && 
		parent.stone[column][row+1] == color &&
		parent.stone[column][row+2] == color &&
		(parent.stone[column][row+3] == EMPTY ||
		parent.stone[column][row+3] == ERASED)){
		  parent.stone[column][row+3] = RED_TAN;
		  yyy = column;
		  xxx = row+3;
		  return true;
		}
	if (dir == 3 && column < 16 && 
		parent.stone[column+1][row] == color &&
		parent.stone[column+2][row] == color &&
		(parent.stone[column+3][row] == EMPTY ||
		parent.stone[column+3][row] == ERASED)){
		  parent.stone[column+3][row] = RED_TAN;
		  yyy = column+3;
		  xxx = row;
		  return true;
		}
	if (dir == 7 && column > 2 && 
		parent.stone[column-1][row] == color &&
		parent.stone[column-2][row] == color &&
		(parent.stone[column-3][row] == EMPTY ||
		parent.stone[column-3][row] == ERASED)){
		  parent.stone[column-3][row] = RED_TAN;
		  yyy = column-3;
		  xxx = row;
		  return true;
		}
	if (dir == 4 && row < 16 && column < 16 &&
		parent.stone[column+1][row+1] == color &&
		parent.stone[column+2][row+2] == color &&
		(parent.stone[column+3][row+3] == EMPTY ||
		parent.stone[column+3][row+3] == ERASED)){
		  parent.stone[column+3][row+3] = RED_TAN;
		  yyy = column+3;
		  xxx = row+3;
		  return true;
		}
	if (dir == 8 && row > 2 && column > 2 &&
		parent.stone[column-1][row-1] == color &&
		parent.stone[column-2][row-2] == color &&
		(parent.stone[column-3][row-3] == EMPTY ||
		parent.stone[column-3][row-3] == ERASED)){
		  parent.stone[column-3][row-3] = RED_TAN;
		  yyy = column-3;
		  xxx = row-3;
		  return true;
		}
	if (dir == 2 && row > 2 && column < 16 &&
		parent.stone[column+1][row-1] == color &&
		parent.stone[column+2][row-2] == color &&
		(parent.stone[column+3][row-3] == EMPTY ||
		parent.stone[column+3][row-3] == ERASED)){
		  parent.stone[column+3][row-3] = RED_TAN;
		  yyy = column+3;
		  xxx = row-3;
		  return true;
		}
	if (dir == 6 && row < 16 && column > 2 &&
		parent.stone[column-1][row+1] == color &&
		parent.stone[column-2][row+2] == color &&
		(parent.stone[column-3][row+3] == EMPTY ||
		parent.stone[column-3][row+3] == ERASED)){
		  parent.stone[column-3][row+3] = RED_TAN;
		  yyy = column-3;
		  xxx = row+3;
		  return true;
		}
	}

     return false; 	
    }
 

//----------------------------------------------------
   public boolean Offense4()
   {
    int dir, column, row;
    int counter = 0;


    for (column=0; column < 19; column++)
     for (row=0; row < 19; row++)
//       if (parent.stone[column][row]==RED_TAN)
	for (dir=1; dir<9; dir++)
	{
	if (dir == 1 && row > 4)
		if (find4(column,row,dir,RED_TAN)){
		  parent.stone[column][row-4] = RED_TAN;
		  yyy = column;
		  xxx = row-4;
		  return true;
		}
	if (dir == 5 && row < 14)
		if (find4(column,row,dir,RED_TAN)){
		  parent.stone[column][row+4] = RED_TAN;
		  yyy = column;
		  xxx = row+4;
		  return true;
		}
	if (dir == 3 && column < 14)
		if (find4(column,row,dir,RED_TAN)){
		  parent.stone[column+4][row] = RED_TAN;
		  yyy = column+4;
		  xxx = row;
		  return true;
		}
	if (dir == 7 && column > 4)
		if (find4(column,row,dir,RED_TAN)){
		  parent.stone[column-4][row] = RED_TAN;
		  yyy = column-4;
		  xxx = row;
		  return true;
		}
	if (dir == 2 && row > 4 && column < 14)
		if (find4(column,row,dir,RED_TAN)){
		  parent.stone[column+4][row-4] = RED_TAN;
		  yyy = column+4;
		  xxx = row-4;
		  return true;
                }
	if (dir == 4 && row < 14 && column < 14)
		if (find4(column,row,dir,RED_TAN)){
		  parent.stone[column+4][row+4] = RED_TAN;
		  yyy = column+4;
		  xxx = row+4;
		  return true;
                }
	if (dir == 6 && column > 4 && row < 14)
		if (find4(column,row,dir,RED_TAN)){
		  parent.stone[column-4][row+4] = RED_TAN;
		  yyy = column-4;
		  xxx = row+4;
		  return true;
                }
	if (dir == 8 && row > 4 && column > 4)
		if (find4(column,row,dir,RED_TAN)){
		  parent.stone[column-4][row-4] = RED_TAN;
		  yyy = column-4;
		  xxx = row-4;
		  return true;
                }
	}

     return false; 	
    }
 

} //end of class