[mirrors/Programs.git] / java / pong / pong.java

import static java.lang.Math.*;
import javax.swing.*;
import java.awt.*;

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;

import java.io.*;
import java.net.*;

/** Class implementing network interface for PongPanel objects */
class PongNetwork implements Runnable {
  BufferedReader br;
  BufferedWriter bw;
	Socket sock;
  String host = "localhost";
  int port = 1033;

	PongPanel pp = null;

  /** constructor should be given instance of PongPanel to interface with and hostname to connect to */
	PongNetwork(PongPanel pp, String host) {
		this.pp = pp;
    this.host = host;
    Thread t = new Thread(this);
    t.start();
	}

  /** creates new thread which tries to connect to existing server on desired host and if it's not listening it starts own socket server. */
  public void run() {
		try {
	    if(!this.startClient(port)) this.startServer(port);

			br = new BufferedReader(new InputStreamReader(sock.getInputStream()));
			bw = new BufferedWriter(new OutputStreamWriter(sock.getOutputStream()));

			if(pp.right == 0) {
				send("0.5,-5,-7");
				send("0.5,-5,-7");
			}

			String s = "";
			while (s != null) {
				s = br.readLine();
				if (s == null) continue;
				System.out.println(s);
        pp.putBall(s);
			}
			sock.close();
			System.out.println("Remote host closed connection :-(");
			System.out.println("Your score was: "+ pp.score + " against oponent's score: " + pp.score_oponent);
      System.exit(0);
		} catch(Exception e) {
			System.out.println("Something's wrong with connection :-(");
		}
  }

  /** start own server */
	boolean startServer(int port) {
		pp.right = 1;
    System.out.println("Starting server on port "+port+" ...");
		try {
			ServerSocket ss = new ServerSocket(port);
			sock = ss.accept();
      System.out.println("Client connected!");	    
		} catch(Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

  /** try to connect to existing server */
	boolean startClient(int port) {
		pp.right = 0;
		System.out.println("Connecting to server "+host+":"+port+" ...");
		try {
			sock = new Socket();
			sock.connect(new InetSocketAddress(host, port), 2000);
			System.out.println("Connected to server!");
		} catch (Exception e) {
			System.out.println("Connection failed!");
			return false;
		}
		return true;
	}

  /** once connection to another pong instance is estabilished, we can send data using this method */
  public void send(String s) {
    try {
      bw.write(s+"\n");  // zapíšeme předem připravený požadavek
      bw.flush();         // odeslání z bufferu
    } catch(Exception e) {
    }
  }

}

/** Pong Panel is object painted on main pong window (PongFrame) and contains all methods and variables needed to play pong */
class PongPanel extends JPanel implements KeyListener, MouseMotionListener { 
  PongNetwork pn;

	int right = 1; //right (1) or left (0)?

	int pad_pos = 50; //0-100;
	int pad_speed = 10;
	int pad_thickness = 10;
	int pad_size = 70;

	public int score = 0;
	public int score_oponent = 0;

  boolean have_ball = false;
	int ball_pos_x, ball_pos_y;
	int ball_mov_x, ball_mov_y;
	int ball_size = 10;

  /** new round is called when your opponent scored */
	public void newRound() {
    if(!have_ball) return;
		ball_pos_x = getWidth()/2;
		ball_pos_y = getHeight()/2;
		ball_mov_x = 7*(right==0?-1:1);
		ball_mov_y = 3;
	}

  /** Constructor */
  public PongPanel(int x, int y, String host) { 
    setSize(x, y);
		//newRound();
		addKeyListener(this);
		addMouseMotionListener(this);
    pn = new PongNetwork(this, host);
  }

  /** Repaint game window */
  public void paint(Graphics g) { 
		//createBufferStrategy(2); //double buffered
		Graphics2D g2D=(Graphics2D) g; // cast to 2D
		g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
			RenderingHints.VALUE_ANTIALIAS_ON);

		g.setColor(Color.WHITE);
		g.setColor(Color.BLACK);
		g.fillRect(0,0, getWidth(), getHeight());
		g.setColor(Color.GREEN);

    if(have_ball) g.fillOval(ball_pos_x-(ball_size/2), ball_pos_y-(ball_size/2), ball_size, ball_size); // draw ball
    
		g.fillRect(right*(getWidth()-pad_thickness), pad_pos, pad_thickness, pad_size); // draw pad
    g.drawString("PONG! "+score+":"+score_oponent, 20,20);
  } 

  /** increment score of your oponent */
	public void oponentScores() {
		score_oponent++;
    pn.send("+gotme :-)"); //HEY! do not comment this you cheater! :-P
		newRound();
	}

  /** compute next iteration of game and repaint screen */
	public boolean tick() {
    if(have_ball) {
      ball_pos_x += ball_mov_x;
      ball_pos_y += ball_mov_y;
      if(ball_pos_y >= getHeight() || ball_pos_y <= 0) ball_mov_y = -ball_mov_y; //bounce

      if(
          (
            (right == 1 && ball_pos_x >= (getWidth()-pad_thickness-round(ball_size/2))) ||
            (right == 0 && ball_pos_x <= pad_thickness+round(ball_size/2))
          ) &&
          (
            ball_pos_y >= pad_pos &&
            ball_pos_y <= pad_pos + pad_size
          )
      ) {
        ball_mov_x = -ball_mov_x;
      }

      else if(
        (right == 1 && ball_pos_x >= getWidth()) ||
        (right == 0 && ball_pos_x <= 0)
      ) oponentScores();

      else if(
        (right == 0 && ball_pos_x >= getWidth()) ||
        (right == 1 && ball_pos_x <= 0)
      ) {
        //send ball over network
        pn.send(getBall());
        have_ball = false; super.repaint();
        //newRound();
        return false;
      }

      //putBall(getBall()); //haloooz s roundem
    }

		super.repaint();
		return true;
	}

  /** serialize ball (position and speed) to be sent over TCP/IP socket */
	public String getBall() {
    have_ball = false;
    return(
      ((float)ball_pos_y / (float)getHeight()) +
      ","+ball_mov_x +
      ","+ball_mov_y +
      ","+right

		);

	}

  /** deserialize ball received through TCP/IP connection */
	public void putBall(String ball) {
    if(ball.charAt(0) == '+') {
      score++;
      return;
    }
    have_ball = true;
    String[] vars = ball.trim().split(",");
    System.out.println("Parsing: "+vars[0]+" "+vars[1]+" "+vars[2]);
    ball_pos_x = (right==1)?pad_thickness+ball_size:getWidth()-(pad_thickness+ball_size);
    ball_pos_y = (int)round(getHeight()*(new Double(vars[0])));
    ball_mov_x = new Integer(vars[1]);
    ball_mov_y = new Integer(vars[2]);
    System.out.println("Parsed: "+ball_pos_y+" "+ball_mov_x+" "+ball_mov_y);
	}

	public void keyPressed(KeyEvent evt) {
		int keyCode = evt.getKeyCode();
		if(keyCode == KeyEvent.VK_UP && pad_pos >= pad_speed) pad_pos -= pad_speed;
		if(keyCode == KeyEvent.VK_DOWN && pad_pos <= (100-pad_speed)) pad_pos += pad_speed;
		super.repaint();
  }

  public void keyReleased(KeyEvent evt) {
  }

  public void keyTyped(KeyEvent evt) {
  }
  public boolean isFocusTraversable() { return true; }

	public void mouseMoved(MouseEvent e) {
		pad_pos = e.getY()-(pad_size/2);
	}
	public void mouseDragged(MouseEvent e) {
	}

}

/** Main window of game */
class PongFrame extends JFrame {
	PongPanel pp;
	PongFrame(int x, int y, String host) throws InterruptedException {
		this.setSize(x,y);
		this.setTitle("NetPong");
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		pp=new PongPanel(getWidth(),getHeight(),host);
		this.getContentPane().add(pp); 

		this.setVisible(true);
	}

  /** start game */
	public void play() throws InterruptedException {
		while(true) {
			pp.tick();
			//if(!pp.tick()) Thread.sleep(2*1000);
			Thread.sleep(1000/24);
		}
	}

}

/**
 * Implementation of classical "PONG" game modified to pass ball over TCP/IP connection.
 * You need to run two instances (client + server).
 * Game takes one optional commandline argument specifiing remote host running the server (localhost is default).
 * If there's no server running on desired hostname, server is started on local machine on port 1033.
 * Copylefted by: Harvie 2o1o
 * @author      Thomas Harvie Mudrunka (mudruto1)
 * @version     1.0
 */

public class pong {
	public static void main(String[] args) throws InterruptedException {
		PongFrame pf = new PongFrame(640,480,args.length>0?args[0]:"127.0.0.1");
		pf.play();
	}
}
Commit	Line	Data
	1	import static java.lang.Math.*;
	2	import javax.swing.*;
	3	import java.awt.*;
	4
	5	import java.awt.event.KeyEvent;
	6	import java.awt.event.KeyListener;
	7	import java.awt.event.MouseEvent;
	8	import java.awt.event.MouseMotionListener;
	9
	10	import java.io.*;
	11	import java.net.*;
	12
	13	/** Class implementing network interface for PongPanel objects */
	14	class PongNetwork implements Runnable {
	15	BufferedReader br;
	16	BufferedWriter bw;
	17	Socket sock;
	18	String host = "localhost";
	19	int port = 1033;
	20
	21	PongPanel pp = null;
	22
	23	/** constructor should be given instance of PongPanel to interface with and hostname to connect to */
	24	PongNetwork(PongPanel pp, String host) {
	25	this.pp = pp;
	26	this.host = host;
	27	Thread t = new Thread(this);
	28	t.start();
	29	}
	30
	31	/** creates new thread which tries to connect to existing server on desired host and if it's not listening it starts own socket server. */
	32	public void run() {
	33	try {
	34	if(!this.startClient(port)) this.startServer(port);
	35
	36	br = new BufferedReader(new InputStreamReader(sock.getInputStream()));
	37	bw = new BufferedWriter(new OutputStreamWriter(sock.getOutputStream()));
	38
	39	if(pp.right == 0) {
	40	send("0.5,-5,-7");
	41	send("0.5,-5,-7");
	42	}
	43
	44	String s = "";
	45	while (s != null) {
	46	s = br.readLine();
	47	if (s == null) continue;
	48	System.out.println(s);
	49	pp.putBall(s);
	50	}
	51	sock.close();
	52	System.out.println("Remote host closed connection :-(");
	53	System.out.println("Your score was: "+ pp.score + " against oponent's score: " + pp.score_oponent);
	54	System.exit(0);
	55	} catch(Exception e) {
	56	System.out.println("Something's wrong with connection :-(");
	57	}
	58	}
	59
	60	/** start own server */
	61	boolean startServer(int port) {
	62	pp.right = 1;
	63	System.out.println("Starting server on port "+port+" ...");
	64	try {
	65	ServerSocket ss = new ServerSocket(port);
	66	sock = ss.accept();
	67	System.out.println("Client connected!");
	68	} catch(Exception e) {
	69	e.printStackTrace();
	70	return false;
	71	}
	72	return true;
	73	}
	74
	75	/** try to connect to existing server */
	76	boolean startClient(int port) {
	77	pp.right = 0;
	78	System.out.println("Connecting to server "+host+":"+port+" ...");
	79	try {
	80	sock = new Socket();
	81	sock.connect(new InetSocketAddress(host, port), 2000);
	82	System.out.println("Connected to server!");
	83	} catch (Exception e) {
	84	System.out.println("Connection failed!");
	85	return false;
	86	}
	87	return true;
	88	}
	89
	90	/** once connection to another pong instance is estabilished, we can send data using this method */
	91	public void send(String s) {
	92	try {
	93	bw.write(s+"\n"); // zapíšeme předem připravený požadavek
	94	bw.flush(); // odeslání z bufferu
	95	} catch(Exception e) {
	96	}
	97	}
	98
	99	}
	100
	101	/** Pong Panel is object painted on main pong window (PongFrame) and contains all methods and variables needed to play pong */
	102	class PongPanel extends JPanel implements KeyListener, MouseMotionListener {
	103	PongNetwork pn;
	104
	105	int right = 1; //right (1) or left (0)?
	106
	107	int pad_pos = 50; //0-100;
	108	int pad_speed = 10;
	109	int pad_thickness = 10;
	110	int pad_size = 70;
	111
	112	public int score = 0;
	113	public int score_oponent = 0;
	114
	115	boolean have_ball = false;
	116	int ball_pos_x, ball_pos_y;
	117	int ball_mov_x, ball_mov_y;
	118	int ball_size = 10;
	119
	120	/** new round is called when your opponent scored */
	121	public void newRound() {
	122	if(!have_ball) return;
	123	ball_pos_x = getWidth()/2;
	124	ball_pos_y = getHeight()/2;
	125	ball_mov_x = 7*(right==0?-1:1);
	126	ball_mov_y = 3;
	127	}
	128
	129	/** Constructor */
	130	public PongPanel(int x, int y, String host) {
	131	setSize(x, y);
	132	//newRound();
	133	addKeyListener(this);
	134	addMouseMotionListener(this);
	135	pn = new PongNetwork(this, host);
	136	}
	137
	138	/** Repaint game window */
	139	public void paint(Graphics g) {
	140	//createBufferStrategy(2); //double buffered
	141	Graphics2D g2D=(Graphics2D) g; // cast to 2D
	142	g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
	143	RenderingHints.VALUE_ANTIALIAS_ON);
	144
	145	g.setColor(Color.WHITE);
	146	g.setColor(Color.BLACK);
	147	g.fillRect(0,0, getWidth(), getHeight());
	148	g.setColor(Color.GREEN);
	149
	150	if(have_ball) g.fillOval(ball_pos_x-(ball_size/2), ball_pos_y-(ball_size/2), ball_size, ball_size); // draw ball
	151
	152	g.fillRect(right*(getWidth()-pad_thickness), pad_pos, pad_thickness, pad_size); // draw pad
	153	g.drawString("PONG! "+score+":"+score_oponent, 20,20);
	154	}
	155
	156	/** increment score of your oponent */
	157	public void oponentScores() {
	158	score_oponent++;
	159	pn.send("+gotme :-)"); //HEY! do not comment this you cheater! :-P
	160	newRound();
	161	}
	162
	163	/** compute next iteration of game and repaint screen */
	164	public boolean tick() {
	165	if(have_ball) {
	166	ball_pos_x += ball_mov_x;
	167	ball_pos_y += ball_mov_y;
	168	if(ball_pos_y >= getHeight() \|\| ball_pos_y <= 0) ball_mov_y = -ball_mov_y; //bounce
	169
	170	if(
	171	(
	172	(right == 1 && ball_pos_x >= (getWidth()-pad_thickness-round(ball_size/2))) \|\|
	173	(right == 0 && ball_pos_x <= pad_thickness+round(ball_size/2))
	174	) &&
	175	(
	176	ball_pos_y >= pad_pos &&
	177	ball_pos_y <= pad_pos + pad_size
	178	)
	179	) {
	180	ball_mov_x = -ball_mov_x;
	181	}
	182
	183	else if(
	184	(right == 1 && ball_pos_x >= getWidth()) \|\|
	185	(right == 0 && ball_pos_x <= 0)
	186	) oponentScores();
	187
	188	else if(
	189	(right == 0 && ball_pos_x >= getWidth()) \|\|
	190	(right == 1 && ball_pos_x <= 0)
	191	) {
	192	//send ball over network
	193	pn.send(getBall());
	194	have_ball = false; super.repaint();
	195	//newRound();
	196	return false;
	197	}
	198
	199	//putBall(getBall()); //haloooz s roundem
	200	}
	201
	202	super.repaint();
	203	return true;
	204	}
	205
	206	/** serialize ball (position and speed) to be sent over TCP/IP socket */
	207	public String getBall() {
	208	have_ball = false;
	209	return(
	210	((float)ball_pos_y / (float)getHeight()) +
	211	","+ball_mov_x +
	212	","+ball_mov_y +
	213	","+right
	214
	215	);
	216
	217	}
	218
	219	/** deserialize ball received through TCP/IP connection */
	220	public void putBall(String ball) {
	221	if(ball.charAt(0) == '+') {
	222	score++;
	223	return;
	224	}
	225	have_ball = true;
	226	String[] vars = ball.trim().split(",");
	227	System.out.println("Parsing: "+vars[0]+" "+vars[1]+" "+vars[2]);
	228	ball_pos_x = (right==1)?pad_thickness+ball_size:getWidth()-(pad_thickness+ball_size);
	229	ball_pos_y = (int)round(getHeight()*(new Double(vars[0])));
	230	ball_mov_x = new Integer(vars[1]);
	231	ball_mov_y = new Integer(vars[2]);
	232	System.out.println("Parsed: "+ball_pos_y+" "+ball_mov_x+" "+ball_mov_y);
	233	}
	234
	235	public void keyPressed(KeyEvent evt) {
	236	int keyCode = evt.getKeyCode();
	237	if(keyCode == KeyEvent.VK_UP && pad_pos >= pad_speed) pad_pos -= pad_speed;
	238	if(keyCode == KeyEvent.VK_DOWN && pad_pos <= (100-pad_speed)) pad_pos += pad_speed;
	239	super.repaint();
	240	}
	241
	242	public void keyReleased(KeyEvent evt) {
	243	}
	244
	245	public void keyTyped(KeyEvent evt) {
	246	}
	247	public boolean isFocusTraversable() { return true; }
	248
	249	public void mouseMoved(MouseEvent e) {
	250	pad_pos = e.getY()-(pad_size/2);
	251	}
	252	public void mouseDragged(MouseEvent e) {
	253	}
	254
	255	}
	256
	257	/** Main window of game */
	258	class PongFrame extends JFrame {
	259	PongPanel pp;
	260	PongFrame(int x, int y, String host) throws InterruptedException {
	261	this.setSize(x,y);
	262	this.setTitle("NetPong");
	263	this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	264
	265	pp=new PongPanel(getWidth(),getHeight(),host);
	266	this.getContentPane().add(pp);
	267
	268	this.setVisible(true);
	269	}
	270
	271	/** start game */
	272	public void play() throws InterruptedException {
	273	while(true) {
	274	pp.tick();
	275	//if(!pp.tick()) Thread.sleep(2*1000);
	276	Thread.sleep(1000/24);
	277	}
	278	}
	279
	280	}
	281
	282	/**
	283	* Implementation of classical "PONG" game modified to pass ball over TCP/IP connection.
	284	* You need to run two instances (client + server).
	285	* Game takes one optional commandline argument specifiing remote host running the server (localhost is default).
	286	* If there's no server running on desired hostname, server is started on local machine on port 1033.
	287	* Copylefted by: Harvie 2o1o
	288	* @author Thomas Harvie Mudrunka (mudruto1)
	289	* @version 1.0
	290	*/
	291
	292	public class pong {
	293	public static void main(String[] args) throws InterruptedException {
	294	PongFrame pf = new PongFrame(640,480,args.length>0?args[0]:"127.0.0.1");
	295	pf.play();
	296	}
	297	}