/*******************************************************************************
 FILE         :   TennisApplet.java 

 COPYRIGHT    :   DMALEX, 1999

 DESCRIPTION  :   Funny tennis 

 PROGRAMMED BY:   Alex Fedosov

 CREATION DATE:   05/11/1999

 LAST UPDATE  :   19/11/1999
*******************************************************************************/

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


// base class for objects which we can move
abstract class MoveableObject
{
   MoveableObject(Dimension _size, Dimension _CourtWidth, int _posX, int _posY)
   {
      CourtWidth = _CourtWidth;
      size       = _size;
      pos        = new Point(_posX, _posY);
      origPos    = new Point(_posX, _posY);
   }
   
   // here we rule over the object's movement
   public abstract void direct(int direction); 
   public abstract void show(Graphics g);
   
   // restore starting position
   public void reset(Graphics g) 
   {
      pos.setLocation(origPos);
      show(g);
   }

   // check for collisions
   public boolean isIntersect(MoveableObject o)
   {
      return pos.x + size.width >= o.pos.x && 
             pos.x <= o.pos.x + o.size.width;
   }
      
   Dimension CourtWidth; // game area
   Dimension size;       // object size  
   Point     pos;        // current object position
   Point     origPos;    // starting position
}


// you know what does 'Racket' means in the game, eh? :-)
// so it's just self-descriptive class => no comments
class Racket extends MoveableObject
{
   Racket(Dimension _size, Dimension _CourtWidth, int _posX, int _posY)
   {
      super(_size, _CourtWidth, _posX, _posY);
      deltaX = 0;
   }
   
   public void reset(Graphics g)
   {
      deltaX = 0;
  		g.clearRect(pos.x-1, pos.y, size.width+2, size.height);
      super.reset(g);
   }
   
   public void show(Graphics g)
   {
      if(deltaX == 0)
         {
  		   g.fillRect(pos.x, pos.y, size.width, size.height);
         return;
         }
      
      if(deltaX > 0)
         {
         // reduce time refresh but increase video-irregularities  ;-(
		   // g.fillRect(pos.x+size.width, pos.y, 1, size.height);
		   g.fillRect(pos.x+1, pos.y, size.width, size.height);
		   g.clearRect(pos.x, pos.y, 1, size.height);
         }
      else
         {
		   // g.fillRect(pos.x, pos.y, 1, size.height);
		   g.fillRect(pos.x, pos.y, size.width, size.height);
		   g.clearRect(pos.x + size.width, pos.y, 1, size.height);
         }
      
      pos.x += deltaX;
      if(pos.x + size.width >= CourtWidth.width || pos.x <= 0)
         {
         deltaX = -deltaX;
         pos.x += deltaX;
         }
   }
   
   public void direct(int direction)
   {
      deltaX = direction;
   }
   
   int deltaX;
}



// just self-descriptive class => no comments
class Ball extends MoveableObject
{
   Ball(Dimension _size, Dimension _CourtWidth, int _posX, int _posY, boolean _fSavePos)
   {
      super(_size, _CourtWidth, _posX, _posY);
      delta    = new Point(0, 0);
      randGen  = new Random(0);
      fSavePos = _fSavePos;
      savePos  = new Point(_posX, _posY);
   }

   int getNextRand()
   {
      // from range -2...2 except 0
      int r = (int)(randGen.nextFloat() * 3) + 1;
      if(r > 2)
         r = r - 5;
      
      return r;
   }
   
   public void direct(int direction)
   {
      if(direction == 0)
         delta = new Point(getNextRand(), getNextRand());
      else
         {
         delta.y = -delta.y;
         // adjust speed
         if(Math.abs(delta.x) == direction)
            delta.x = direction == 1 ? delta.x*2 : delta.x/2;
         }
   }
   
   public void reset(Graphics g)
   {
      if(fSavePos)
         return;
      
      delta = new Point(0, 0);
      g.clearRect(pos.x, pos.y, size.width, size.height);
      super.reset(g);
   }
   
   public void show(Graphics g)
   {
      if(fSavePos) 
         {
         // in the netgame we show the ball based on data from server side
         if(savePos.x != pos.x)
            g.clearRect(savePos.x, savePos.y, size.width, size.height);
         g.fillOval(pos.x, pos.y, size.width, size.height);
         savePos.x = pos.x;
         savePos.y = pos.y;
         return;
         }
      
      if(delta.x == 0 || delta.y == 0)
         {
         // slow down refresh  ;-(
         // g.setColor(Color.red);
         g.fillOval(pos.x, pos.y, size.width, size.height);
         return;
         }

      g.clearRect(pos.x, pos.y, size.width, size.height);
      
      pos.x += delta.x;
      pos.y += delta.y;
      
      if(pos.x + size.width >= CourtWidth.width || pos.x <= 0)
         delta.x = -delta.x;
      
      g.fillOval(pos.x, pos.y, size.width, size.height);
   }
   
   Point   delta;
   Random  randGen;
   boolean fSavePos; // should we save previous position of the ball?
   Point   savePos;  // previous position
}


// main class
class CourtView extends Canvas implements Runnable
{
   Dimension CourtSize  = new Dimension(230, 300);
   Dimension racketSize = new Dimension(40, 5);
   Dimension ballSize   = new Dimension(6, 6);
   
   Racket playerOne = new Racket(racketSize, CourtSize, CourtSize.width/2 - racketSize.width/2, CourtSize.height - racketSize.height);
   Racket playerTwo = new Racket(racketSize, CourtSize, CourtSize.width/2 - racketSize.width/2, 0);
   Ball   ball      = new Ball(ballSize, CourtSize, CourtSize.width/2, CourtSize.height/2, false);
   
   NetSettingsDialog nDlg = null;  // dialog of the net-tuning
   ServerSocket srv       = null;  // server (==null at the client side)
   Socket       socket    = null;  // current connection
   OutputStream os        = null;  // data stream
   InputStream  is        = null;  // data stream
   int          fState    = 0;     // 0 - no requests, 1 - request for single play, 2 - request for netgame
   boolean      isNetGame = false; // what type of the game do we play now?
      
   int    delay = 0;       // wait for nothing 'delay' msec
   int    playerOnePoints; // score for 'our' side
   int    playerTwoPoints; // score for 'opponent' side
   Label  scoreBoard;      // score-board

   
	CourtView(Label _scoreBoard)
	{
      scoreBoard = _scoreBoard;
	   resize(CourtSize);
		setBackground(Color.cyan);                  
	}
	
   public synchronized void Delay(int _delay)
   {
		try{
         switch(_delay)
            {
            case -1: 
               Thread.sleep(1500); 
               break;
               
            case 0:                              
               Thread.sleep(delay/10);
               // strange operation because of strange Thread.sleep(5)
               // behavior with magic parameter's value = 5
               for(int i = 0, j = 0; i < 10000 * delay; i++)
                  j++;
               break;
               
            default:
               delay = _delay;
               break;
            }
         }
		catch(Exception e)
			{
			}
   }
   
   
   void showMsg(String msg)
   {
      scoreBoard.setText(msg);
      Delay(-1); // generally user has very imperfect vision organs :-)
   }
   

   // here is the dedicated bug place! 
   // I should use special synchronized class instead fState variable
   // but I have no time and motivation to do this...
   // ...all the more it still works and main programmers rule is:
   // "if it works don't touch it!" :-)
   public synchronized void start(boolean _isNetGame)
   {
      // what this capricious user wanna now? :-)
      fState = _isNetGame ? 2 : 1;
   }

   
   void closeConnection()
   {
      try{         
         if(os != null)
            {
            os.close();
            os = null;
            }
                  
         if(is != null)
            {
            is.close();
            is = null;
            }
               
         if(socket != null)
            {
            socket.close();            
            socket = null;
            }
               
         if(srv != null)
            {
            srv.close();
            srv = null;
            }
         }
      catch(Exception e)
         {
         os = null;
         is = null;
         socket = null;
         srv = null;
         }
   }
   
   
   boolean selectNetGame()
   {     
      if(nDlg == null)
         nDlg = new NetSettingsDialog();
      
      nDlg.show();
      if(nDlg.fCancel)
         return false;
      
      try{         
         closeConnection();
         showMsg("Looking for server...  ");
         socket = new Socket(InetAddress.getByName(nDlg.txtIPAddr.getText()), Integer.valueOf(nDlg.txtIPPort.getText()).intValue());
         os = socket.getOutputStream();
         is = socket.getInputStream();
         ball = new Ball(ballSize, CourtSize, CourtSize.width/2, CourtSize.height/2, true);         
         }
      catch(Exception e)
         {
         // so I'm server!
         try{            
            showMsg("Server not found. Create new server.");
            srv = new ServerSocket(Integer.valueOf(nDlg.txtIPPort.getText()).intValue(), 5);
            socket = srv.accept();
            os = socket.getOutputStream();
            is = socket.getInputStream();
            ball = new Ball(ballSize, CourtSize, CourtSize.width/2, CourtSize.height/2, false);
            }
         catch(Exception x)
            {
            closeConnection();
            showMsg("Network problems. Tune security in your browser");
            // "Tune security, tune security....." 
            // .... or just force me to do 'signed applet'! :-)
            return false;
            }
         }            
      return true;
    }
                                  
   public void reset(Graphics g)
   {     
      g.clearRect(0, 0, CourtSize.width, CourtSize.height);
      ball.reset(g);
      playerOne.reset(g);
      playerTwo.reset(g);
      showMsg("You: " + String.valueOf(playerOnePoints) + 
              " Opponent: " + String.valueOf(playerTwoPoints));
   }
   
	public synchronized void paint(Graphics g)
	{
      switch(fState)
         {
         case 0: break;
         case 1:
            {
            fState = 0;
            isNetGame = false;
            closeConnection(); // to release other side
            ball = new Ball(ballSize, CourtSize, CourtSize.width/2, CourtSize.height/2, false);
            showMsg("Single play against computer");
            playerTwoPoints = playerOnePoints = 0;
            reset(g);
            break;
            }
            
         case 2:
            {
            fState = 0;
            if(!selectNetGame()) 
               break;
            
            isNetGame = true;
            playerTwoPoints = playerOnePoints = 0;
            reset(g);
            break;
            }
         }
      
     
      if(isNetGame)
         dataExchange();
      else
         // computer's AI very simple and human-loved.... in the meanwhile :-)
         if(ball.pos.x > playerTwo.pos.x + playerTwo.size.width/2)
            playerTwo.direct(1);
         else
            playerTwo.direct(-1);
      
      // lady... sorry... player (server especially) first! :-)
      if(ball.delta.x == 0 && playerOne.deltaX != 0 && ((isNetGame && srv != null) || !isNetGame))
         ball.direct(0);

      // time to win? ...or lose? 
      boolean fBallAtPlayerTwoSide = ball.pos.y <= playerTwo.size.height + 1;
      if(fBallAtPlayerTwoSide || ball.pos.y + ball.size.height >= ball.CourtWidth.height - playerOne.size.height - 1)
         if(ball.isIntersect(fBallAtPlayerTwoSide ? playerTwo : playerOne))
            if(fBallAtPlayerTwoSide  && ball.delta.x *  playerTwo.deltaX > 0 ||
               !fBallAtPlayerTwoSide && ball.delta.x *  playerOne.deltaX > 0)
               ball.direct(1); // speed up
            else
               ball.direct(2); // speed down
         else
            {
            checkScore(fBallAtPlayerTwoSide);
            reset(g);
            }

      // just refresh
      ball.show(g); 
      playerOne.show(g);
      playerTwo.show(g);
	}

   
   void checkScore(boolean playerPoint)
   {
      if(playerPoint)
         playerOnePoints++;
      else
         playerTwoPoints++;
            
      if(playerOnePoints >= 20)
         {
         showMsg("You are winner!");
         playerTwoPoints = playerOnePoints = 0;
         return;
         }
      else               
         if(playerTwoPoints >= 20)
            {
            showMsg("You are loser!");
            playerTwoPoints = playerOnePoints = 0;
            return;
            }      
   }
   
   // reload the function to prevent undesirable view refresh
	public synchronized void update(Graphics g)
	{
      paint(g);
	}
	
	public synchronized void proceedKey(int key)
	{
		switch(key)
		   {
		   case Event.LEFT:  playerOne.direct(-1); break;
		   case Event.RIGHT: playerOne.direct(1);  break;
		   }
	}	
   
   // we can transfer the data byte for byte over the net but our view 
   // area size could exceed 256 size limit! so we need data converter.
   int bytes2coord(byte one, byte two)
   {
      return (one+127) * 255 + two + 127;
   }
   
   Point coord2bytes(int coord)
   {
      Point ret = new Point();
      ret.x = coord / 255;
      ret.y = coord - ret.x * 255;
      ret.x -= 127;
      ret.y -= 127;
      return ret;
   }
   
   synchronized void dataExchange()
   {
		try{
         if(srv == null)
            {
            // I'm client
            byte buf[] = new byte[1];
            buf[0] = (byte)playerOne.deltaX;
            os.write(buf);
                          
            buf = new byte[5];
            is.read(buf); 
            playerTwo.direct(-buf[0]);
            // I don't like 'getter/setter' here :-)
            ball.pos.x = ball.CourtWidth.width  - ball.size.width  - bytes2coord(buf[1], buf[2]);
            ball.pos.y = ball.CourtWidth.height - ball.size.height - bytes2coord(buf[3], buf[4]);
            }
         else
            {
            // I'm server
            byte buf[] = new byte[1];
            is.read(buf); 
            playerTwo.direct(-buf[0]);
                     
            buf = new byte[5];
            buf[0] = (byte)(playerOne.deltaX);
            buf[1] = (byte)coord2bytes(ball.pos.x).x;
            buf[2] = (byte)coord2bytes(ball.pos.x).y;
            buf[3] = (byte)coord2bytes(ball.pos.y).x;
            buf[4] = (byte)coord2bytes(ball.pos.y).y;
            os.write(buf);
            }
         }
		catch(Exception e)
			{
         closeConnection();
         showMsg("Some problem during data transfer.");
         fState = 1;
			}
}

	public void run()
	{
		try{
         // main loop
			while(true)
			   {
				this.repaint(); 
            Delay(0);            
            }
         }
		catch(Exception e)
			{
         showMsg("Sorry, there's some software problem. Bye.");
			}
	}
}


// to bring speed of the computer into accord with human's abilities
class speedRegulator extends Panel
{
   final int maxDelay   = 100;
   Scrollbar scrlSpeed  = new Scrollbar(Scrollbar.HORIZONTAL, 1, 10, 0, maxDelay + 10);
   Label     valueSpeed = new Label();
   CourtView cView;
   int       width;
   int       height;

   speedRegulator(CourtView _cView, int _width, int _height) 
   {
      setLayout(new GridLayout(1, 2));
      add(scrlSpeed);
      add(valueSpeed);
      cView  = _cView;
      width  = _width;
      height = _height;
      
      // speed calibration (roughly)
      long msecBefore = System.currentTimeMillis();
      for(int i = 0; i < 10000000; i++) height = _height;
      long msecAfter = System.currentTimeMillis();
      
      if(msecAfter <= msecBefore)
         scrlSpeed.setValue(maxDelay); // max value
      else      
         scrlSpeed.setValue(Math.max((80 - ((int)(msecAfter - msecBefore))/20), 0));
      
      set();
   }
   
   void set() 
   {
      valueSpeed.setText("Speed delay: " + String.valueOf(scrlSpeed.getValue()));
      cView.Delay(scrlSpeed.getValue());
   }
   
	public boolean handleEvent(Event e) 
	{		
      if(e.target.equals(scrlSpeed))
         {
         set();
   		return true;
         }
      
      return super.handleEvent(e);
   }
   
	public Dimension preferredSize()
   {
      return new Dimension(width, height);
   }
}



// wanna play with the REAL opponent? Select it!
class NetSettingsDialog extends Dialog
{
   Button btnOK        = new Button("  OK  ");
   Button btnCancel    = new Button("Cancel");
   TextField txtIPAddr = new TextField("1.1.1.1");
   TextField txtIPPort = new TextField("8000");
   boolean fCancel     = true;
   
   NetSettingsDialog()
   {
      super(new Frame(), "Network game setting", true);
		setLayout(new GridLayout(4,2));
      
      try{
         add(new Label("Your IP address:"));
         add(new Label(InetAddress.getLocalHost().toString()));
         }
      catch(Exception x)
         {
         // apparently you have very strange IP 
         // and how are you going to play network game in this case? 
         // really I don't care! :-)
         }
      
      Label lblOppon = new Label("IP address of your opponent:");
      add(lblOppon);
		add(txtIPAddr);
      add(new Label("IP port of your opponent:"));
		add(txtIPPort);      
      
      Panel btns = new Panel();
      btns.setLayout(new FlowLayout());
		btns.add(btnOK);
		btns.add(btnCancel);
      add(btns);
      // It's pity but it doesn't work ;-( So use predefined settings instead.
      // int h, w = lblOppon.getFontMetrics(lblOppon.getFont()).stringWidth("IP address of your opponent:  111.111.111.111");
      // h = lblOppon.getFontMetrics(lblOppon.getFont()).getHeight();
      // resize(w + 10, h * 4 + 10);
      resize(350, 150);
   }
   
	public boolean handleEvent(Event e)
   {
      if(e.id == Event.WINDOW_DESTROY)
         {
         hide();
         return true;
         }
      
      return super.handleEvent(e);
   }
      
	public boolean keyDown(Event e, int key)
	{		
      if(key == Event.ENTER || key == Event.ESCAPE)
         {
         fCancel = key == Event.ESCAPE;
         hide();
   		return true;
         }
		return false;
   }
   
	public boolean action(Event e, Object o)
   {
      if(e.target.equals(btnOK) || e.target.equals(btnCancel))
         {
         fCancel = e.target.equals(btnCancel);
         hide();
         return true;
         }
      
      return false;
   }
   
}



public class TennisApplet extends Applet
{
	/**
	 * The entry point for the applet. 
	 */
	public void init()
	{		
		initForm();
	}

   // some useful controls
	Label     scoreBoard = new Label("Press 'Restart' button to begin......");
	Button    btnStart   = new Button("Restart");
	Button    btnNetGame = new Button("NetGame");
	CourtView cView      = new CourtView(scoreBoard); 
   speedRegulator speedReg = new speedRegulator(cView, 200, 20);
	Thread	 threadPic  = null; // game's thread
		
	public boolean keyDown(Event e, int key)
	{		
		cView.proceedKey(key);
		return false;
	}
	
	
	public void start()
	{
		if(threadPic == null)
		{
			threadPic = new Thread(cView);
			threadPic.start();
		}
	}
	
	
	public void stop()
	{
		if(threadPic != null)
		{
			threadPic.stop();
			threadPic = null;
		}
	}  
	
	public boolean action(Event e, Object o)
	{		
		if(e.target.equals(btnStart))
			{
			cView.start(false);
			return true;
			}
      else
		   if(e.target.equals(btnNetGame))
		   	{
		   	cView.start(true);
		   	return true;
		   	}
	
		return false;
	}

	/**
	 * Intializes values for the applet and its components
	 */
	void initForm()
	{
		setBackground(Color.lightGray);
		setForeground(Color.black);
		setLayout(new FlowLayout());
		add(btnStart);
      add(btnNetGame);
		add(scoreBoard);
		add(cView);
		add(speedReg);
	}
}