# Pong-Source - Ich hab kein (fast) Plan? :-/



## Saiba (27. Juni 2005)

Gugus Leute 

 Ich hab da nun son Pong-Sourcecode vor mir. Ich möchte auch son Pong machen, aber vielleicht etwas abgeändert. Aber dazu muss ich zuerst den ganzen Code verstehen >_< und das tu ich leider noch nicht ><''

  Könnte bitte mir ein paar Methoden, Eigenschaften, etc erklären?
  (Oder den Code kommentieren wär noch feiner )

  Wer schwedisch kann, darf mir das Zeug natürlich auch übersetzen =)

  Ich würd mich auf Antworten freuen 

```
import java.awt.Graphics;
  	import java.awt.Event;
  	import java.awt.Color;
  	import java.awt.Point;
  	import java.awt.Rectangle;
  	import java.awt.Image;
  	import java.lang.Thread;
  	import java.lang.Math;
  
  public class JPong extends java.applet.Applet
  		implements Runnable {
  		
  		Thread runner;
  		Image offscreeni;
  		Graphics offscreeng;
  		Rectangle plane; 
  		Point ballPoint, racketPoint, enemyPoint, ballSpeed;
  		boolean start, death = false;
  		int playerScore, enemyScore = 0;
  		int tuffhet = 8;
  		
  		public void init() {
 			offscreeni = createImage(this.size().width, this.size().height);
  			offscreeng = offscreeni.getGraphics();
  			setBackground(Color.black); //keine sehbare wirkung
 			ballPoint = new Point((this.size().width/2), (this.size().height/2)); //Ball im Mittelpunkt.
 			racketPoint = new Point((this.size().width -35), ((this.size().height/2) -25)); //startposition spieler
 			enemyPoint = new Point(35, ((this.size().height/2) -25)); //startposition computers
 			plane = new Rectangle(15, 15, (this.size().width), (this.size().height -30)); //spielfeld
  			ballSpeed = new Point(0,0);
  			repaint();
  		}
  		
  		public void start() {
  			if (runner == null) {
  				runner = new Thread(this);
  				runner.start();
  			}
  		}
  		
  		public void stop() {
  			if (runner != null) {
  				runner.stop();
  				runner = null;
  			}
  		}
  		
  		public void run() {
  			while (true) {
  				checkRacket();
  				checkEnemy();
  				checkWalls();
  				moveBall();
  				moveEnemy(enemyPoint.y + 25);
  				repaint();
 				try {	 Thread.sleep(35); }
 				catch (InterruptedException e) { };
  			}
  			
  		}
  		
  		public boolean mouseMove(Event evt, int x, int y) {
  			racketPoint.y = (y - 25);
  			repaint();
  			return true;
 			// gammal kod fšr att inte lŒta racket Œka utanfšr kanten:
  			// if (y - 25 < 20) racketPoint.y = 20;
 			// else if (y - 25 > (this.size().height -70)) racketPoint.y = (this.size().height -70);
  		}
  		
  		public boolean mouseUp(Event evt, int x, int y) {
  			if (start == false) {
  				ballSpeed.x = 4;
  				ballSpeed.y = 2;
  				start = true;
  			}
  			return true;
  		}
  		
  		void moveBall() {
  			ballPoint.x = (ballPoint.x + ballSpeed.x);
  			ballPoint.y = (ballPoint.y + ballSpeed.y);
  		}		
  		
  		void moveEnemy(int enemyPos) {
  		int dist = java.lang.Math.abs(ballPoint.y - enemyPos);
  			if (ballSpeed.x < 0) {
 		 	if (enemyPos < (ballPoint.y - 3)) enemyPoint.y = (enemyPoint.y + dist/tuffhet);
 		 	else if (enemyPos > (ballPoint.y + 3)) enemyPoint.y = (enemyPoint.y - dist/tuffhet);
  			}
  			else {
 		 	if (enemyPos < (this.size().height / 2 - 3)) enemyPoint.y = (enemyPoint.y + 2);
 		 	else if (enemyPos > (this.size().height / 2 + 3)) enemyPoint.y = (enemyPoint.y - 2);
  			}
  		}
  		
  		void checkRacket() {
 			if (ballSpeed.x < 0) return;	 		 	//Om bollen ršr sig Œt vŠnster È ut.
  			//Om bollen befinner sig MELLAN rackets kanter:
 			if ((ballPoint.x + ballSpeed.x) >= racketPoint.x - 6 & (ballPoint.x < racketPoint.x))
 		 	if ((ballPoint.y + 8) > racketPoint.y & ballPoint.y < (racketPoint.y + 50)) {	
 		 		//y-fšrflyttning skall škas/minskas:
 		 		int racketHit = (ballPoint.y - (racketPoint.y +25));
 		 		ballSpeed.y = (ballSpeed.y + (racketHit/7));
 		 		//x-fšrflyttning skall inverteras:
 					ballSpeed.x = (ballSpeed.x * -1);
  				}
  		}
  		
  		void checkEnemy() {
 			if (ballSpeed.x > 0) return;	 		 	//Om bollen ršr sig Œt hšger È ut.
  			//Om bollen befinner sig MELLAN rackets kanter:
 			if ((ballPoint.x + ballSpeed.x) <= enemyPoint.x + 4 & (ballPoint.x > enemyPoint.x))
 		 	if ((ballPoint.y + 8) > enemyPoint.y & ballPoint.y < (enemyPoint.y + 50)) {
 		 		//y-fšrflyttning skall škas/minskas:
 		 		int racketHit = (ballPoint.y - (enemyPoint.y +25));
 		 		ballSpeed.y = (ballSpeed.y + (racketHit/7));
 		 		//x-fšrflyttning skall inverteras:
 					ballSpeed.x = (ballSpeed.x * -1);
  				}
  		}
  		
  		void checkWalls() {
 			if ((ballPoint.x + ballSpeed.x) <= plane.x) 		miss(); 		 		 // vŠnster kant.
 			if ((ballPoint.x + ballSpeed.x) >= (plane.width - 20)) 	miss();	 		 	// hšger kant.
 			if ((ballPoint.y + ballSpeed.y) <= plane.y) 		ballSpeed.y = (ballSpeed.y * -1);	// švre kant.
 			if ((ballPoint.y + ballSpeed.y) >= (plane.height + 8)) 	ballSpeed.y = (ballSpeed.y * -1); // nedre kant.
  		}
  		
  		void miss() {
  			if (ballSpeed.x < 0) {
 				playerScore = (playerScore + 1);
 				if (tuffhet > 2) tuffhet = (tuffhet - 1);
  			}
  			else enemyScore = (enemyScore + 1);
  			ballSpeed.x = (ballSpeed.x * -1);
  			ballPoint.x = (ballPoint.x + ballSpeed.x);
  			
  			for (int i = 3; i > 0; i = (i - 1)) {
  				death = true;
  				repaint();
 				try {	 Thread.sleep(300); }
 				catch (InterruptedException e) { };
  				death = false;
  				repaint();
 				try {	 Thread.sleep(300); }
 				catch (InterruptedException e) { };
  			}
  			
 			ballPoint = new Point((this.size().width/2), (this.size().height/2)); //Bollen startar pŒ mittpunkten.
  			ballSpeed.x = 0;
  			ballSpeed.y = 0;
  			start = false;
  			
  		}
  		
  		public void update(Graphics g) {
  			paint(g);
  		}
  		
  		public void paint(Graphics g) {
  			offscreeng.setColor(Color.red);
 			offscreeng.fillRect(0,0,this.size().width, this.size().height);
  			
  			if (death == false) offscreeng.setColor(Color.blue);
 			else offscreeng.setColor(Color.yellow); //lightGray; farbe fürs blinken
 			offscreeng.drawString(Integer.toString(enemyScore), 100, 35);
 			offscreeng.drawString(Integer.toString(playerScore), 215, 35);
  		    offscreeng.clipRect(plane.x, plane.y, plane.width - 28, plane.height + 1);
 			offscreeng.drawRect(plane.x, plane.y, plane.width - 30, plane.height);
 			offscreeng.fillRect(racketPoint.x, racketPoint.y, 6,50);
  			offscreeng.fillRect(enemyPoint.x, enemyPoint.y, 6, 50);
  			offscreeng.fillOval(ballPoint.x, ballPoint.y, 8, 8);
  			//HŠr ritas bufferytan ut:
  			g.drawImage(offscreeni,0,0,this);
  		
  		}
  	}
```
 

 Oder jemand hätte mir ein anderes Pong, welches einfanger ist zum erstellen *g*...
 Oder ein Tutorial für ein ganzes Pong wär der hammer.
 Ich muss nämlich gerade nen Java-Projekt machen, und hab eben Pong ausgewählt >_<''


----------



## teppi (27. Juni 2005)

Hallo!

In diesem Thread:

http://www.tutorials.de/tutorials176378.html

findest du Links zu Tutorials, die die grundlegenden Konzepte eigentlich ganz gut erklären. Also Threads, Events, Doublebuffering usw. .. 

Schau dich da mal um.

Gruß Stefan


----------



## Billie (27. Juni 2005)

> Könnte bitte mir ein paar Methoden, Eigenschaften, etc erklären?



Ein paar... dann sag welche "paar" und wenn du alles nicht verstehst, solltest du sowieso weiter hinten anfangen, zB mit den oben gelinkten Tutorials.


----------



## Saiba (29. Juni 2005)

Hi.. Danke für die Posts.
 Mittlerweile hab ich das "zusammengestellt" *g*:


```
import java.applet.*;
 import java.awt.*;
 
 public class Brett extends Applet implements Runnable
 {
 	// Initialisierung der Variablen
 	int x_pos = 30;			// x - Position des Balles
 	int y_pos = 100;		// y - Position des Balles
 	int x_speed = 10;		// Geschwindigkeit des Balles in x - Richtung
 	int y_speed = 10;
 	int radius = 20;		// Radius des Balles
 	int appletsize_x = 300; // Größe des Applets in x - Richtung
 	int appletsize_y = 300;	// Größe des Applets in y - Richtung
 
 	// Variablen für die Doppelpufferung
 	private Image dbImage;
 	private Graphics dbg;
 
 	public void init()
 	{
 		setBackground (Color.gray);
 	}
 
 	public void start ()
 	{
 		// Schaffen eines neuen Threads, in dem das Spiel läuft
 		Thread th = new Thread (this);
 		// Starten des Threads
 		th.start ();
 	}
 
 	public void stop()
 	{
 
 	}
 
 	public void destroy()
 	{
 
 	}
 
 	/* Diese Methode fängt das Ereigniss auf, das beim Drücken einer Keyboardtaste entsteht.
 	Die Tasten Cursor links, rechts und die Space Taste haben dabei eine bestimmte Bedeutung.
 	Wird eine andere Taste gedrückt, so wird ihr Integerwert in die Standardausgabe geschrieben. */
 	public boolean keyDown (Event e, int key)
 	{
 		// linke Cursortaste
 		if (key == Event.LEFT)
 		{
 			// Ball bewegt sich dann nach links
 			x_speed = -10;
 		}
 		// rechte Cursortaste
 		else if (key == Event.RIGHT)
 		{
 			// Ball bewegt sich dann nach rechts
 			x_speed = 10;
 		}
 //		 NACH UNTEN
 		if (key == Event.DOWN)
 		{
 			// Ball bewegt sich dann nach unten
 			y_speed = 10;
 		}
 //		 NACH OBEN
 		if (key == Event.UP)
 		{
 			// Ball bewegt sich dann nach oben
 			y_speed = -10;
 			System.out.println("asdf");
 		}
 		// Leertaste hat Wert 32
 		else if (key == 32)
 		{
 			x_speed = 0;
 			y_speed = 0;
 		}
 		else
 		{
 			// Ausgabe von gedrüktem Key und Zahlenwert an die Standardausgabe
 		    //System.out.println ("Charakter: " + (char)key + " Integer Value: " + key);
 		}
 
 		return true;
 	}
 
 	public void run ()
 	{
 		// Erniedrigen der ThreadPriority um zeichnen zu erleichtern
 		Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
 
 		// Solange true ist läuft der Thread weiter
 		while (true)
 		{
 			// Wenn der Ball den rechten Rand berührt, dann prallt er ab
 			if (x_pos > appletsize_x - radius)
 			{
 				// Ändern der Richtung des Balles
 				x_speed = -1;
 			}
 			// Ball brührt linken Rand und prallt ab
 			else if (x_pos < radius)
 			{
 				// Ändern der Richtung des Balles
 				x_speed = +1;
 			}
 
 			// Verändern der x- Koordinate
 			x_pos += x_speed;
 			
 			// Neuzeichnen des Applets
 			repaint();
 
 			try
 			{
 		    	// Stoppen des Threads für in Klammern angegebene Millisekunden
 				Thread.sleep (20);
 			}
 			catch (InterruptedException ex)
 			{
 				// do nothing
 			}
 
 			// Zurücksetzen der ThreadPriority auf Maximalwert
 			Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
 		}
 	}
 
 	
 	
 	
 	public void run2 ()
 	{
 		// Erniedrigen der ThreadPriority um zeichnen zu erleichtern
 		Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
 
 		// Solange true ist läuft der Thread weiter
 		while (true)
 		{
 			// Wenn der Ball den rechten Rand berührt, dann prallt er ab
 			if (y_pos > appletsize_y - radius)
 			{
 				// Ändern der Richtung des Balles
 				y_speed = -1;
 			}
 			// Ball brührt linken Rand und prallt ab
 			else if (y_pos < radius)
 			{
 				// Ändern der Richtung des Balles
 				y_speed = +1;
 			}
 
 			// Verändern der x- Koordinate
 			y_pos += y_speed;
 			
 			// Neuzeichnen des Applets
 			repaint();
 
 			try
 			{
 		    	// Stoppen des Threads für in Klammern angegebene Millisekunden
 				Thread.sleep (20);
 			}
 			catch (InterruptedException ex)
 			{
 				// do nothing
 			}
 
 			// Zurücksetzen der ThreadPriority auf Maximalwert
 			Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
 		}
 	}
 	
 	
 	
 	
 	
 	/** Update - Methode, Realisierung der Doppelpufferung zur Reduzierung des Bildschirmflackerns */
 	public void update (Graphics g)
 	{
 		// Initialisierung des DoubleBuffers
 		if (dbImage == null)
 		{
 			dbImage = createImage (this.getSize().width, this.getSize().height);
 			dbg = dbImage.getGraphics ();
 		}
 
 		// Bildschirm im Hintergrund löschen
 		dbg.setColor (getBackground ());
 		dbg.fillRect (0, 0, this.getSize().width, this.getSize().height);
 
 		// Auf gelöschten Hintergrund Vordergrund zeichnen
 		dbg.setColor (getForeground());
 		paint (dbg);
 
 		// Nun fertig gezeichnetes Bild Offscreen auf dem richtigen Bildschirm anzeigen
 		g.drawImage (dbImage, 0, 0, this);
 	}
 
 	public void paint (Graphics g)
 	{
 		g.setColor  (Color.white);
 
 		g.fillOval (x_pos - radius, y_pos - radius, 2 * radius, 2 * radius);
 	}
 }
```
 
 Nun kann ich ja bewegen. aber NUR nach LINKS und Rechts... 
 Ich versteh's net, wieso kann ich net nach unten und nach oben bewegen, den ball... >_<


----------



## Saiba (29. Juni 2005)

Ach ja: Es ist ja ein Applet wie man's sehen, kann. So bitte ich euch diese Klasse in einer html-datei zu laden zur besseren Ansicht.
 Jedenfalls bei mir im Eclipse sieht's im Vorschau nicht so aus wie ich's ansehen will


----------



## teppi (29. Juni 2005)

Es wird jeweils nur genau die run() Methode ausgeführt bei Thread.start() .. Wenn du die die 2 hinter run2() entfernst und diese dafür bei der "alten" Methode einsetzt kannst du den Ball hoch und runter bewegen. Um alles zu kombinieren musst du den entsprechenden Code in einer einzigen run() Methode zusammen fassen ...


----------



## Saiba (29. Juni 2005)

Danke für deine Hilfe...

hab einfach nur 
	
	
	



```
if (y_pos > appletsize_y - radius)
			{
				// Ändern der Richtung des Balles
				y_speed = -1;
			}
			else if (y_pos < radius)
			{
				// Ändern der Richtung des Balles
				y_speed = +1;
			}
```
Und 
	
	
	



```
y_pos += y_speed;
```
 eingefügt und dann ging's  so ma weiterschaun =)


----------

