repaint wir nicht mehr geöffnet!

[Tonxxx]

Hallo, ich hab folgendes problem, wenn ich mein programm starte, dann geht alles nach plan, doch wenn sich end auf 1 stellt, und ich mit hilfe von einem doppelclick es wieder auf 0 stellen will, sollte es wieder so laufen, wie es anfangs getan hat. doch jetzt öffnet es in der langen while schleiffe bei run() die repaint() methode nicht mehr!
repaint() (zeile 463) und repaint2() werden noch schön auf der konsole ausgegeben, doch die repaint() methode, welche dazwischen liegt, öffnet sich nicht mehr! was ist da los?

//Snake
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.event.MouseListener;
import java.util.*;
import javax.swing.*;




public class Snake extends Applet implements Runnable, KeyListener, MouseListener, MouseMotionListener
{
	// Initialisierung der Variablen

	int appletsize_x = 600; 	// Größe des Applets in x - Richtung
	int appletsize_y = 600;		// Größe des Applets in y - Richtung
//
	int x_pos = appletsize_x / 2;		// x - Position des Balles
	int y_pos = appletsize_y / 2;		// y - Position des Balles

	int x_speed = 0;		// Geschwindigkeit des Balles in x - Richtung
	int y_speed = 0;		// Geschwindigkeit des Balles in y - Richtung

	public int getX_speed()
	{
		return x_speed;
	}

	public void setX_speed(int x_speed)
	{
		this.x_speed 	= x_speed;
	}
	public int getY_speed()
	{
		return y_speed;
	}

	public void setY_speed(int y_speed)
	{
		this.y_speed 	= y_speed;
	}

	int speed = 2;

	int radius = 15;		// Radius des Balles

	int pause = 10;

	int key;

	public int getRadius()
	{
		return radius;
	}

	public void setRadius(int radius)
	{
		this.radius 	= radius;
	}

//
	int x_beweg;
	int y_beweg;	

	int x_be_speed = 0;
	int y_be_speed = 0;

	int be_speed = 1;

	int b_beweg = 38;
	int h_beweg = 32;

	int[] x_be;
	int[] y_be;

	int anzahl_be_punkte = 6;
//
	boolean be_tmp = true;

	//Zufallszahl
	Random zufallspos = new Random();

	Punkte punkte = new Punkte();
	Futter futter = new Futter();

	// Variablen für die Doppelpufferung
	private Image dbImage;
	private Graphics dbg;

  	 JButton button = new JButton("Mausereignisse");
   	 JLabel l = new JLabel();
    
   	 // Konstruktor des Applets
   /*	 public Snake()
  	 {
      	 	 Container cp = getContentPane();
       		 cp.setLayout(new BorderLayout());
        
       		 //Komponenten hinzufuegen
       		 cp.add(button,BorderLayout.NORTH);
       		 cp.add(l,BorderLayout.SOUTH);
        
       		 button.addMouseListener(this);
    	}*/


	public void init()
	{
		setBackground (Color.blue);

		addKeyListener(this);
		addMouseListener(this);
		addMouseMotionListener(this);


	}

	public void start ()
	{
		// Schaffen eines neuen Threads, in dem das Spiel läuft
		Thread th = new Thread (this);
		// Starten des Threads
		th.start ();

				//System.out.println("start : Start");
	}

	public void stop()
	{

	}

	public void destroy()
	{

	}




	public void keyPressed(KeyEvent e)
	{
		//getGraphics().drawString("User pressed key " + e.getKeyChar(), 10);
		//currentLine+=20;

		// linke Cursortaste
		if (e.getKeyChar() == 0141)
		{
			// Ball bewegt sich dann nach links
			x_speed = -speed;
			y_speed = 0;

		}
		// rechte Cursortaste
		else if (e.getKeyChar() == 0144)
		{
			// Ball bewegt sich dann nach rechts
			x_speed = speed;
			y_speed = 0;
		}
		// hoch
		else if (e.getKeyChar() == 0167)//1004 = hoch
		{
			// Ball bewegt sich dann nach links
			y_speed = -speed;
			x_speed = 0;
		}
		// runter
		else if (e.getKeyChar() == 0163)//1005 = runter
		{
			// Ball bewegt sich dann nach rechts
			y_speed = speed;
			x_speed = 0;
		}
		// punkt
		else if (key == 0056)
		{
			x_speed = 0;
			y_speed = 0;
		}
		else
		{
			// Ausgabe von gedrüktem Key und Zahlenwert an die Standardausgabe
			//getGraphics().drawString("User pressed key " + e.getKeyChar(), 10);
		}
					//System.out.println("nach Cursor : " + x_speed + " , " + y_speed);

					//System.out.println("finish : keyDown");
	}

	public void keyReleased(KeyEvent e)
	{
		System.out.println("User released key " + e.getKeyChar());

	}

	public void keyTyped(KeyEvent e)
	{

	}

	public void mouseClicked(MouseEvent e)
	{
		System.out.println("User clicked mouse " + e.getClickCount() + " times!");
		System.out.println("mouseDown start");
		//Wenn Spiel noch nicht gestartet ist, oder wieder gestartet wird
		if (e.getClickCount () == 2)
		{
		    // Alle wichtigen Werte zurücksetzen
			punkte.setEnd(0);
			init ();
			run();
			punkte.setCount(10);
			repaint();
		}
	}

	public void mouseEntered(MouseEvent e)
	{

	}

	public void mouseExited(MouseEvent e)
	{

	}

	public void mousePressed(MouseEvent e)
	{

	}

	public void mouseReleased(MouseEvent e)
	{

	}

	public void mouseMoved(MouseEvent e)
	{
	}

	public void mouseDragged(MouseEvent e)
	{
	}

	public void run ()
	{
					//System.out.println("start : run");
		// Erniedrigen der ThreadPriority um zeichnen zu erleichtern
		Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

		System.out.println("run : " + x_speed + " , " + y_speed);

	// Zufallsort des Futters
		
		futter.Zufallspos_X(appletsize_x, appletsize_y);
		futter.Zufallspos_Y(appletsize_x, appletsize_y);

	// Zufallsort der Punkte

		punkte.Zufallspos_X(appletsize_x, appletsize_y, radius);
		punkte.Zufallspos_Y(appletsize_x, appletsize_y, radius);

	// Zufallsort der beweglichen Punkte
		x_be = new int[anzahl_be_punkte];

		while(be_tmp == true)
		{
			for(int i=0; i<=anzahl_be_punkte -1; i++)
			{
				x_be[i] = zufallspos.nextInt(appletsize_x - punkte.getBreite());
				System.out.println("bewegliche Punkte x: " + x_be[i]);

				be_tmp = false;
	
			}

			y_be = new int[anzahl_be_punkte];
			for(int i=0; i<=anzahl_be_punkte -1; i++)
			{
				y_be[i] = zufallspos.nextInt(appletsize_x - punkte.getHöhe());	
				System.out.println("bewegliche Punkte y: " + y_be[i]);
			
				be_tmp = false;
	
			}
			// überprüfen, das sie nicht übereinander liegen!
			for(int i=0; i<=anzahl_be_punkte -1; i++)
			{	
				if(y_be[i] <= (appletsize_y / 2) + 2 * radius  + 1 && y_be[i]  + h_beweg + 1 >= appletsize_y / 2)			
				{
					be_tmp = true;
				}
			}		
		}
	// Zufallsrichtung der beweglichen Punkte

		final int N = 0;
		final int NO = 1;
		final int O = 2;
		final int SO = 3;
		final int S = 4;
		final int SW = 5;
		final int W = 6;
		final int NW = 7;
		

		for(int i=0; i<=anzahl_be_punkte -1; i++)
		{
			//x_futter = zufallspos.nextInt(7);	
		}

		x_be_speed = be_speed;

		int loop =0;

		// Solange 0 ist läuft der Thread weiter
		while (punkte.getEnd() == 0)
		{
		loop++;
					//System.out.println("while start " + loop);

			System.out.println("while start end : " + punkte.getEnd());
			// 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 = -speed;
			}
			// Ball brührt linken Rand und prallt ab
			else if (x_pos < radius)
			{
				// Ändern der Richtung des Balles
				x_speed = +speed;
			}
			// Verändern der x- Koordinate
			x_pos += x_speed;

			// Wenn der Ball den unteren Rand berührt, dann prallt er ab
			if (y_pos > appletsize_y - radius)
			{
				// Ändern der Richtung des Balles
				y_speed = -speed;
			}
			// Ball brührt oberen Rand und prallt ab
			else if (y_pos < radius)
			{
				// Ändern der Richtung des Balles
				y_speed = +speed;
			}
			// Verändern der y- Koordinate
			y_pos += y_speed;

			x_speed = punkte.Punkte_erkennen1(x_pos, y_pos, radius, x_speed, y_speed);
			y_speed = punkte.Punkte_erkennen2(x_pos, y_pos, radius, x_speed, y_speed);

			// Futter erkennen

			futter.Futter_erkennen(x_pos, y_pos, radius, x_speed, y_speed, appletsize_x, appletsize_y);

			
			// Bewegliche Punkte Erkennen
			for (int i=0; i<=anzahl_be_punkte -1; i++)
			{
				x_beweg = x_be[i];
				y_beweg = y_be[i];

				if (   (x_beweg + b_beweg -(x_pos + radius)) * (x_beweg + b_beweg -(x_pos + radius)) + (y_beweg + h_beweg -(y_pos + radius)) * (y_beweg + h_beweg -(y_pos + radius)) <= radius * radius || 
			      		(x_beweg + b_beweg -(x_pos + radius)) * (x_beweg + b_beweg -(x_pos + radius)) + (y_beweg + h_beweg -(y_pos + radius)) * (y_beweg + h_beweg -(y_pos + radius)) <= radius * radius || 
			       		(x_beweg + b_beweg -(x_pos + radius)) * (x_beweg + b_beweg -(x_pos + radius)) + (y_beweg + h_beweg -(y_pos + radius)) * (y_beweg + h_beweg -(y_pos + radius)) <= radius * radius ||
			       		(x_beweg  + b_beweg -(x_pos + radius)) * (x_beweg + b_beweg -(x_pos + radius)) + (y_beweg + h_beweg -(y_pos + radius)) * (y_beweg + h_beweg -(y_pos + radius)) <= radius * radius ||
					x_pos + radius >= x_beweg && x_pos + radius <= x_beweg + b_beweg && y_pos >= y_beweg && y_pos <= y_beweg + b_beweg ||
					x_pos >= x_beweg && x_pos <= x_beweg + b_beweg && y_pos - radius >= y_beweg && y_pos - radius <= y_beweg + b_beweg ||
					x_pos - radius >= x_beweg && x_pos - radius <= x_beweg + b_beweg && y_pos >= y_beweg && y_pos <= y_beweg + b_beweg ||
					x_pos >= x_beweg && x_pos <= x_beweg + b_beweg && y_pos + radius >= y_beweg && y_pos + radius <= y_beweg + b_beweg   )
				{
								//System.out.println("start : punkteerkennen1 if anweisung");
					//Abprallen von den Punkten
					if (x_speed != 0)
					{
						x_speed = -x_speed;
						y_speed = 0;
						if (x_speed < 0)
						{
							x_pos = x_pos -3;
						}
						if (x_speed > 0)
						{
							x_pos = x_pos +3;
						}
					}

					if (y_speed != 0)
					{
						y_speed = -y_speed;
						x_speed = 0;

						if (y_speed < 0)
						{
							y_pos = y_pos -3;
						}
						if (y_speed > 0)
						{
							y_pos = y_pos +3;
						}
					}

					System.out.println("Dead! beweg");
					punkte.police();			
			
				}

			}
			
		//	x_be_speed = be_speed;

			for(int i=0;i <= anzahl_be_punkte -1; i++)
			{
			
				// Wenn der bewegliche Punkt den rechten Rand berührt, dann prallt er ab
				if (x_be[i] > appletsize_x - b_beweg)
				{
					// Ändern der Richtung des Balles
					x_be_speed = -be_speed;
				}
				// bewegliche Punkt brührt linken Rand und prallt ab
				else if (x_be[i] < 0)
				{
					// Ändern der Richtung des Balles
					x_be_speed = +be_speed;
				}

				// Verändern der x- Koordinate
				//for(int i=0;i <= anzahl_be_punkte -1; i++)
				//{

					x_be[i] += x_be_speed;
				//}

				// Wenn der Ball den unteren Rand berührt, dann prallt er ab
				if (y_be[i] > appletsize_y - h_beweg)
				{
					// Ändern der Richtung des Balles
					y_be_speed = -be_speed;
				}

				// Ball brührt oberen Rand und prallt ab
				else if (y_be[i] < 0)
				{
					// Ändern der Richtung des Balles
					y_be_speed = +be_speed;
				}

				// Verändern der y- Koordinate
				//for(int i=0;i <= anzahl_be_punkte -1; i++)
				//{
					y_beweg += y_be_speed;
				//}
			}

			// Neuzeichnen des Applets
			System.out.println("repaint()");
			repaint();
			System.out.println("repaint2()");
			try
			{
				// Stoppen des Threads für in Klammern angegebene Millisekunden
				Thread.sleep (pause);
			}
			catch (InterruptedException ex)
			{
				// do nothing
			}
						//System.out.println("while end " + loop);
			// 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)
	{
					//System.out.println("start : update");
		// 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);
					//System.out.println("finish : update");
	}

	public void paint (Graphics g)
	{
		System.out.println("end : " + punkte.getEnd());

		if (punkte.getEnd() == 0)
		{
						//System.out.println("start : paint");
			System.out.println("futter : " + futter.getFressen());
			System.out.println("punkte : " + punkte.getCount());

			// Kugel
			g.setColor  (Color.red);

			g.fillOval (x_pos - radius, y_pos - radius, 2 * radius, 2 * radius);

			// Punkte
			for(int i=0; i<= punkte.getAnzahl_punkte() -1; i++)
			{
				g.setColor  (Color.black);
				g.fillRect (punkte.getX_p(i),punkte.getY_p(i),punkte.getBreite(),punkte.getHöhe());	
			}

			// Beweglichen Punkte
			for(int i=0; i<=anzahl_be_punkte -1; i++)
			{
				g.setColor  (Color.pink);
				g.fillRect (x_be[i], y_be[i],b_beweg,h_beweg);	
			}
		
			//Futter
			g.setColor  (Color.yellow);
			g.fillRect (futter.getX_futter(), futter.getY_futter(),futter.getB_futter(),futter.getH_futter());

			g.setColor (Color.yellow);

			g.drawString ("Score: " + futter.getFressen(), 10, 40);
			g.drawString ("Lives: " + punkte.getCount(), 300, 40);

		}
		else
		{
			setBackground (Color.black);

			g.setColor (Color.yellow);

			// Erreichte Punkte und game over
			g.drawString ("Game over!", 130, 100);
			g.drawString ("You scored " + futter.getFressen() + " Points!", 90, 140);

			// Bewertung der Punkte
			if (futter.getFressen() < 3) g.drawString ("Well, it could be better!", 100, 190);
			else if (futter.getFressen() < 6 && futter.getFressen() >= 3) g.drawString ("That was not so bad", 100, 190);
			else if (futter.getFressen() < 9 && futter.getFressen() >= 6) g.drawString ("That was really good", 100, 190);
			else if (futter.getFressen() < 12 && futter.getFressen() >= 9) g.drawString ("You seem to be very good!", 90, 190);
			else if (futter.getFressen() < 15 && futter.getFressen() >= 12) g.drawString ("That was nearly perfect!", 90, 190);
			else if (futter.getFressen() >= 15) g.drawString ("You are the Champingon!",100, 190);

			//g.drawString ("Doubleclick on the Applet, to play again!", 20, 220);

			//isStoped = true;	// Zurücksetzen der isStoped Variablen, um wieder neu beginnen zu können
		}

	}
}

class Punkte
{
	private int x_punkt;		// Punkte
	private int y_punkt;

	private int breite;		// breite der Punkte
	private int höhe;			// Höhe der Punkte

	private int[] x_p;
	private int[] y_p;

	private int anzahl_punkte = 20;	

	private int count;

	private int end;

	private boolean p_tmp;
		
	//Zufallszahl
	Random zufallsort = new Random();

	//Konstruktor
	public Punkte()
	{
					//System.out.println("start : Punkte.konstruktor");
		x_punkt = 0;		// Punkte
		y_punkt = 0;

		breite = 48;		// breite der Punkte
		höhe = 48;		// Höhe der Punkte

		anzahl_punkte = 10;

		count = 10;
		
		end = 0;

		p_tmp = true;
					//System.out.println("finish : Punkte.konstruktor");	
	}

	//get_set methoden
	public int getX_punkt()
	{
		return x_punkt;
	}
		
	public void setX_punkt(int x_punkt)
	{
		this.x_punkt 	= x_punkt;
	}
	
	public int getY_punkt()
	{
		return y_punkt;
	}

	public void setY_punkt(int y_punkt)
	{
		this.y_punkt 	= y_punkt;
	}

	public int getBreite()
	{
		return breite;
	}		
	public void setBreite(int breite)
	{
		this.breite	= breite;
	}
	public int getHöhe()
	{
		return höhe;
	}
	public void setHöhe(int höhe)
	{
		this.höhe	= höhe;
	}

	public int getX_p(int i)
	{
		return x_p[i];
	}
	public void setX_p(int[] x_p)
	{
		this.x_p	= x_p;
	}
	public int getY_p(int i)
	{
		return y_p[i];
	}
	public void setY_p(int[] y_p)
	{
		this.y_p	= y_p;
	}

	public int getAnzahl_punkte()
	{
		return anzahl_punkte;
	}
	public void setAnzahl_punkte(int anzahl_punkte)
	{
		this.anzahl_punkte= anzahl_punkte;
	}
	public int getCount()
	{
		return count;
	}
		
	public void setCount(int count)
	{
		this.count 	= count;
	}
	public int getEnd()
	{
		return end;
	}
		
	public void setEnd(int end)
	{
		this.end 	= end;
	}
	public boolean getP_tmp()
	{
		return p_tmp;
	}
		
	public void setP_tmp(boolean p_tmp)
	{
		this.p_tmp 	= p_tmp;
	}

	public int[] Zufallspos_X(int appletsize_x, int appletsize_y, int radius)
	{
				//System.out.println("start : zufallspos_X");


		x_p = new int[anzahl_punkte];
		for(int i=0; i<=anzahl_punkte -1; i++)
		{
			x_p[i] = zufallsort.nextInt(appletsize_x - breite);
			System.out.println("Punkte x: " + x_p[i]);
	
		}
					//System.out.println("finish : Zufallspos_X");
		return x_p;



				


	}
	public int[] Zufallspos_Y(int appletsize_x, int appletsize_y, int radius)
	{
					//System.out.println("start : zufallspos_Y");
		while(p_tmp == true)
		{

			y_p = new int[anzahl_punkte];
			for(int i=0; i<=anzahl_punkte -1; i++)
			{
				y_p[i] = zufallsort.nextInt(appletsize_x - höhe);	
				System.out.println("Punkte y: " + y_p[i]);

				p_tmp = false;
	
			}
						//System.out.println("finish : Zufallspos_Y");
			//return y_p;

			for(int i=0; i<=anzahl_punkte -1; i++)
			{	
				if(x_p[i] + breite + 1 >= appletsize_x / 2 && x_p[i] <= appletsize_x / 2 + 2 * radius + 1 &&
				   y_p[i] + höhe + 1 >= appletsize_y / 2 && y_p[i] <= appletsize_y / 2 + 2 * radius + 1 )

					//(appletsize_y / 2) + radius <=y_be[i]<= (appletsize_y / 2) - h_beweg && (appletsize_x / 2) - b_beweg<= x_be[i]<= (appletsize_x / 2) + radius)
				{
					p_tmp = true;
				}
			}
		}

		return y_p;
	}
	
	public int Punkte_erkennen1(int x_pos, int y_pos, int radius, int x_speed, int y_speed)
	{
			System.out.println("start : punkteerkennen1");
			// Punkte erkennen
			for (int i=0; i<=anzahl_punkte -1; i++)
			{
				x_punkt = getX_p(i);
				y_punkt = getY_p(i);

				if (   (x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius || 
			      		(x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius || 
			       		(x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius ||
			       		(x_punkt  + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius ||
					x_pos + radius >= x_punkt && x_pos + radius <= x_punkt + breite && y_pos >= y_punkt && y_pos <= y_punkt + breite ||
					x_pos >= x_punkt && x_pos <= x_punkt + breite && y_pos - radius >= y_punkt && y_pos - radius <= y_punkt + breite ||
					x_pos - radius >= x_punkt && x_pos - radius <= x_punkt + breite && y_pos >= y_punkt && y_pos <= y_punkt + breite ||
					x_pos >= x_punkt && x_pos <= x_punkt + breite && y_pos + radius >= y_punkt && y_pos + radius <= y_punkt + breite   )

				{
								//System.out.println("start : punkteerkennen1 if anweisung");
					//Abprallen von den Punkten
					if (x_speed != 0)
					{
						x_speed = -x_speed;
						y_speed = 0;

						if (x_speed < 0)
						{
							x_pos = x_pos -2;
						}
						if (x_speed > 0)
						{
							x_pos = x_pos +2;
						}
					}

					if (y_speed != 0)
					{
						y_speed = -y_speed;
						x_speed = 0;

						if (y_speed < 0)
						{
							y_pos = y_pos -2;
						}
						if (y_speed > 0)
						{
							y_pos = y_pos +2;
						}
					}

					//System.out.println("Dead!");	
					police();		
			
				}

			}
					//System.out.println("finish : punkteerkennen1");
				
		return x_speed;
	}
	public int Punkte_erkennen2(int x_pos, int y_pos, int radius, int x_speed, int y_speed)
	{
			System.out.println("start : punkteerkennen2");

			// Punkte erkennen
			for (int i=0; i<=anzahl_punkte -1; i++)
			{
				x_punkt = x_p[i];
				y_punkt = y_p[i];

				if (   (x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius || 
			      		(x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius || 
			       		(x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius ||
			       		(x_punkt  + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius ||
					x_pos + radius >= x_punkt && x_pos + radius <= x_punkt + breite && y_pos >= y_punkt && y_pos <= y_punkt + breite ||
					x_pos >= x_punkt && x_pos <= x_punkt + breite && y_pos - radius >= y_punkt && y_pos - radius <= y_punkt + breite ||
					x_pos - radius >= x_punkt && x_pos - radius <= x_punkt + breite && y_pos >= y_punkt && y_pos <= y_punkt + breite ||
					x_pos >= x_punkt && x_pos <= x_punkt + breite && y_pos + radius >= y_punkt && y_pos + radius <= y_punkt + breite   )
				{

					//Abprallen von den Punkten
					if (x_speed != 0)
					{
						x_speed = -x_speed;
						y_speed = 0;

						if (x_speed < 0)
						{
							x_pos = x_pos -2;
						}
						if (x_speed > 0)
						{
							x_pos = x_pos +2;
						}
					}

					if (y_speed != 0)
					{
						y_speed = -y_speed;
						x_speed = 0;

						if (y_speed < 0)
						{
							y_pos = y_pos -2;
						}
						if (y_speed > 0)
						{
							y_pos = y_pos +2;
						}
					}

					//System.out.println("Dead!");				
			
				}

			}
					//System.out.println("finish : punkteerkennen21");
		return y_speed;
	}
	public void police()
	{
		count--;

		System.out.println("Police");

		if(count == 0)
		{
			end();
		}
		setCount(count);
	}

	public void end()
	{
		System.out.println("end");
		end = 1;
		setEnd(end);
	}

}

die classe Futter, hab ich nicht hoch gestellt, da es zuwenig platz hat, ich hoffe ihr braucht die nicht....

vielen Dank

 

[Marco13]

CHAOS :autsch: Kann's sein dass die "lange Schleife" beendet und nicht neu gestartet wird *rumrat*

 

[Tonxxx]

nein, da es das System.out.println("repaint()");
und das System.out.println("repaint2()"); immer ausführt!

das ganze Spiel läuft weiter normal ab, nur wir es nicht mehr gezeichnet!

 

[javimka]

Deine Frage ist unmöglich, dein 899-Zeilen-Viech da oben kompiliert nicht und das Fenster ist so breit, dass ich nicht mal in meinem 9:16 Bildschirm die ganze Breite betrachten kann.
Kannst du das nicht ein bisschen (so auf ca 50 Zeilen) kürzen, so dass das Problem immer noch bestehen bleibt, aber der ganze Rest weg fällt? So blick ich wirklich nicht durch, welche while Schleife welches repaint oder repaint2 öffnet (=aufruft?).

 

[Spacerat]

Innerhalb des EDTs (mouseClicked) oder überhaupt die run-Methode eines anderen Threads aufzurufen ist allses andere als sinnvoll. Ist ja schön und gut, wenn die beiden Texte ausgegeben werden, aber selbst wenn der Thread nach dem 1. end nicht mehr läuft, ist das kein wunder. Ebenso, dass repaint (der Vorgang, nicht die Methode ) während eines EDT-Durchlaufs nicht ausgeführt wird (möglicher Deadlock, wenn der Thread laufen würde).
Ansonsten schliesse ich mich meinen Vorrednern an...

 

[Tonxxx]

das mein quelltext nicht schlau aufgebaut ist, hab ich nie behauptet.

doch warum ist es kein wunder, das das repaint, nach dem ersten end nicht mehr geöffnet wird?

verkürzen kannn ich den quelltext nicht, denn ich weiss nie was ich stehen lassen darf, und was nicht.

und das man es nicht compilieren kann liegt daran das der text nicht komplet ist, um ihn komplett zu machen, muss man dies noch unten anfügen:

class Futter
{

	int x_futter;			// Futter
	int y_futter;

	int b_futter;		// Breite des Futters
	int h_futter;		// Höhe des Futter

	int fressen;

	Random zufallsort = new Random();

	//Konstruktor
	public Futter()
	{
		x_futter = 0;
		y_futter = 0;

		b_futter = 41;
		h_futter = 47;
		fressen = 0;
	}
	
	//get set Methoden

		//get_set methoden
	public int getX_futter()
	{
		return x_futter;
	}	
	public void setX_futter(int x_futter)
	{
		this.x_futter 	= x_futter;
	}
	public int getY_futter()
	{
		return y_futter;
	}		
	public void setY_futter(int y_futter)
	{
		this.y_futter 	= y_futter;
	}

	public int getB_futter()
	{
		return b_futter;
	}		
	public void setB_futter(int b_futter)
	{
		this.b_futter 	= b_futter;
	}
	public int getH_futter()
	{
		return h_futter;
	}	
	public void setH_futter(int h_futter)
	{
		this.h_futter 	= h_futter;
	}
	public int getFressen()
	{
		return fressen;
	}		
	public void setFressen(int fressen)
	{
		this.fressen 	= fressen;
	}
	//Zufallspos
	public int Zufallspos_X(int appletsize_x, int appletsize_y)
	{
					//System.out.println("start : zufallspos_X");
		Random zufallsort = new Random();

		x_futter = zufallsort.nextInt(appletsize_x - b_futter);
		System.out.println("Futter x: " + x_futter);
	

					//System.out.println("finish : Zufallspos_X");
		return x_futter;
	}
	public int Zufallspos_Y(int appletsize_x, int appletsize_y)
	{
					//System.out.println("start : zufallspos_X");
		Random zufallsort = new Random();

		y_futter = zufallsort.nextInt(appletsize_x - h_futter);
		System.out.println("Futter y: " + y_futter);
	

					//System.out.println("finish : Zufallspos_X");
		return y_futter;
	}

	public void Futter_erkennen(int x_pos, int y_pos, int radius, int x_speed, int y_speed, int appletsize_x, int appletsize_y)
	{
		System.out.println("start : futtererkennen");
		// Futter erkennen

		if (   (x_futter + b_futter -(x_pos + radius)) * (x_futter + b_futter -(x_pos + radius)) + (y_futter + h_futter -(y_pos + radius)) * (y_futter + h_futter -(y_pos + radius)) <= radius * radius || 
		  	(x_futter + b_futter -(x_pos + radius)) * (x_futter + b_futter -(x_pos + radius)) + (y_futter + h_futter -(y_pos + radius)) * (y_futter + h_futter -(y_pos + radius)) <= radius * radius || 
		 	(x_futter + b_futter -(x_pos + radius)) * (x_futter + b_futter -(x_pos + radius)) + (y_futter + h_futter -(y_pos + radius)) * (y_futter + h_futter -(y_pos + radius)) <= radius * radius ||
		     	(x_futter  + b_futter -(x_pos + radius)) * (x_futter + b_futter -(x_pos + radius)) + (y_futter + h_futter -(y_pos + radius)) * (y_futter + h_futter -(y_pos + radius)) <= radius * radius ||
			x_pos + radius >= x_futter && x_pos + radius <= x_futter + b_futter && y_pos >= y_futter && y_pos <= y_futter + b_futter ||
			x_pos >= x_futter && x_pos <= x_futter + b_futter && y_pos - radius >= y_futter && y_pos - radius <= y_futter + b_futter ||
			x_pos - radius >= x_futter && x_pos - radius <= x_futter + b_futter && y_pos >= y_futter && y_pos <= y_futter + b_futter ||
			x_pos >= x_futter && x_pos <= x_futter + b_futter && y_pos + radius >= y_futter && y_pos + radius <= y_futter + b_futter   )
		{
	
			System.out.println("Fressen");
			
			fressen();

			// Fresszeit
			try
			{
				// Stoppen des Threads für in Klammern angegebene Millisekunden
				Thread.sleep (300);
			}
			catch (InterruptedException ex)
			{
				// do nothing
			}

			x_futter = zufallsort.nextInt(appletsize_x - b_futter);	
			y_futter = zufallsort.nextInt(appletsize_y - h_futter);			
			
		}
		setX_futter(x_futter);
		setY_futter(y_futter);
	}
	public void fressen()
	{
		fressen++;

		System.out.println("fressen");

		setFressen(fressen);
			
	}


}

 

[javimka]

Habe ich dich um weitere 143 Zeilen Code gebeten? :autsch:

verkürzen kannn ich den quelltext nicht, denn ich weiss nie was ich stehen lassen darf, und was nicht.

Schmeiss mal 500 Zeilen raus (z.B. machst du /* ... */ Kommentare). Dann startest du das Programm nochmals und schaust ob der Fehler noch auftritt. Wenn ja, schmeisst du nochmals 300 Zeilen raus und schaust wieder, ob der Fehler noch dabei ist. u.s.w.
Wenn der Fehler irgendwann nicht mehr eintritt, dann füge halt einen Teil wieder ein und schmeiss sonst was weg. Oft stösst man so sogar selbst auf das Problem.

Du kannst doch nicht ernsthaft annehmen, dass sich jemand in deine 1000 Zeilen Code einliesst.

 

[hdi]

Ich würde dir raten das ganze mal aufzuräumen. Da es sich um ein Applet handelt musst du wohl alles in eine Datei schreiben (das rate ich jetzt mal, ich hab noch nie ein Applet gemacht).
Aber sorge für mehr Übersicht. z.B. sowas wie

/**
***** CLASS: Futter ***********
***************************
***************************
*/

public class Futter{
     ...
}

/**
***** END OF CLASS: Futter ****
***************************
***************************
*/

Dann bennene alle Variablen und Methoden um, die sich nicht an die Namenskonventionen halten:

x_punkt -> xPunkt (oder einfach nur x)
Tue_etwas() -> tueEtwas()

Falls du ne IDE nutzt (davon gehe ich stark aus weil ohne kann man mit diesem Chaos wohl gar nix anfangen), dann gibt es sicherlich eine Refactoring-Option, mit der ziemlich easy geht.
zB in Eclipse Rechtsklick auf einen Namen -> Refactor -> Rename.

Dann halte Ausschau nach Variablen oder Methoden die niemals benutzt werden. zB hab ich irgendwo zwei Arrays gesehen, für die es zwar Getter und Setter gibt, aber die niemals initialisiert werden. D.h. entweder du verwendest das gar nicht, oder es kommt zu einer NullPointerExcpetion zur Laufzeit.

Du solltest die Initialisierung von Membern auch komplett im Konstruktor lassen, und sie nicht schon bei der Definition in der Klasse deklarieren. Weil ich hab gesehen dass du die im Konstruktor eh neu belegst, und zwar auch noch mit anderen Werten. Das kann zu Missverständnissen führen.

Und als letztes solltest du dir überlegen, wie du so Dinge wie:

(x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius || 
                        (x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius || 
                        (x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius ||
                        (x_punkt  + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius ||
                    x_pos + radius >= x_punkt && x_pos + radius <= x_punkt + breite && y_pos >= y_punkt && y_pos <= y_punkt + breite ||
                    x_pos >= x_punkt && x_pos <= x_punkt + breite && y_pos - radius >= y_punkt && y_pos - radius <= y_punkt + breite ||
                    x_pos - radius >= x_punkt && x_pos - radius <= x_punkt + breite && y_pos >= y_punkt && y_pos <= y_punkt + breite ||
                    x_pos >= x_punkt && x_pos <= x_punkt + breite && y_pos + radius >= y_punkt && y_pos + radius <= y_punkt + breite

anders berechnen kannst. Egal was du da machst, es geht sicherlich VIEL kürzer!

Mit diesem Code tust du dir aber echt keinen Gefallen.

verkürzen kannn ich den quelltext nicht, denn ich weiss nie was ich stehen lassen darf, und was nicht.

Das ist schlecht :bae: Hast du ihn nicht selber geschrieben?

 

[Tonxxx]

so ich hoffe ich hab ihn genug gestutzt!

//Snake
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.event.MouseListener;
import java.util.*;
import javax.swing.*;




public class Snake extends Applet implements Runnable, KeyListener, MouseListener, MouseMotionListener
{
	// Initialisierung der Variablen

	int appletsize_x = 600; 	// Größe des Applets in x - Richtung
	int appletsize_y = 600;		// Größe des Applets in y - Richtung
//
	int x_pos = appletsize_x / 2;		// x - Position des Balles
	int y_pos = appletsize_y / 2;		// y - Position des Balles

	int x_speed = 0;		// Geschwindigkeit des Balles in x - Richtung
	int y_speed = 0;		// Geschwindigkeit des Balles in y - Richtung

	public int getX_speed()
	{
		return x_speed;
	}

	public void setX_speed(int x_speed)
	{
		this.x_speed 	= x_speed;
	}
	public int getY_speed()
	{
		return y_speed;
	}

	public void setY_speed(int y_speed)
	{
		this.y_speed 	= y_speed;
	}

	int speed = 2;

	int radius = 15;		// Radius des Balles

	int pause = 10;

	int key;

	public int getRadius()
	{
		return radius;
	}

	public void setRadius(int radius)
	{
		this.radius 	= radius;
	}

//
	int x_beweg;
	int y_beweg;	

	int x_be_speed = 0;
	int y_be_speed = 0;

	int be_speed = 1;

	int b_beweg = 38;
	int h_beweg = 32;

	int[] x_be;
	int[] y_be;

	int anzahl_be_punkte = 6;
//
	boolean be_tmp = true;

	//Zufallszahl
	Random zufallspos = new Random();

	Punkte punkte = new Punkte();
	//Futter futter = new Futter();

	// Variablen für die Doppelpufferung
	private Image dbImage;
	private Graphics dbg;

  	 JButton button = new JButton("Mausereignisse");
   	 JLabel l = new JLabel();

	public void init()
	{
		setBackground (Color.blue);

		addKeyListener(this);
		addMouseListener(this);
		addMouseMotionListener(this);


	}

	public void start ()
	{
		// Schaffen eines neuen Threads, in dem das Spiel läuft
		Thread th = new Thread (this);
		// Starten des Threads
		th.start ();

				//System.out.println("start : Start");
	}

	public void stop()
	{

	}

	public void destroy()
	{

	}




	public void keyPressed(KeyEvent e)
	{
		//getGraphics().drawString("User pressed key " + e.getKeyChar(), 10);
		//currentLine+=20;

		// linke Cursortaste
		if (e.getKeyChar() == 0141)
		{
			// Ball bewegt sich dann nach links
			x_speed = -speed;
			y_speed = 0;

		}
		// rechte Cursortaste
		else if (e.getKeyChar() == 0144)
		{
			// Ball bewegt sich dann nach rechts
			x_speed = speed;
			y_speed = 0;
		}
		// hoch
		else if (e.getKeyChar() == 0167)//1004 = hoch
		{
			// Ball bewegt sich dann nach links
			y_speed = -speed;
			x_speed = 0;
		}
		// runter
		else if (e.getKeyChar() == 0163)//1005 = runter
		{
			// Ball bewegt sich dann nach rechts
			y_speed = speed;
			x_speed = 0;
		}
		else if (e.getKeyChar() == 0160)//1005 = runter
		{
			punkte.end();
		}
		// punkt
		else if (key == 0056)
		{
			x_speed = 0;
			y_speed = 0;
		}
		else
		{
			// Ausgabe von gedrüktem Key und Zahlenwert an die Standardausgabe
			//getGraphics().drawString("User pressed key " + e.getKeyChar(), 10);
		}
					//System.out.println("nach Cursor : " + x_speed + " , " + y_speed);

					//System.out.println("finish : keyDown");
	}

	public void keyReleased(KeyEvent e)
	{
		System.out.println("User released key " + e.getKeyChar());

	}

	public void keyTyped(KeyEvent e)
	{

	}

	public void mouseClicked(MouseEvent e)
	{
		System.out.println("User clicked mouse " + e.getClickCount() + " times!");
		System.out.println("mouseDown start");
		//Wenn Spiel noch nicht gestartet ist, oder wieder gestartet wird
		if (e.getClickCount () == 2)
		{
		    // Alle wichtigen Werte zurücksetzen
			punkte.setEnd(0);
			init ();
			run();
			punkte.setCount(10);
			repaint();
		}
	}

	public void mouseEntered(MouseEvent e)
	{

	}

	public void mouseExited(MouseEvent e)
	{

	}

	public void mousePressed(MouseEvent e)
	{

	}

	public void mouseReleased(MouseEvent e)
	{

	}

	public void mouseMoved(MouseEvent e)
	{
	}

	public void mouseDragged(MouseEvent e)
	{
	}


	public void run ()
	{
					//System.out.println("start : run");
		// Erniedrigen der ThreadPriority um zeichnen zu erleichtern
		Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

		System.out.println("run : " + x_speed + " , " + y_speed);
		x_be_speed = be_speed;

		int loop =0;

		// Solange 0 ist läuft der Thread weiter
		while (punkte.getEnd() == 0)
		{
		loop++;
					//System.out.println("while start " + loop);

			System.out.println("while start end : " + punkte.getEnd());
			// Verändern der x- Koordinate
			x_pos += x_speed;

			// Verändern der y- Koordinate
			y_pos += y_speed;

			// Neuzeichnen des Applets
			System.out.println("repaint()");
			repaint();
			System.out.println("repaint2()");
			try
			{
				// Stoppen des Threads für in Klammern angegebene Millisekunden
				Thread.sleep (pause);
			}
			catch (InterruptedException ex)
			{
				// do nothing
			}
						//System.out.println("while end " + loop);
			// Zurücksetzen der ThreadPriority auf Maximalwert
			Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
		}
		if(punkte.getEnd() == 1)
		{
			repaint();
		}
	}


	/** Update - Methode, Realisierung der Doppelpufferung zur Reduzierung des Bildschirmflackerns */
	public void update (Graphics g)
	{
					//System.out.println("start : update");
		// 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);
					//System.out.println("finish : update");
	}

	public void paint (Graphics g)
	{
		System.out.println("end : " + punkte.getEnd());

		if (punkte.getEnd() == 0)
		{
						//System.out.println("start : paint");
			System.out.println("punkte : " + punkte.getCount());

			// Kugel
			g.setColor  (Color.red);

			g.fillOval (x_pos - radius, y_pos - radius, 2 * radius, 2 * radius);


		}
		else
		{
			setBackground (Color.black);

			g.setColor (Color.yellow);

			// Erreichte Punkte und game over
			g.drawString ("Game over!", 130, 100);
			g.drawString ("You scored " + "10" + " Points!", 90, 140);

			//g.drawString ("Doubleclick on the Applet, to play again!", 20, 220);

			//isStoped = true;	// Zurücksetzen der isStoped Variablen, um wieder neu beginnen zu können
		}

	}
}

class Punkte
{
	private int x_punkt;		// Punkte
	private int y_punkt;

	private int breite;		// breite der Punkte
	private int höhe;			// Höhe der Punkte

	private int[] x_p;
	private int[] y_p;

	private int anzahl_punkte = 20;	

	private int count;

	private int end;

	private boolean p_tmp;
		
	//Zufallszahl
	Random zufallsort = new Random();

	//Konstruktor
	public Punkte()
	{
					//System.out.println("start : Punkte.konstruktor");
		x_punkt = 0;		// Punkte
		y_punkt = 0;

		breite = 48;		// breite der Punkte
		höhe = 48;		// Höhe der Punkte

		anzahl_punkte = 10;

		count = 10;
		
		end = 0;

		p_tmp = true;
					//System.out.println("finish : Punkte.konstruktor");	
	}


	public int getCount()
	{
		return count;
	}
		
	public void setCount(int count)
	{
		this.count 	= count;
	}
	public int getEnd()
	{
		return end;
	}		
	public void setEnd(int end)
	{
		this.end 	= end;
	}

	public void police()
	{
		count--;

		System.out.println("Police");

		if(count == 0)
		{
			end();
		}
		setCount(count);
	}

	public void end()
	{
		System.out.println("end");
		end = 1;
		setEnd(end);
	}

}

was mir jetz auch aufgefallen ist, wenn ich einen doppelclick gemacht habe, und etwas vor mein fenster tue, und das das fenster wieder in den vordergrund tue, hat es einen blauen hintergrund. ich schliesse daraus, das es die init geöffnet hat, und sie so mit auch gezeichnet hat, der punkt ist aber niergens! und "end : o" gibt es mir auch nicht aus, wie es nach zeile 312 tun sollte.

 

[Marco13]

Nur weil das vielleicht untergeganzen ist: NICHT innerhalb der mouseKlicked die "run"-Methode aufrufen. Was auch immer du da machen willst: Mach' es anders.

 

[hdi]

Was auch immer du da machen willst: Mach' es anders.

Und zwar so:

    public void mouseClicked(MouseEvent e)
    {
        System.out.println("User clicked mouse " + e.getClickCount() + " times!");
        System.out.println("mouseDown start");
        //Wenn Spiel noch nicht gestartet ist, oder wieder gestartet wird
        if (e.getClickCount () == 2)
        {
            new Thread(){
                  public void run(){
                        // Alle wichtigen Werte zurücksetzen
                        punkte.setEnd(0);
                        init ();
                        run();
                        punkte.setCount(10);
                        repaint();
                   }
            }.start();
        }
    }

Grund: die mouseClicked Methode wird von einem Thread (EDT) aufgerufen, der für das Zeichnen und allen Interaktionen deines Fensters zuständig ist. Wenn der nun das Spiel startet, dann ist er damit beschäftigt (die ganze Zeit), und kann keine neuen Maus-Klicks o.ä. aufrufen. repaint() funktioniert noch, sofern du es dann in deinem GameLoop aufrufst. Aber ansonsten ist das Ding quasi tot für eintreffende Events.

 

[Marco13]

Ehrlich gesagt bin ich mir nicht sicher, ob das die richtige Lösung ist ... : Wenn man 10 mal doppelklickt, laufen da 10 Threads... vielleicht ... dazu müßte man nachvollziehen, was punkte.setEnd(0), init(), run() und punkte.setCount(10) genau machen... :autsch:

 

[javimka]

// EDIT
Habe gerade gesehen, dass hdi die Lösung gefunden hat.

Das Beste wäre wahrscheinlich die gesamte run()-Methode in einen Swing Timer mit ActionListener umzuwandeln, der dann in gegebenen Abständen halt über den EDT den nächsten Schritt berechnet und neu zeichnen lässt.

Man kann übrigens auch ein Applet in beliebig viele Klassen unterteilen und dann zu einem Jar zusammenpacken.

 

[hdi]

Ehrlich gesagt bin ich mir nicht sicher, ob das die richtige Lösung ist ... : Wenn man 10 mal doppelklickt, laufen da 10 Threads... vielleicht ...

Das ist natürlich völlig korrekt! Man sollte den im Moment laufenden Thread stoppen (boolean Flag setzen), und dann einen neuen starten.

 

[Spacerat]

Und zwar so:

    public void mouseClicked(MouseEvent e)
    {
        System.out.println("User clicked mouse " + e.getClickCount() + " times!");
        System.out.println("mouseDown start");
        //Wenn Spiel noch nicht gestartet ist, oder wieder gestartet wird
        if (e.getClickCount () == 2)
        {
            new Thread(){
                  public void run(){
                        // Alle wichtigen Werte zurücksetzen
                        punkte.setEnd(0);
                        init ();
                        run(); // waaaaaaahhhhhhhhh......
                        punkte.setCount(10);
                        repaint();
                   }
            }.start();
        }
    }

@hdi: diese Endlos-Rekursion war sicher nur Flüchtigkeit und hoffentlich keine Absicht

 

[hdi]

edit: Ne, das ist mir nicht augefallen. Ich hab seinen Code einfach copy&pastet

Verbesserung:

new Thread(){
                  public void run(){
                        // Alle wichtigen Werte zurücksetzen
                        punkte.setEnd(0);
                        init ();
                        DeineKlasse.this.run(); // waaaaaaahhhhhhhhh......
                        punkte.setCount(10);
                        repaint();
                   }
            }.start();

 

[Tonxxx]

Vielen Dank für die vielen Antworten. Mein programm zeichnet sich nun korrekt!!!:toll:
doch wie ihr schon besprochen habt, muss man die Thraeds noch beenden. und da ich no nichts von multithreading gehört habe, habe ich einfach mal gegoogelt(doch habe ich es leider nicht so ganz verstanden). ich habe etwas gefunden, und es in mein programm integriert! und der compiler hat mir alles als gut befunden.
ich hab folgendendes gemacht:

class SimpleThread extends Thread
{     
  public void run()
  {    
    while(isInterrupted() == false)
    {
      System.out.println(getState());
    }   
  }
}

und dachte mir dass befor ich einen neuen Thread starte, den alten lösche....
und dies machte ich einfach so:

    	public void mouseClicked(MouseEvent e)
    	{
        	System.out.println("User clicked mouse " + e.getClickCount() + " times!");
        	System.out.println("mouseDown start");
        	//Wenn Spiel noch nicht gestartet ist, oder wieder gestartet wird
        	if (e.getClickCount () == 2)
        	{
   			 Thread th = new SimpleThread(); 
  			 th.interrupt();
            		new Thread()
			{
                  		public void run()
				{
                        		// Alle wichtigen Werte zurücksetzen
                        		punkte.setEnd(0);
                        		punkte.setCount(10);
                        		init ();
                      			Snake.this.run(); // waaaaaaahhhhhhhhh......
                        		//punkte.setCount(10);

					x_pos = appletsize_x / 2;
					y_pos = appletsize_y / 2;

					x_speed = 0;
					y_speed = 0;

					speed = 2;
					
					
                        		repaint();
                   		}
            		}.start();
        	}
    	}

doch noch immer geht mein spiel immer unkontollierbarer, doch weiss ich nicht an was das es liegt. was mach ich flasch?

zur IDN: leider kenne ich mich noch nicht mit einer IDN aus, und schreibe noch alles auf dem editor.

aus zu meiner äusserst hässlichen if anweisung, habe ich noch keine gute lösung gefunden.

 

[hdi]

ich weiss nicht welche Nebeneffekte interrupt() noch so mitbringt. Aber auch sonst machst du so einiges falsch Am besten ist es eig immer einfach ein boolesches Flag zu setzen:

class SimpleThread extends Thread
{     

  private boolean alive;

  public void run()
  {    
     alive = true;
     while(alive)
     {
         System.out.println("läuft...");
     }   
  }

   public void end(){
       alive = false;
   }
}

Und dann musst du dir eine Instanz davon abspeichern, und diese nutzen:

/** in der Klasse wo diese Methode steht musst du eine Member-Variable erstellen: */
private SimpleThread myGameLoop;

public void mouseClicked(MouseEvent e)
{
            if (e.getClickCount () == 2)
            {
                 // Wenn ein spiel läuft, beende es erstmal (killt den Thread)
                 if(myGameLoop != null){
                     myGameLoop.end();
                 }
                 // starte einen neuen Thread
                 myGameLoop = new SimpleThread();
                 myGameLoop.start();
            }
}

PS: Lade dir Eclipse herunter, da kannst du den Code automatisch schön formatieren lassen.

 

[Tonxxx]

SOrry, aber warscheinlich bin ich einfach zu dumm eure anweisungen zu befolgen....

doch, die Classe SimpleThread hab ich eingefügt, und die methode mouseClicked hab ich genau so eingefügt wie du es mir gesagt hast, und denn rest rausgescmissen. doch dann zeichnet es mir wieder nicht korrekt, und wir sind am gleichen problem wie anfangs.

dann hab ich damit etwas rumgespielt, und es verändert, so das es mir noch logisch erschin, voila es hat es wieder korrekt gezeichnet, doch das spiel wurde trotzdem von immer wie schneller..

kannst du mir sagen, was genau in der mouseClicked methode stehen muss??? so dass es mir alles zeichnet und das mein spiel nicht immer wie schneller wird( die Thraeds schliest)???

 

[hdi]

Ich hab den ganzen anderen Code aus der mouseClicked nur rausgehauen um dir aufzuzeigen was du ändern musst. Inwiefern dein exisiterender Code dort bleiben muss, weiss nicht. Das kommt ganz drauf an wo deine Logik drin steckt.

Ich persönlich hab immer nen GameThread (dein SimpleThread), und der beinhaltet auch alle Spieldaten. Das Fenster selbst enthält keine Spieldaten, außer halt einem Panel um das zu zeichnen. Außerdem sollten in Methoden, die vom EDT ausgeführt werden (zB mouseClicked) nicht großartige Berechnungen stattfinden. Das sollte immer zack zack gehen, also neuen Thread starten, und der kümmert sich dann um den Rest.

 

[Tonxxx]

ja doch mein problem ist, mit deinem code, wird die methode repaint wieder nicht geöffnet. wie mach ich das, das es den letzten Thread schliesst und trotzdem die repaint geöffnet wird!

 

[hdi]

mit repaint() ?! Ich verstehe grad dein Problem nicht. Btw Methoden werden aufgerufen, nicht geöffnet (das ist das, was du machst wenn du im Editor Code reinschreiben willst).

Ein GameLoop ist ja eine Schleife, wie du sie weiter unten in deinem code hast. Wann immer du etwas an den Daten geändert hast, die dargestellt werden, musst du ein repaint() aufrufen. Also gib deinem SimpleThread deine JPanel-Instanz im Konstruktor mit, der malt das dann:

class SimpleThread extends Thread
{     
  
  private boolean alive;
  private DeinPanel panel;

  public SimpleThread(DeinPanel panel){
      this.panel = panel;
  } 

  public void run()
  {    
     alive = true;
     while(alive)
     {
         /* Normalerweise ist die grobe Stuktur so: */
         berechneDieDatenNeu();
         panel.repaint(); // die paintComponent-Methode des Panels greift auf die Daten zu und malt sie irgendwie
         sleep(x); // x = 10 oder mehr, je nachdem wie viel "Action" dein Spiel beinhaltet. Das wird gemacht damit dein Programm nicht 100% CPU-Auslastung verursacht
     }   
  }
 
   public void end(){
       alive = false;
   }
}

 

[Tonxxx]

mein problem war ja, dass wenn wenn end auf 1 war, ist mein spiel fertig, nun wollte ich, dass man mit einem doppelclick das spiel wieder starten kann, und das dachte ich mache ich indem ich die end variable wieder auf 0 stelle.
doch dann lief das spiel wieder, doch die repaint() methode wurde nicht mehr aufgerufen. dann habt ihr mir geholfen, mit dem

new Thread{

}

doch dann wurden die thraeds nicht mehr geschlossen, so wurde mein spiel immer wie schneller, bis ihr mir gezeigt habt, wie ich die threads "kille". doch mit deinem lösungsweg, zeichnet es mir das ganze wieder nicht, und ich hab immernoch den bildschirm wie wenn end auf 1 steht. also die repaint() methode wird wieder nicht aufgerufen.

jetzt brauche ich eine lösung die beide lösungswege kombiniert, das heisst, dass repaint() aufgerufen wird, aber trotzdem die threads geschlosen werden!


und was ist ein panel?

 

[hdi]

Irgendwas stimmt dann in der Logik nicht. Du vergisst irgendetwas zurückzusetzen oder überschreibst irgendeine Referenz, o.ä.

Zeig bitte nochmal deinen kompletten Code, aber falls er nicht noch immer in einem überarbeiteten, schön formatierten Zustand ist, dann mach das bitte erst. Ich werde mir nämlich nicht 1000 Zeilen ansehen wenn sie nicht formatiert und die Klassen nicht schön voneinander getrennt sind.

 

[Tonxxx]

Also, ich hatte in den letzten wochen leider fast keine, bis gar keine zeit, für Java.....;(
nun weiss ich nicht genau, was du mit formatieren meinst....
und wie die kklassen schön von einander getrennt sein müssen...(sind sie nicht jetzt schon schön getrennt?)

also was soll ich genau tun, damit du dich bereiterklärst, meinen Quellcode anzusehen???

schon einmal vielen dank, das du dich mit dem problem abgibst!!!:toll:

 

[hdi]

Also das ist einfach zu viel Code... Fangen wir mal von vorne an, und machen es gemeinsam.

Die Klasse für das Spiel (die Spiel-Logik):

class SimpleThread extends Thread
{     
  private boolean alive;
  private GamePanel panel;
 
  public SimpleThread(GamePanel panel){
      this.panel = panel;
  } 
 
  public void run()
  {    
     alive = true;
     while(alive)
     { 
         System.out.println("Spiel läuft...");
         panel.repaint(); // die paintComponent-Methode des Panels greift auf die Daten zu und malt sie irgendwie
         try{
             Thread.sleep(10);
         }catch(Exception e){}
     }   
  }
 
   public void end(){
       alive = false;
   }
}

Die Klasse für das Panel, auf dem das Spiel gezeichnet wird:

public class GamePanel extends JPanel implements MouseListener{

private SimpleThread game;

public GamePanel(int w, int h){
    setPreferredSize(new Dimension(w,h));
    addMouseListener(this);
    // Spiel starten
    game= new SimpleThread(this);
    game.start();
}

public void mouseClicked(MouseEvent e)
{
            if (e.getClickCount () == 2)
            {
                 // Wenn ein spiel läuft, beende es erstmal (killt den Thread)
                 if(game!= null){
                     game.end();
                 }
                 // starte einen neuen Thread
                 game= new SimpleThread(this);
                 game.start();
            }
}

// die anderen Mouse-Methoden, können erstmal leer bleiben

   @Override
   protected void paintComponent(Graphics g){
       super.paintComponent(g);
       // hier kommt die Zeichen-Logik rein
   }
}

Das Fenster, in dem unser Panel steckt:

public class MyFrame extends JFrame{
    public MyFrame(){
        super("Mein Spiel"); 
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        add(new GamePanel(500,500));
        pack();
        setLocationRelativeTo(null); 
    }   
}

und zuletzt noch eine Start-Klasse:

public class Start{

    public static void main(String[] args){
       EventQueue.inokeLater(new Runnable(){ 
           @Override
           public void run(){
                new MyFrame().setVisible(true);
           } 
        });
     }
}

...und jetzt müssen wir 2 Dinge tun:
- Die Daten des Spiels in die Klasse SimpleThread schreiben
- Etwas in die paintComponent()-Methode der Klasse GamePanel schreiben, um die Daten zu zeichnen

Der Rest, also das, was wir jetzt haben, ist ein grober Rahmen und das sieht bei jedem Spiel ungefähr so aus, bzw. sagen wir mal so: Für einfache 2D-Spielchen kommt man damit meist aus.
Also... was willst du programmieren?

 

[Tonxxx]

also eigentlich war es mal als Applet gedacht, doch nur, da ich da vorlagen hatte.
doch als ich diese Klassen in einem quellcode vereint habe, hat mir der kompiler reklamiert..
ich habe recherchiert und herausgefunden das es ein typischer kompilierfehler ist, doch wie kann das sein?

C:\Programme Java\Applets\Snake\My Frame>javac GamePanel.java
GamePanel.java:43: GamePanel is not abstract and does not override abstract meth
od mouseExited(java.awt.event.MouseEvent) in java.awt.event.MouseListener
public class GamePanel extends JPanel implements MouseListener
^
GamePanel.java:99: method does not override a method from its superclass
@Override
^
GamePanel.java:97: cannot find symbol
symbol : method inokeLater(<anonymous java.lang.Runnable>)
location: class java.awt.EventQueue
EventQueue.inokeLater(new Runnable()
^
3 errors

und was meinst du genau mit was ich programieren will?

 

[hdi]

Die Klassen sind nicht ganz fertig, siehe die Kommentare in dem Code von mir. U.a. musst du halt zB die Methoden von Interfaces implementieren. Und außerdem fehlen noch die nötigen import-Anweisungen, da ich das direkt hier runtergeschrieben hab. Kann auch sein dass sogar der ein oder andere Tippfehler drin ist. Wenn du aber nicht mal weisst, was diese Fehler bedeuten bzw. was an dem Code so nicht stimmt, dann ist so ein komplettes Projekt wohl noch etwas zu hoch gegriffen.

Du solltest dir mal mehr durchlesen bevor du dich jetzt da rein stürzt, zB in der Java-Insel. Die Grundlagen halt. Hier in der FAQ-Rubrik gibt es auch einige interessante Artikel zu den Basics. Wenn du konkrete Fragen dazu hast, kannst du sie stellen.

und was meinst du genau mit was ich programieren will?

Wie schon gesagt sind diese Klassen, die ich dir gegeben hab, eine grobe Struktur wie man kleinere 2D Games anfangen könnte. Das trifft auch verschiedenste Spiele zu. Und jetzt war die Frage was konkret du programmieren möchtest, denn nur so könnte ich dir sagen wie du jetzt mit den Klassen weitermachen kannst.

 

[Tonxxx]

ehrlich gesagt weiss ich dass ich noch sehr schlecht in java bin. und ich hatte auchnie vor ein riesiges projekt zusarten, sondern hab einfach mal mit etwas angefangen und einfach weitergemacht...
ich habe immer nur sachen verwendet, die ich verstanden habe, doch irgendeinmal habt ir mir sachen gegeben, die ich dann nicht mehr verstanden habe, z.B. für was braucht man mehrere Threads?
es läuft doch alles schön nacheinander... und wenn ich nur einen Thread hätte, dann müsste ich in auch nid töten, denn dass habe ich auch wieder nicht verstanden...und das problem ist nun, wenn ich meinen eigenen Quellcode nicht zu 100% verstehe, wie soll ich dann Fehler suchen???
und nun hast du mir ein grundgerüst gezeigt, welches ich erst recht nicht verstehe, z.B. was ist dieses @?

ich weiss das ihr hier mir helfen wollt, und ich bin euch auch sehr dankbar, das ihr euch die zeit für mich nehmt, doch habt ihr mich zimlich überrumpelt!

anfangs hatte ich nur einen ball der sich in der horizontalen bewegt hat... dann habe ich eine steuerung eingebaut, mit der ich den ball frei bewegen kann...
ich habe feste steine eingebaut, durch die mein ball nicht gehen kann, dann noch steine welche sich bewegen, auch die sind nicht durchwuerbar, und zuletzt noch ein viereck, welches sich einen neue koordinaten sucht, wenn der ball es berührt...

ich dacht, dass wäre alles nicht so schwierig und man brächte kein multithreating, oder so etwas...

trotzdem vielen dank für die hilfe, ich habe trotzdem einiges gelernt!

 

[hdi]

Das ist auch kein Mutlithreading. Es läuft immer nur 1 Thread. (der alte wird gekillt, ein neuer wird gestartet). Das Problem ist dass man halt auch kaum auf deinen Code eingehen kann wenn du hier 800 Zeilen postet. Wer hat schon Lust sich das anzusehen. Und da du dauernd irgendwelche Probleme hast von wegen er repaintet sich nicht und es läuft nicht usw... das sind unkonkrete Aussagen, und der Fehler kann überall in deiner Logik stecken.

Ich würde dir empfehlen mein Grundgerüst zu verwenden, und wenn du etwas nicht verstehst, dann frag nach. Oder du liest halt erstmal mehr zu JAva, dann verstehst du den Code auch mehr...

Das "@" ist eine Annotation, @Override sagt dem Programmierer das eine Methode überschrieben wird. D.h. sie wurde geerbt und nun wird die geerbte Funktionalität verändert. Das muss man nicht hinschreiben, es ist nur so eine Art Kommentar.

 

[Tonxxx]

ja aber warum muss ich einen neuen Thread starten und den alten killen? wiso geht der alte nicht?

 

[hdi]

ja aber warum muss ich einen neuen Thread starten und den alten killen?

musst du nicht

wiso geht der alte nicht?

Geht schon...

...es gibt wie immer verschiedene Herangehensweisen und 1000 Lösungen für ein Problem. Ich hab dir nur ein Bsp gegeben. Ich finde es unkomplizierter den alten Thread zu killen und einen neuen zu starten, als einen einzigen zu haben, da man diesen dann entweder in künstlichen Wartezuständen halten muss (zwischen Gameover und neuem Spiel), oder halt die Initialisierung bzw. Re-Initialisierung etwas umständlicher ist. Ist aber nur meine Meinung. Es ist relativ egal, du kannst das gerne umschreiben. Aber wie gesagt solange ich nicht konkret weiss was du tun willst kann ich auch nicht sagen was du falsch oder richtig machst.

 

[Tonxxx]

aber warum kann ich den Tread nicht einfach weiterlaufen lassen???

ich habe mich etwas an diesem spiel orientiert:
Java Cooperation: our first game

und in diesem spiel bracut es auch keine neuen Threads und der Thread wird auch nicht eingeschläfert oder so...

wiso kann ich dass nicht auch so machen?

 

[hdi]

Weil das schlecht ist. Die run-Methode des Spiels sieht so aus:

	public void run ()
	{
		// Erniedrigen der ThreadPriority um zeichnen zu erleichtern
		Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

		while (true)
		{
			if (player.getLives() >= 0 && !isStoped)
			{
				redball.move();
				blueball.move();
			}

			repaint();

			try
			{
				// Stoppen des Threads für 10 Millisekunden
				Thread.sleep (speed);
			}
			catch (InterruptedException ex)
			{
				// do nothing
			}

			// Zurücksetzen der ThreadPriority auf Maximalwert
			Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
		}
	}

Wenn kein Spiel läuft, hängst du trotzdem in einer Endlosschleife, in der alle 10ms ein repaint() aufgerufen wird. Es arbeitet halt ein Thread, der eigentlich nix zu tun hat. Er checkt nur alle 10ms ob ein Spiel läuft oder nicht, und das ist unnötig.

und der Thread wird auch nicht eingeschläfert oder so..

Doch, genau das passiert eben. Das ist busy-waiting mit einer kleinen Schlafpause. Und zu allem übel ist der Thread auch noch auf MAX_PRIORITY gesetzt (und zwar 10 mal in der Sekunde :noe. D.h. dein Programm belastet das Betriebssystem, ohne auch nur irgendetwas zu tun. Ich würde sagen das Bsp von dieser Seite ist schlecht und du solltest dich nicht daran halten.

 

[Tonxxx]

kann sein, doch ist mir das eigentlich recht egal, da ich den besseren Weg ja nicht begreife...

und das es mein betriebsystem belastet ist mir auch recht schnuppe, schliesslich will ich einfach mit meinen kenntnissen ein spiel schaffen....

was müsste ich also machen, wenn ich es der Java cooperation gleich tun will?

 

[hdi]

kann sein, doch ist mir das eigentlich recht egal, da ich den besseren Weg ja nicht begreife...

Naja so eine Scheissegal-Einstellung ist nicht so dolle.. Dann kann ich genauso gut sagen ist mir egal ob du Scheiss Code schreibst oder nicht, also warum helfen wenn du eh zu faul bist es zu lernen.

und das es mein betriebsystem belastet ist mir auch recht schnuppe, schliesslich will ich einfach mit meinen kenntnissen ein spiel schaffen....

Ja ich weiss, und ich will dir helfen es besser zu machen da du es schlecht machst bzw es ja überhaupt nicht funktioniert.

was müsste ich also machen, wenn ich es der Java cooperation gleich tun will?

hä?

 

[Tonxxx]

es ist nicht eine Scheissegal einstellung, sondern: ich habe mir vorgenommen, zuerst das programm zum laufen zu bringen, da ich ja theoretisch alles dazu habe.... dann will ich mich weiterbilden in Java...

das heisst ich will mein programm so einfach wie möglich gestalten.

darum ist mir dies mit dem Betribsystem auch noch schnuppe, da ich es noch nicht weiss wie besser machen. und auf diese art, sollte es theoretisch ja funktionieren.

ich möchte es so einfach wie möglich machen, so wie in meinem beispiel von java cooperation!

 

[hdi]

Ja aber wie ich schon sagte:

Das Problem ist dass man halt auch kaum auf deinen Code eingehen kann wenn du hier 800 Zeilen postet.

Sprich es ist (zumindest für mich) zu mühselig jetzt bei deinem Code herauszufinden was du falsch machst. Deshalb war mein Ansatz, es gleich von vorne zu machen, und zwar richtig. Aber darauf möchtest du nicht eingehen, da du scheinbar strikt dagegen bist in diesem Zuge Neues zu erlernen. Also.. du erwartest Hilfe aber gleichzeitig willst du nix lernen, und was du bisher weisst reicht auch nicht aus. Doofe Situation würd ich sagen, vllt solltest du einfach den PC ausmachen und ne DVD kucken :bae:

 

[Tonxxx]

ja du hast ja recht....

doch jetzt ist mir eine andere möglichkeit in den sinn gekommen...

ist es möglich dass, wenn man 2 mal klickt nicht ein neuer thread gemacht wird und das alles, sondern dass sich das programm einfach schliesst und neu öffnet....

oder ist das bei einem Applet gar nicht möglich?