# Spiel neustarten



## enzo545 (13. Feb 2012)

Hallo zusammen, 
ich versuche gerade in meinem Spiel eine neustart Funktion einzubauen. 
Folgendes überlegt.:
Die run() Methode läuft solange der Player != 0 Leben hat, also erstelle ich einfach eine neue Methode restart() und setze da alle Variablen, die noch mit dem Spiel zu tun haben (sprich: Leben, Score...), auf ihren Anfangswert.
Die Methode restart() lass ich dann durch die Taste Enter ausführen.
Ergebnis ???:L = Funktioniert ZUM TEIL, WEIL...
- die Bilder bzw. Objekte nicht erneut gezeichnet werden wenn ich das erste mal verliere, somit bleibt das letzte vorhandene Bild stehen. 
Wieso es zum TEIL funktioniert? Nun ja, ich habe mir bei der Kollision zwischen Objekt und Spieler immer eine Ausgabe in der Console geben lassen. Wenn ich Enter drücke und ein wenig warte bis Spieler und Objekt kollidieren kommt wieder eine Ausgabe...Habe auch versucht die paint() und init() Methode erneut ausführen lassen wenn ich Enter drücke (nur so zum ausprobieren; schadet ja nicht).

Hier ist meine Main Klasse...Ab der Zeile 299 geht es los mit der restart()
P.S: Bitte keine kommentare über mein Code. Ich weiß, dass es unsauber ist ecc. das höre ich schon von meinen Lehrer :lol: , aber immerhin läuft es. Ich möchte die Probleme lösen die mich am meisten beschäftigen und danach kommen die Feinheiten...

DANKE IM VORAUS LEUTE...ICH HOFFE IHR KÖNNT HELFEN ;(




```
import java.awt.*;
import java.applet.*;
import java.io.File;
import java.io.IOException;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Panel;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;

import javax.imageio.ImageIO;

/** 
  *
  * Run away!
  *
  * @ version 3.0 vom 07.02.2012
  * @ V. De Nicola
  */

public class Main extends Applet implements Runnable 
{

  private static final long serialVersionUID = -8110438439236694170L;
  private Thread th = new Thread(this);
  public Player player;
  public Ball ball;
  public Ball_x ball_x;
  public AudioClip ac;
  public Timer_C tc;
  public MP3 mp3;
  public Highscore hs;
  
  // Variablen initialisiert für die Schnelligkeit der Bewegungen
  int playerLeftSpeed = -50;
  int playerRightSpeed = 50;
  int playerUpSpeed = 5;
  int playerDownSpeed = 10;

  // Bewegungsvariablen
  public boolean playerMoveLeft;
  public boolean playerMoveRight;
  public boolean playerMoveUp;
  public boolean playerMoveDown;

  // Variable zum Flackern verhindern
  private Image dbImage;
  private Graphics dbg;
  
  //Sprung & Appletvariable
  int appletsize_x = 656; // Größe des Applets in x - Richtung
  int appletsize_y = 527; // Größe des Applets in y - Richtung
  int terrain = 418;      // Im Spiel "fester Boden" (vom Kopf aus)
  int jumpline = 300;     // Nicht zu überschreitende Grenze für Sprung
  int radius_player = 9;         // Kopf vom stickman für wenn er aus dem applet läuft
  
  //Hintergrundbild_Spiel
  Image hintergrund;
  Image gameover;
  Image startbild;
  Image flamme;
   
  //Deklaration der Bälle
  private Ball firstball;     // Refferenz auf den roten Ball
  private Ball secondball;      // Refferenz auf den blauen Ball
  private Ball thirdball;
  private Ball_x fourthball;
  
  int flagge_enter = 0;			//Enter
  boolean menue = true;		//Variable um Menü anzeigen zu lassen
  boolean pause = false;		//Variable um Spiel pausieren 
  boolean move_x = true;		//Hindernisse starten lassen nach bestimmter Punktzahl
  // Ende Attribute

    public void init()
  {     
    player = new Player(9, 250, 418);   //Player erstellen
    tc = new Timer_C(); //Timer von der Klasse erstellen
    
    firstball = new Ball (390, -1000, 5, 6, player);
    secondball = new Ball (400, -40, 1, 7, player);
    thirdball = new Ball (540, -60, 1, 9, player);
    fourthball = new Ball_x (-60, 410, 2,  player);
    
    // Verweis auf das Bild anlegen
    hintergrund = getImage(getCodeBase(), "hintergrund.gif");
    gameover = getImage(getCodeBase(), "gameover.gif");
    startbild = getImage(getCodeBase(), "startbild.gif");
    flamme = getImage(getCodeBase(), "flammen2.png");
    
    //Hintergrundbild wird schon vorbereitet
    prepareImage(hintergrund, this);
    prepareImage(gameover, this);
    prepareImage(startbild, this);
    prepareImage(flamme, this);
  } 
  
    // Anfang Methoden
  	public void start()
  	{ 		
  		if(player.lives != 0 )
  		{
  		    Timer_C.main(null);
  		}
  	}
  
    public void run ()
    { 	
       Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
    	 
      while(player.lives != 0)
       {   
	     	  firstball.move();
	          repaint();
	                 
	           //Schwierigkeitsstufe erhöhen durch punktestand
	           if (player.score >= 10)
	                 {
	                  secondball.move();    
	                 }
	           if (player.score >= 50)
	                 {
	                  thirdball.move();
	                 }
	       
	          // move player
	          if(playerMoveLeft)
	          {
	            player.moveX(playerLeftSpeed);
	          }
	           if(playerMoveRight)
	          {
	            player.moveX(playerRightSpeed);
	          }
	          if (playerMoveUp)
	          {
	            player.moveY(playerUpSpeed);
	          }
	          if(playerMoveDown)
	          {
	            player.moveYDown(playerDownSpeed);
	          }
	          
	          //Grenzen gesetzt für das überschreiten des Applet und Sprung
	          //X
	          if(player.x_pos > appletsize_x + radius_player  ) 
	          {
	            player.x_pos = 660;
	          }
	          else if(player.x_pos < 0 - radius_player  )
	          {
	            player.x_pos = -4;
	          }
	          
	          //SPRUNG
	          if (player.y_pos > terrain) //Y
	          {
	              player.y_pos = terrain ; 
	          }
	          else if(player.y_pos < 0)
	          {
	        	  player.y_pos = 0;
	          }
	          
	         /* if (player.y_pos < jumpline)
	          {
	            do
	            {
	              player.y_pos++ ;
	            }
	            while (player.y_pos < jumpline);
	          }*/
	  
	          if (player.y_pos < terrain)
	          {
	            do
	            {
	              player.y_pos++;
	            }
	            while (player.y_pos > terrain);
	            
	            //geschwindigkeit in der luft -zum bewegen- verringern
	            playerLeftSpeed = -4;
	            playerRightSpeed = 4;
	            
	          }
	          else
	          {
	            playerLeftSpeed = -7;
	            playerRightSpeed = 7;
	          }
	          
	          repaint();
	    	        
	          if (player.score >= 5 && move_x == true)
	          {
	                fourthball.movex();
	                
	            if (fourthball.pos_x == 686)
	            {
	              //move_x = false;
	              fourthball.pos_x = -30;
	            }
	            
	          }
	  
	          try
	          {
	            Thread.sleep(10);
	          }
	          catch (InterruptedException ex)
	          {
	            // do nothing
	          }
	  
	          Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
	          
       		}
       }  
   
    //Belegung der Tasten durch Aktionen
	public boolean keyDown(Event e, int key)
    {
	        if(key == Event.LEFT)
		        {
		          playerMoveLeft = true;
		          player.playerWalkLeft(true);
		        }
	        else if(key == Event.RIGHT)
		        {
	        	  playerMoveRight = true;
	        	  player.playerWalkRight(true);
		        }
	        else if (key == Event.UP)
		        {
		           playerMoveUp = true;
		        }
	        else if (key == Event.DOWN)
		        {
		           playerMoveDown = true;
		        }
	        if(key == Event.ENTER && flagge_enter == 0)
		        {
	        	   th.start();
	        	   menue = false;
	        	   flagge_enter = 1;
		        }
	        if(key == Event.ESCAPE)
		        {
	        		newgame();
	        		System.out.println("Bin da!");
		        }
		        
	        return false;
    }

    public boolean keyUp(Event e, int key)
    {  
    
        if(key == Event.LEFT)
	        {
	          playerMoveLeft = false;
	          player.playerWalkLeft(false);
	        }
        else if(key == Event.RIGHT)
	        {
	          playerMoveRight = false;
	          player.playerWalkRight(false);
	        }
        if (key == Event.UP)
	        {
	          playerMoveUp = false;
	        }
        else if (key == Event.DOWN)
	        {
	           playerMoveDown = false;
	        }
        
        
        return true;
    }
 
    public void Menue(Graphics g)
	{    
	   Graphics2D g1 = (Graphics2D) g;
	   g1.setColor  (Color.BLACK);
	   
	   g.drawImage(startbild, 0, 0, this);
	   g1.setFont (new Font ("Comic Sans MS", Font.BOLD, 18));
	   g1.drawString ("ENTER = STARTEN", 195, 255); 
	   g1.drawString ("ESCAPE = SCHLIEßEN", 165, 330);   
	       
	}
    
    public void restart()
    {
    	//Punktestand und Leben zurücksezten
    	player.lives = 3;
    	player.score = 0;
    	
    	//Position des Stickman zurücksetzen
    	player.x_pos = 250;
    	player.y_pos = 418;
    	
    	//Boolische Variablen auf ihren anfangswert zurücksetzen
    	menue = true;
    	move_x = true;	
   
    	run();
    	paint(dbg);
    	init();
    }
    
    //Methode zum Flackern des Spiels zu verhindern
    public void update (Graphics g)
    {
        if (dbImage == null)
	        {
	          ....
	        }
    }
   
    //Zeichnen der Figur
    public void paint (Graphics g)
    {
    	    Graphics2D g1 = (Graphics2D) g;	 
    	    
    	    Menue(g1);
    	    
    	    if(menue!=true)
    	    { 
		        //Hintergrundbild zeichnen
		    	g1.drawImage(hintergrund, 0, 0, this);
		        
		        //Stickman zeichnen
		        player.drawPlayer(g1);
		        
		        g1.setColor  (Color.WHITE);
		        g1.setFont (new Font ("", Font.PLAIN, 12));
		        //Punktestand
		        g1.drawString ("SCORE: " +player.getScore(), 575, 25);
		        
		        //Lebenspunkte
		        g1.drawString ("LIVES: " +player.getLives(), 20, 25);
		        
		        // Zeichnen der Bälle
		        firstball.DrawBall(g);
    	    }
    	
	        if (player.score >= 5)
            {
	        	secondball.DrawBall(g); 
	        	fourthball.DrawBall(g);   
            }
      if (player.score >= 50)
            {
    	  		thirdball.DrawBall(g);
            }
	        
	        
    	//Jet-Pack Flammen
	        if(playerMoveUp == true)
	        {
	        	try{ 
	                flamme =ImageIO.read(new File("flammen2.png")); 
	            } 
	            catch(IOException eio){ 
	                System.out.print(eio.toString()); 
	            }
	    	  g1.drawImage(flamme, player.x_pos+9, player.y_pos+30, this); 
	    	  g1.drawImage(flamme, player.x_pos-18, player.y_pos+30, this);
	        }
	        
       if (player.lives <= 0)
       {
           Graphics2D g2 = (Graphics2D) g;
           g2.setColor  (Color.BLACK);
           g2.setFont (new Font ("Comic Sans MS", Font.PLAIN, 18));
           
           //Game Over Bild
           g2.drawImage(gameover, 0, 0, this);
           
           //High Score wird angezeigt
           g2.drawString ("SCORE: " +player.getScore(), 520, 280);

       }
       
    }
        
    // Ende Methoden
}
```

IM ANHANG NOCH EIN BILD VOM SPIEL :toll: :applaus:


----------



## Gossi (14. Feb 2012)

enzo545 hat gesagt.:


> ```
> public void restart()
> {
> //Punktestand und Leben zurücksezten
> ...


Versuche es anstelle von run mal mit new Thread(this).start();
run() ist völlig verkehrt, immer nen extra Thread mit start, sonst bringt dir die Methode nix ^^


----------



## Quaxli (14. Feb 2012)

Ich finde das Konzept mit dem Thread (= GameLoop) neu starten nicht gut. 
Nachdem da drin ja auch der repaint-Aufruf ist, wird Dein Bild nicht mehr neu gezeichnet, sobald Du "tot gegangen" bist. 

Ich verwende in meinen Spielchen i. d. R. eine Methode zum Rücksetzen aller Variablen. Diese wird bei jedem (Neu-)Start des Spiels aufgerufen - auch beim ersten Mal.
Im GameLoop selbst entscheide ich über einen boolean welche Methoden ausgeführt werden.

Wird gerade der Startbildschirm angezeigt, d. h. das Spiel an sich ist gar nicht gestartet, dann reduziert das den GameLoop auf repaint und Thread.sleep(..).
Wenn das Spiel (neu) gestartet wurde greift auch die restliche Logik.

In (Pseudo-)Code sieht das ungefähr so aus:


```
while(frame.isVisible){

   if(gameStarted){

     fragDieTastureingabeAb();
     bewegeAlles();
     prüfeAlles();  //Kollisionen, Verlassen des sichtbaren Bereichts, etc. etc.

   }

   Thread.sleep(10);  //try-catch spare ich mir gerade
    repaint();

}
```


----------



## Fu3L (14. Feb 2012)

Ich hab generell eine Instanz vom Typ Game. Wenn ein Spiel läuft ist es ungleich null, sonst wohl. Ist Game ungleich null wird durch mein GameLoop das Spiel zum updaten angeregt.
Will ich das Spiel neu starten, reicht ein simples game = new Game(bla bla); und alles funktioniert wunderbar^^


----------



## enzo545 (14. Feb 2012)

Hey leutz,
vielen dank für eure megaa Antworten. 
Ich hab mal beschlossen, dass ich Gossis vorschlag nehmen würde...Habs angewendet und das Spiel startet auch wieder neu. Alles TIP TOP!! :applaus:
Trotzdem danke nochmal bei allen anderen. Ihr seid die bescht :toll:


----------

