// Battleship modified November 5, 1996
// By David Dao
// Project Part (2) to play across net
//
// Original JAVA code to play BATTLESHIP - April 26, 1995
// By Nathaniel G. Auvil and Patrick Gillisse
//
// CSCI 406 Internet Programming for Dr. Roger Webster
import java.applet.*;
import java.awt.*;
import java.io.*;
import java.util.*;
import java.lang.*;
import java.net.*;
//====================================================================
public class netBattle extends Applet implements Runnable{
    final int max=10;
    final int num_ships=5;
    final String blanks="                                     ";

    AudioClip blowup, sinking, greatshotkid, taps;
    boolean game_starting = false; 	// set to true to begin game
    boolean first_point = true; 	// flag for ship placement 
    boolean game_over = false;
    boolean p1_ships_placed = false; 
    boolean start_firing = false;
    boolean otherPlayer_turn = false; 	// tells if player1 is up
    boolean ship_hit = false;
    boolean recieved_board = false;	// flag for streamlistner

    String opponent_move;		// buffer to hold opponent move
    int com_x, com_y, start_x, start_y;
    int[][] ship_loc= new int [4][2]; 	// position for hit ships
    char[][] ship_info= new char[4][2];
    char dir_found='N';
    int ships_found=0;
    char ship_letter= ' '; 		// holds letter value of hit ship
    
    Panel player1, player2;

    Button[][] play1 = new Button[10][10];
    Button[][] play2 = new Button [10][10];
    char p1_grid[][]= new char [max][max];
    char p2_grid[][]= new char [max][max];
    int placed_ships=5;    
    int firstx, firsty;
    TextArea display= new TextArea(2, 60);  
    String message= "Player 1 enter starting point of aircraft carrier"; 
    int num_players;
    int sunk_player1=0,
        sunk_player2=0,
	hit_ship1[]= new int [num_ships],
	hit_ship2[]= new int [num_ships];

  	Thread thread;		// create a thread to run in
				//     variables needed for net window	
	String param;
  	NCWindow window; 	// the popup window to do the internet work
	Image[] images;		// array of images to be loaded
	MediaTracker tracker;	// a media tracker to keep track of loading progress
	//#########################################################################
// initialize variables needed for game
public void init()
{
     String s_num_players= getParameter("num_players");
     num_players= Integer.parseInt(s_num_players); 

     sinking= getAudioClip(getCodeBase(), "going_down.au");
     blowup= getAudioClip(getCodeBase(), "blowup.au");
     greatshotkid= getAudioClip(getCodeBase(), "greatshotkid.au");
 //    taps= getAudioClip(getCodeBase(), "taps.au");

     player1 = new Panel();  			// create a panel
     player2 = new Panel();
     player1.resize(150,150);
     player2.resize(250,250);

     add(player1);
     add(player2);
     add(display);  //this is for message display
     display.setEditable(false);  
     display.insertText(message, 0);
     player1.setBackground(Color.blue);
     player1.setLayout(new GridLayout(10, 10, 1, 1));
     player2.setBackground(Color.red);
     player2.setLayout(new GridLayout(10, 10, 1, 1));
     showStatus("Creating battleship grid");	
     for(int i =0; i<max; i++) 		// create the grid
       for(int j =0; j<max; j++) 
         { 
	    play2[i][j] = new Button(j+","+i);
            play1[i][j] = new Button(j+","+i);
            play2[i][j].setBackground(Color.cyan);
	    play1[i][j].setBackground(Color.cyan);
            player1.add(play1[i][j]);
            player2.add(play2[i][j]);
	 } 

     player1.show();
     player2.show(); 
     disable_buttons(play2); 		// disable for the start
     for(int i=0; i<max; i++)    	// initialize char grids to all -'s
       for(int j=0; j<max; j++)  
       {    
 	 p1_grid[i][j]= '-';
         p2_grid[i][j]= '-';
       }
     for (int i=0; i<num_ships; i++)   	// initialize counter for hits
     {
       hit_ship1[i]=0;
       hit_ship2[i]=0;
     } 
     for(int i=0; i<4; i++)    		
       for(int j=0; j<2; j++)     
 	 ship_loc[i][j]= -1;

//   this initializes the images and window for communications
     showStatus("Creating communications window...");	
     tracker = new MediaTracker(this);
     images = new Image[9];			// set up array for 8 images
     for(int i=0; i<8; i++) {
	images[i] = getImage(getDocumentBase(), "image"+i+".jpeg");
	tracker.addImage(images[i],i);
     }
     for(int i=0; i<8; i++) {
	showStatus("Loading image-"+i);
	try {
	   tracker.waitForID(i); 
	} 
	catch (InterruptedException e){
	   showStatus("Image loading failed!");
	}
	showStatus("Image-"+i+" fully loaded");
     }
     window = new NCWindow(getCodeBase(),8432,images);  //set up the window
     this.setLayout(new FlowLayout());
     this.add(new Button("QUIT"));
}
//###########################################################################
//    gets the thread going to handle communications
public void start() {

  	thread = new Thread(this,"main"); 	 // create a thread for this window
  	thread.setPriority(Thread.MIN_PRIORITY); // low priority so components work
  	thread.start();
}

public void run() {
   String p2_coord;

   while (!(window.gameBegin())) {
      try{thread.sleep(50);} catch(InterruptedException e){}
   }
   sendBoard(p1_grid);
   while (!(window.shipPlacement())) {
      try{thread.sleep(50);} catch(InterruptedException e){}
   }
   initBoard();
   start_firing = true;
   while (!(game_over)) {
      while (!(window.moveMade())&&!(game_over)) {
         try{thread.sleep(50);} catch(InterruptedException e){}
         if (!(window.gameBegin())) opponentSurrender();
      } 
      opponent_move = window.getNextMove(); 
      window.resetMove();
      getNextShot();	// method to get opponent's shot
      if (result_shot_human(play1, p1_grid, com_x, com_y, hit_ship1))
	 sunk_player1++;
      otherPlayer_turn= false;
      if (sunk_player1==num_ships)
      {
	  declare_winner();
	  disable_buttons(play2);
	  reveal(play2, p2_grid);
	  reveal(play1, p1_grid);
          game_over=true;
      }
   }
}
//###########################################################################
public void opponentSurrender()
{
    message_out("Your opponent has surrendered to your military might!!!   GAME OVER.");
    endGame();	
} 
//###########################################################################
public void initCom()
{
    	window.start();  
    	window.show();  
}

//###########################################################################
//   get opponent coordinates 
public void getNextShot()
{
   int next;
   String temp;

   message_out("Got opponent's shot, your move!!!\n");
   System.out.println("Got next shot coord " + opponent_move);
   next = opponent_move.indexOf('-');  		//get position of next delimiter
   temp = opponent_move.substring(0, next);
   com_x = Integer.parseInt(temp.trim());
   temp = opponent_move.substring(next+1);
   com_y = Integer.parseInt(temp.trim());
} 

//###########################################################################
//  send shot coordinates to opponent
public void sendShot(int x, int y)
{
    String myShot;
    message_out("Sending opponent your shot, waiting for opponent's shot...\n");
    myShot = Integer.toString(x) + "-" + Integer.toString(y); 
    System.out.println("Recieved opponent coordinates " + myShot);
    window.sendMove(myShot);  
}
//###########################################################################
//  initialize our board with opponent coordinates
public void initBoard()
{
   String opponentBoard;
   int count = 0;
   
   opponentBoard = window.getNewBoard();
   System.out.println(opponentBoard);
   StringBuffer p2_coord = new StringBuffer(opponentBoard);
   message_out("Recieved opponent ship coordinates...\n");
   for(int i=0; i<max; i++)    		   // convert string buffer to grid
       for(int j=0; j<max; j++) {     
 	  p2_grid[i][j] = p2_coord.charAt(count);
	  count ++;
       }
}

//###########################################################################
// send our board coordinates to other player
public void sendBoard(char area[][])
{
   StringBuffer p1_coord = new StringBuffer(100);
   String myBoard;
   int opponent;

   message_out("Sending your ship coordinates to opponent...\n");
   for(int i=0; i<max; i++)    		   // convert grid to string buffer
       for(int j=0; j<max; j++)      
 	  p1_coord.append(area[i][j]);
   myBoard = (p1_coord.toString());	   // string reference to buffer
   System.out.println(p1_coord.toString());
   window.sendBoard(myBoard);
}

//###########################################################################
// send our board coordinates to other player
public void endGame()
{
   window.quitWindow();
   disable_buttons(play2);
   reveal(play2, p2_grid);
   reveal(play1, p1_grid);
   game_over = true;
}

//#######################################################################
// Rips the integer label off of buttons

public boolean action(Event evt, Object arg) 
{
    if (evt.target instanceof Button) {
        String label = (String)arg;
        if (label.equals("QUIT")){
                message_out("Player quits, GAME OVER.");
	        endGame();
                return true;
	}
           else if (!(otherPlayer_turn))
             {          
         	String r= label.substring(0,1);   
        	String t= label.substring(2,3);
        	int x= Integer.parseInt(r);       // cast as an integer
        	int y= Integer.parseInt(t);       // cast as an integer    
        	game_cont1(x, y);  		  // player vs computer 
      	     }
    	     else
                message_out("Please wait, it is the other players turn!\n");
    }
    return false;
}
   
//#######################################################################
// This resets all the labels on the buttons to grid numbers
public void retag_buttons(Button b[][])
{
  int i, j;
  
  for(i=0; i<max; i++) 	   
    for(j=0; j<max; j++) 
      b[i][j].setLabel(j+","+i);  
}

//#######################################################################
// This disables all the buttons on the given grid.
public void disable_buttons(Button b[][])
{
  int i, j;
  
  for(i=0; i<max; i++) 	   
    for(j=0; j<max; j++) 
      b[i][j].disable();  
}

//#######################################################################
// This enables all the buttons on the given grid.
public void enable_buttons(Button b[][])
{
  int i, j;
  
  for(i=0; i<max; i++) 	   
    for(j=0; j<max; j++) 
      b[i][j].enable();  
}
  
//#######################################################################
// This declares a winner at the end of the game.
public void declare_winner()
{
  if (sunk_player2==num_ships)
    message_out("You are the VICTOR!!!!   GAME OVER\n");
  else if (num_players==2)
  {
    message_out("You are the VICTOR!!!!   GAME OVER\n"); 
  }
  else
  {
//    taps.play();
    message_out("Your battleship has been sunk, you lost!!!  GAME OVER\n");  
  }
}

//####################################################################
// This function controls a one player game.

public void game_cont1(int x, int y)
{ 
  if (!(game_starting))  		// need to place ships
  {
    human_place_ships(play1, p1_grid, x,y);
    if (placed_ships==0)
    {
      disable_buttons(play1);
      enable_buttons(play2);
      initCom();			// establish communications window
      otherPlayer_turn = !(window.whoseTurn());
      game_starting= true;  
    }     
  }

  if (start_firing)    			// start shooting
  {
    if ((sunk_player1<num_ships) && (sunk_player2<num_ships))
    {      
        if (result_shot_human(play2, p2_grid, x, y, hit_ship2))
	   sunk_player2++;
	sendShot(x,y);			// send opponent our shot

	if (sunk_player2<num_ships)
           otherPlayer_turn = true;
        else
        {
	   sendShot(x,y);		// send opponent our last shot
           declare_winner();
	   disable_buttons(play2);
	   reveal(play2, p2_grid);
	   reveal(play1, p1_grid);
           game_over=true;
        }  
     }
  }    
}

//###########################################################################
// This function processes the actual shot, determining if 
//   a ship is hit and/or sunk.
//	 INPUT= play_grid, hits array, x and y of shot
//	OUTPUT= true   if sunk
//	 	false   if still floating
public boolean result_shot_human(Button b[][], char area[][], int y, int x, int hit[])
{
  boolean r=false;

  switch (area[x][y])
  {
    case '-':
	area[x][y]= '*';
        b[x][y].setLabel(" ");
	b[x][y].setBackground(Color.white);
	message_out("You missed...............");
	break;

    case 'A':	
	area[x][y]= 'A';
	b[x][y].setLabel("A");
	b[x][y].setBackground(Color.yellow);
	hit[4]++;
        if (hit[4]<5)
        {
	  message_out("Aircraft carrier is hit");
	  blowup.play();  // play expolsion
        }
        if (hit[4]==5)
	{
	  message_out("Aircraft carrier is sunk!!!!!!");
	  sinking.play();  // play sinking sound	  
	  r=true;
	}
	break;

    case 'B':
	area[x][y]= 'B';
	b[x][y].setLabel("B");
	b[x][y].setBackground(Color.yellow);
	hit[3]++;
	if (hit[3]<4)
	{
          message_out("Battleship is hit");
	  blowup.play();  // play expolsion
        }
	if (hit[3]==4)
	{
	  message_out("Battleship is sunk!!!!!!");
	  sinking.play();  // play sinking sound	  
	  r=true;
	}
	break;

    case 'S':
	area[x][y]= 'S';
	b[x][y].setLabel("S");
	b[x][y].setBackground(Color.yellow);
	hit[2]++;
	if (hit[2]<3)
	{ 
	  message_out("Submarine is hit");
          blowup.play();  // play expolsion
	}
	if (hit[2]==3)
	{
	  message_out("Submarine is sunk!!!!!!");
          sinking.play();  // play sinking sound	  
	  r=true;
	}
	break;

    case 'P':
	area[x][y]= 'P';
	b[x][y].setLabel("P");
	b[x][y].setBackground(Color.yellow);
	hit[1]++;
 	if (hit[1]<2)
	{
          message_out("PT boat is hit");
	  blowup.play();  //play expolsion
	}
	if (hit[1]==2)
	{
	  message_out("PT boat is sunk!!!!!!");
	  sinking.play();  //play sinking sound	  
	  r=true;
	}
	break;

    case 'H':
	greatshotkid.play();  //play expolsion
	area[x][y]= 'H';
	b[x][y].setLabel("H");
	b[x][y].setBackground(Color.yellow);	
	message_out("Headquarters is sunk!!!!!!");	  
	r=true;
	break;
  }
  return r;
}

//#######################################################################
// This outputs the message passed to it
public void message_out(String m)
{
  display.replaceText(blanks, 0, 50);
  display.replaceText(m, 0, 45);
}

//#########################################################################
// This method returns the ship name in relation to length.
public String ship_name()
{
  String name=" ";

  switch(placed_ships)
  {
    case 5:
	name="Aircraft Carrier";
	break;
    case 4:
      	name="Battleship";
	break;
    case 3:
	name="Submarine";
	break;
    case 2:
	name="PT boat";
	break;
    case 1:
        name="Headquarters";
	break;
  }
  return name;
}

//#########################################################################
// checks if a ship can be placed in at least a single direction from
//   the point specified so in human placement a starting point
//   printed on screen is always legal for at least on direction.
public boolean usable_spot (char[][] area, int x, int y)
{
  boolean result=false;
  int dir=0;

  if (check_place(area, x, y, dir))
	result=true;
  dir=1;
  if (check_place(area, x, y, dir))
 	result=true;
  dir=2;
  if (check_place(area, x, y, dir))
 	result=true;
  dir=3;
  if (check_place(area, x, y, dir))
 	result=true;
  return result;
}

//#########################################################################
//	checks if the placed_ship fits in the area if given position and
//	direction

public boolean check_place(char[][] area, int x, int y, int dir)
{
  int i=0;
  boolean ret_val=true;

  switch (dir)
  {
    case 1:
        for(i=y; i<(y+placed_ships); i++)	  
	{
	  if ((i>(max-1)) || (area[x][i] != '-'))
	    ret_val=false;
        }	  	    
        break;

    case 3:
	for(i=y; i>(y-placed_ships); i--)
	{
 	  if ((i<0) || (area[x][i] != '-'))
	    ret_val=false;
	}
	break;

    case 0:
	for(i=x; i>(x-placed_ships); i--)
	{
	  if ((i<0) || (area[i][y] != '-'))
	    ret_val=false;
	}
	break;

    case 2:
	for(i=x; i<(x+placed_ships); i++)
	{
	  if ((i>(max-1)) || (area[i][y] != '-'))
	    ret_val=false;
	}
	break;
    } // end of switch (dir)
  return ret_val;
}

//#########################################################################
// the x and y should be reversed

public void human_place_ships(Button b[][], char area[][], int y, int x)
{
  if ((area[x][y] == '-') && (first_point) && (usable_spot(area, x, y)))
  {
      switch(placed_ships)
      {
        case 5:
	{
           b[x][y].setLabel(ship_letter());
	   area[x][y]=ship_letterc();
           message_out("Place endpoint of aircraft carrier(5 spaces long)");
	   first_point=false;
	   break;
        }
 	case 4:
	{
           b[x][y].setLabel(ship_letter());
	   area[x][y]=ship_letterc();
           message_out("Place endpoint of battleship(4 spaces long)");	   
	   first_point=false;
           break;
        }
	case 3:
	{
           b[x][y].setLabel(ship_letter());
	   area[x][y]=ship_letterc();
           message_out("Place endpoint of submarine(3 spaces long)");	   
	   first_point=false;
	   break;
        }
	case 2:
	{
           b[x][y].setLabel(ship_letter());
	   area[x][y]=ship_letterc();
           message_out("Place endpoint of PT boat(2 spaces long)");	 
           first_point=false;  
	   break;
        }
	case 1:
	{
           b[x][y].setLabel(ship_letter());
	   area[x][y]=ship_letterc();
	   placed_ships--;
	   retag_buttons(b); //reset all button labels 
	   break;
        }
      } //end of switch statement    
      firstx=x; //store the initial position
      firsty=y;
  }

  //********after first point of ship is placed.
  else if ((area[x][y] == '-') && !(first_point))
  {
    if (check_xy(b, area, x, y))
    {
      first_point=true;
      placed_ships--; //ship placed successfully
      message_out("Place starting point of " + ship_name());
    } 
  }
  else
  {  	
    message_out("Location is unavailable. Try again.");	    
  } 
}

//#########################################################################
// This checks if the placement is legal
 
public boolean check_xy(Button b[][], char area[][], int x, int y)
{
  boolean result=true;
  
  if (firsty==y)
  {
    if (firstx+(placed_ships-1)==x)
      insert_down(b, area, x, y);
    else if (firstx-(placed_ships-1)==x)
      insert_up(b, area, x, y);
    else
      result=false;
  }
  else if (firstx==x)
  {
    if (firsty+(placed_ships-1)==y)
      insert_right(b, area, x, y); 
    else if (firsty-(placed_ships-1)==y)
      insert_left(b, area, x, y); 
    else
      result=false;
  }
  else
  {
    //otherwise it is not legal so need new end-point
    result= false;	    
  }
  if (!(result))
    message_out("Endpoint is not legal. Try again.");
  return result;
}

//#########################################################################
//  This method returns the ship String for corresponding placed_ships value

public String ship_letter()
{
  String letter=" ";

  switch(placed_ships)
  {
     case 1:
	letter="H";
        break;
     case 2:
	letter="P";
        break;
     case 3:
	letter="S";
        break;
     case 4:
	letter="B";
        break;
     case 5:
	letter="A";
        break;
  }
  return letter;
}       

//#########################################################################
//  This method returns the ship String for corresponding placed_ships value
 
public char ship_letterc()
{
  char letter=' ';

  switch(placed_ships)
  {
     case 1:
	letter='H';
        break;
     case 2:
	letter='P';
        break;
     case 3:
	letter='S';
        break;
     case 4:
	letter='B';
        break;
     case 5:
	letter='A';
        break;
  }

  return letter;
}     

//#########################################################################
public void insert_down(Button b[][], char area[][], int x, int y)
{
  int i;

  for(i=firstx; i<=x; i++)
  {
    b[i][firsty].setLabel(ship_letter());
    area[i][firsty]=ship_letterc();
  }
}
//#########################################################################

public void insert_up(Button b[][], char area[][], int x, int y)
{
  int i;

  for(i=firstx; i>=x; i--)
  {
    b[i][firsty].setLabel(ship_letter());
    area[i][firsty]=ship_letterc();
  }
}
//#########################################################################

public void insert_right(Button b[][], char area[][], int x, int y)
{
  int i;

  for(i=firsty; i<=y; i++)
  {
    b[firstx][i].setLabel(ship_letter());
    area[firstx][i]=ship_letterc();
  }
}
//#########################################################################

public void insert_left(Button b[][], char area[][], int x, int y)
{
  int i;

  for(i=firsty; i>=y; i--)
  {
    b[firstx][i].setLabel(ship_letter());
    area[firstx][i]=ship_letterc();
  }
}

//#########################################################################
// This method reveals the playing fields at the end of the game

public void reveal(Button[][] b, char[][] area)
{
  int ii, jj;

  for (ii=0; ii<max; ii++)
    for (jj=0; jj<max; jj++)
    {
      switch(area[ii][jj])
      {
        case '-':  
	  b[ii][jj].setLabel(" "); 
	  break;
	case 'A':
	  b[ii][jj].setLabel("A");
	  break;
	case 'B':
	  b[ii][jj].setLabel("B");
	  break;
	case 'S':
	  b[ii][jj].setLabel("S");
	  break;
	case 'P':
	  b[ii][jj].setLabel("P");
          break;
	case 'H':
	  b[ii][jj].setLabel("H");
	  break;
      }
    }
}
public void stop (){
   window.quitWindow();
}

} //end of class