Java - Schnellere bewegungen

[Exodus155]

Hallo,

ALSO HIER MAL DER QUELLCODE:

import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JFrame;
import javax.swing.JPanel;



public class game extends JPanel implements Runnable
{	

                static int a = 0;
	static int w = 100;
	static int x = 100;
	static int y = 100;
	static int z = 50;		
	int speed = 15;

protected void paintComponent(Graphics g)
{	
	super.paintComponent(g);
	g.drawLine(w,x,y,z);
}

game()
{
		new Thread(this).start();
}

public void run()
{

	while(true)
	{	
	try 
	{		
		System.out.println(a);
		Thread.sleep(speed);
	} catch (Exception e)
	{}	
		repaint();
	}

}

	public static void main(String[] args)
	{
		
		JFrame f1 = new JFrame();
		f1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f1.add(new game());	
		f1.setResizable(false);
		f1.setSize(500, 500);
		f1.setVisible(true);	
		
		KeyListener al1 = new KeyListener()
		{
			public void keyPressed(KeyEvent event)
			{	
					if (event.getKeyCode() == KeyEvent.VK_LEFT)
				{
					
					y--;

				}
				else
					if (event.getKeyCode() == KeyEvent.VK_RIGHT)	
				{					
						w++;
				}
				else
					if (event.getKeyCode() == KeyEvent.VK_UP)
				{				
						x--;
				}
				else
					if (event.getKeyCode() == KeyEvent.VK_DOWN)
				{						
						z++;
				}
			}
			
			public void keyReleased(KeyEvent arg0) {
				
				
			}

			public void keyTyped(KeyEvent arg0) {
				
				
			}
		};
		f1.addKeyListener(al1);
	}
}

Frage:

Also mein Problem besteht ind diesem test, wie kann ich den strich schneller umherbewegen! Dass mit der Tastatur funktioniert und der Strich bewegt sich ja, aber wie kann man den schneller machen? mit speed 1 hab ichs auch schonmal probiert! Merkt man aber nix!


Bitte um hilfe

MFG
Exodus155

 

[SlaterB]

mehr Tastaturereignisse wird nicht gehen, schon gar nicht von Java aus,

aber statt
z++;
mach doch
z+=10;

-> 10x schneller

--------

ist etwas hakelig, sauberer wirds mit einem anderen Ansatz:
mit internen Variablen den Zustand der Maus speichern

beim ersten keyPressed also pressed = true merken
und dann gar nicht mehr auf Ereignisse von der Maus achten (bis auf das Loslassen der Taste)
sondern im Thread abhängig von der genauen Zeit seit Start des Drücken mit beliebiger Geschwindigkeit Pixel-genau die Position berechnen,

Grenzen sind dafür die Zeitmessung (System.nanoTime() + currentTimeInMillies()) + die Genauigkeit und Dauer von Thread.sleep(),
nicht einfach wenn du bei +=5; statt ++; schon ein Forum fragen musst,
aber mit viel Probieren vielleicht schaffbar

 

[EgonOlsen]

z.B. so (aber Achtung: Es ist jetzt so schnell, dass es nicht mehr kontrollierbar ist). Das Grundprinzip ist, auf Zustandsänderungen der Tasten zu reagieren, nicht auf die Wiederholung des Events, den der hängt von der Tastaturgeschwindigkeit ab):

import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class game extends JPanel {

    private int a = 0;
    private int w = 100;
    private int x = 100;
    private int y = 100;
    private int z = 50;

    private boolean up = false;
    private boolean down = false;
    private boolean left = false;
    private boolean right = false;

    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.drawLine(w, x, y, z);
    }


    public void doIt() {
        try {
            while (true) {
                if (left) {
                    y--;
                }
                if (right) {
                    w++;
                }
                if (up) {
                    x--;
                }
                if (down) {
                    z++;
                }
                //Thread.sleep(10);
                repaint();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        JFrame f1 = new JFrame();
        f1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f1.setResizable(false);
        f1.setSize(500, 500);
        f1.setVisible(true);
        game ga = new game(f1);
        f1.add(ga);
        ga.doIt();
    }

    game(JFrame jf) {
        KeyListener al1 = new MyListener();
        jf.addKeyListener(al1);
    }

    class MyListener implements KeyListener {

        public void keyPressed(KeyEvent event) {
            switch (event.getKeyCode()) {
            case (KeyEvent.VK_LEFT):
                left = true;
                break;
            case (KeyEvent.VK_RIGHT):
                right = true;
                break;
            case (KeyEvent.VK_UP):
                up = true;
                break;
            case (KeyEvent.VK_DOWN):
                down = true;
                break;
            }
        }

        public void keyReleased(KeyEvent event) {
            switch (event.getKeyCode()) {
            case (KeyEvent.VK_LEFT):
                left = false;
                break;
            case (KeyEvent.VK_RIGHT):
                right = false;
                break;
            case (KeyEvent.VK_UP):
                up = false;
                break;
            case (KeyEvent.VK_DOWN):
                down = false;
                break;
            }
        }

        public void keyTyped(KeyEvent arg0) {
        }
    }
}

 

[Exodus155]

So habs. ist wirklich ziemlich schnell! Hab jetz ein bisschen gedrosselt mit Thread.sleep(5) //5 ms warten dann neuzeichnen! danke nochma!


MFG
Exodus155

 

[Exodus155]

Ahja noch was:
Warum ist eigentlich langsamer wenn ich direkt in keypressed x++ mache?


MFG
Exodus

 

[Quaxli]

Ich finde, die Geschwindigkeit über den Thread.sleep zu steuern etwas ungeschickt. Üblicherweise nutze ich etwas in der Art:

  public void move(long delta) {
    
    if(dx!=0){
      x += dx*(delta/modx);
    }
    
    if(dy!=0){
      y += dy*(delta/mody);
    }

  }

Die move-Methode ist beim jeweiligen Objekt, das bewegt werden soll und wird aus der Haupt-Schleife regelmäßig aufgerufen. Vorher ermittele ich noch mittels System.nanoTime(), wie lange der letzte Schleifendurchlauf gedauert hat.

dx ist die aktuelle Geschwindigkeit in x- und y-Richtung und modx bzw. mody sind fix vorbelegt mit

double modx = 1000000000;

Das Ganze hat den Vorteil, daß das Programm auch auf fremden Rechnern rund läuft. Thread.sleep() rufe ich üblicherweise mit dem Wert 10 auf.


Gruß

Ralf

P.S.: Die {-Klammern bei der if-Bedingung sind unnötig - ist eine Angwohnheit von mir.

 

[Quaxli]

Ich hab mal ein bißchen an Deinem Code rumgefrickelt :wink:

import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class Test extends JPanel {

   private static final long serialVersionUID = 1L;
   
    //Typ integer reicht jetzt nicht mehr - sonst wird jedesmal abgerundet
		private double w = 100;
    private double x = 100;
    private double y = 100;
    private double z = 50;
    
    long last = 0;
    long delta = 0;
    double mod = 1000000000;
    int speed = 150;
    
    private boolean up = false;
    private boolean down = false;
    private boolean left = false;
    private boolean right = false;

    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.drawLine((int)w, (int)x, (int)y, (int)z);
    }


    public void doIt() {
        try {
        	
            while (true) {
            	
           	if(last==0){
           	  last = System.nanoTime();
           	}else{
          	   delta = System.nanoTime() - last;
          	   last = System.nanoTime();
          	 }
            	
                if (left) {
                	y -= speed*(delta/mod);
                }
                if (right) {
                	w += speed*(delta/mod);
                }
                if (up) {
                	x -= speed*(delta/mod);
                }
                if (down) {
                	z += speed*(delta/mod);
                }
                
                Thread.sleep(10);
                repaint();
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        JFrame f1 = new JFrame();
        f1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f1.setResizable(false);
        f1.setSize(500, 500);
        f1.setVisible(true);
        Test ga = new Test(f1);
        f1.add(ga);
        ga.doIt();
    }

    Test(JFrame jf) {
        KeyListener al1 = new MyListener();
        jf.addKeyListener(al1);
    }

    class MyListener implements KeyListener {

        public void keyPressed(KeyEvent event) {
            switch (event.getKeyCode()) {
            case (KeyEvent.VK_LEFT):
                left = true;
                break;
            case (KeyEvent.VK_RIGHT):
                right = true;
                break;
            case (KeyEvent.VK_UP):
                up = true;
                break;
            case (KeyEvent.VK_DOWN):
                down = true;
                break;
            }
        }

        public void keyReleased(KeyEvent event) {
            switch (event.getKeyCode()) {
            case (KeyEvent.VK_LEFT):
                left = false;
                break;
            case (KeyEvent.VK_RIGHT):
                right = false;
                break;
            case (KeyEvent.VK_UP):
                up = false;
                break;
            case (KeyEvent.VK_DOWN):
                down = false;
                break;
            }
        }

        public void keyTyped(KeyEvent arg0) {
        }
    }
}

 

[Exodus155]

Ah ok danke jetz gehts besser! also zu einem anderen thema kurz!

Ich hab ein jpegformat mit einer kugel! so wie bekomme ich die kugel jetz alleine da raus ohne den weißen hintergrund?

MFG
Exodus

 

[m@nu]

benutz keine jpg's, sondern png's resp. gif's.
da hast du den vorteil, dass du einen alpha-channel (png) resp. eine transparente farbe (gif) definieren kannst.

 

[Exodus155]

also dass heißt ich kann den weißen hintergrund wegzeichnen dass nur die kugel übrig bleibt oder? aber wie?

MFg
Exodus

 

[Quaxli]

Du erstellst mit geeigneten Grafikprogramm ein GIF oder png mit transparentem Hintergrund. Wie das geht mußt Du ggf. in der Hilfe des Grafikprogramms nachlesen. Die Grafik verwendest Du dann in Deinem Programm und sie wird wie gewünscht dargestellt.

Gruß

Ralf

 

[Exodus155]

So jetz gehts! die kugel bewegt sich hin undher auf tastendruck, aber was mir nicht gefällt, dss die kugel mal schneller ist mal ruckelt es usw.....! Wie kann ich dieses problem mit bufferedImage lösen? Hier mal der ausschnitt von paint:

    protected void paintComponent(Graphics g)
    {
    	
    		Graphics2D g2 = (Graphics2D) g;
    		
    		super.paintComponent(g);
    		
   	    	image = Toolkit.getDefaultToolkit().getImage("Kugel.gif");    	
   	    	
    		g2.drawImage(image,w, x, this);
    	
    }

MFG
Exodus

 

[Wildcard]

Du darfst das Bild nicht in paintComponent laden, das muss vorher passiern.

 

[SlaterB]

und nur EIN MAL?!

 

[Exodus155]

Habs jetz so probiert geht nix!

    public void ImageVorladen()
    {
	    	image = Toolkit.getDefaultToolkit().getImage("Kugel.gif");    	
	    	
	    	if (image != null)
	    	{
	    		repaint();
	    	}
    }
  
  @Override
    protected void paintComponent(Graphics g)
    {
    	
    		Graphics2D g2 = (Graphics2D) g;
    		
    		super.paintComponent(g2);
   	    	
    		if (image != null)
    		{
    		g2.drawImage(image,w, x, this);
    		}
    }

MFG
Exodus

 

[dieta]

Wie "geht nix!" ?

Schmeißt er dir 'ne Exception oder tut er einfach gar nix?

Rufst du die Methode "public void ImageVorladen()" auch im Konstruktor auf? (man kann ja nie wissen...) ?

 

[Exodus155]

KAnn man dass auch so machen?

    protected void paintComponent(Graphics g)
    {
    	
    	if (image == null)
    	{
            image = Toolkit.getDefaultToolkit().getImage("Kugel.gif");
    	}   		
    	
    	Graphics2D g2 = (Graphics2D) g;
    	
    	super.paintComponent(g2);    	
    	
    	if (image != null)
    	{
    	g2.drawImage(image, w,x,this);
    	}    		
    }

MFG
Exodus

 

[DEvent]

KAnn man dass auch so machen?

    protected void paintComponent(Graphics g)
    {
    	
    	if (image == null)
    	{
            image = Toolkit.getDefaultToolkit().getImage("Kugel.gif");
    	}   		
    	
    	Graphics2D g2 = (Graphics2D) g;
    	
    	super.paintComponent(g2);    	
    	
    	if (image != null)
    	{
    	g2.drawImage(image, w,x,this);
    	}    		
    }

MFG
Exodus

Das ist doch Sinnlos jedesmal zu prüfen ob man das Bild geladen hat. Lade das Bild einfach im Konstruktor uhnd gut ist.

 

[Quaxli]

Zum Thema "geht nix": Mir ist noch nicht ganz klar warum, aber bei mir wurde auch nichts angezeigt. Erst als ich den JFrame f1 als Klassenvariable deklariert hatte und in der doIt-Schleife das repaint() durch f1.repaint(), gefolgt von einem f1.validate() ersetzt hatte, ging es wieder.
Mir ist noch nicht ganz klar, warum das validate() notwendig ist, sollte es eigentlich nicht.

Gruß

Ralf

 

[schalentier]

Hehe, genau das ist ein Grund warum Swing Anwendungen immer langsam sind...

Im obigen Code sind gleich mehrere Fehler. Componenten fuegt man einem JFrame immer per getContentPane() hinzu. Und natuerlich muss das JPanel auch sichtbar sein, also das f1.setVisible(true) nach dem Hinzufuegen aufrufen, nicht vorher!

So isses richtig.

public static void main(String[] args) {
        JFrame f1 = new JFrame();
        f1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f1.setResizable(false);
        f1.setSize(500, 500);
        Test2 ga = new Test2(f1);
        f1.getContentPane().add(ga); // vorher: f1.add(ga)
        f1.setVisible(true);
        ga.doIt();
    }

"validate" startet den Layouter, es werden also alle Kind-Componenten neu angeordnet. Deswegen klappts auch, wenn du ein validate nach (oder vor) dem repaint machst. Nur, ein validate ist sehr teuer.

Wozu das Thread.sleep(10)? Sagts doch, ihr wollt eine langsame Anwendung, um dann die Behauptung aufzustellen, Java waere langsam :bae:

 

[Evil-Devil]

Seit Java5 kann man das hinzufügen von Komponenten direkt über add() machen, das macht immerhin auch nichts anderes als getContentPane() abzufragen.

 

[Quaxli]

add() nehme ich auch immer. Da gab's noch nie Probleme. Lt. Beschreibung in der Klasse Container ist das auch kein Problem.

@schalentier:

Im obigen Code sind gleich mehrere Fehler. Componenten fuegt man einem JFrame immer per getContentPane() hinzu. Und natuerlich muss das JPanel auch sichtbar sein, also das f1.setVisible(true) nach dem Hinzufuegen aufrufen, nicht vorher!

Stimmt! Das mit dem setVisible() hatte ich übersehen (obwohl ich es hätte wissen müssen). Daher war auch das validate() nötig.

Wozu das Thread.sleep(10)? Sagts doch, ihr wollt eine langsame Anwendung, um dann die Behauptung aufzustellen, Java waere langsam

Thread.sleep(10) ist im Rahmen der Spieleprogrammierung durchaus üblich, um anderen Prozessen Zeit zum ausführen zu geben. Wenn Thread.sleep(10) dazu führen würde, daß eine Java-Anwendung als langsam bezeichnet wird hat sie ein grundsätzliches Problem bzw. der Programmierer. Ich verwende immer ein Sleep ohne Performance-Probleme zu haben und habe dies auch regelmäßig in anderen Programmen gesehen. Hier ein Beispiel dafür.

 

[Exodus155]

SO hier mal der aktuelle Quelltest:

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Graphics; 
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.Toolkit;
import java.awt.event.KeyEvent; 
import java.awt.event.KeyListener; 
import java.awt.image.BufferedImage;
import java.awt.image.RGBImageFilter;
import java.awt.image.VolatileImage;
import java.io.File;

import javax.swing.JFrame; 
import javax.swing.JPanel;


public class game extends JPanel{ 	
	
//Kugel
	private int w = 100;
    private int x = 100; 
    private int y = 150;
    private int z = 150; 
    
    long last = 0; 
    long delta = 0; 
    double mod = 1000000000; 
    int speed = 150; 

    private boolean up = false; 
    private boolean down = false; 
    private boolean left = false; 
    private boolean right = false; 
    
	VolatileImage img;
	static Image image;


   protected void paintComponent(Graphics g)
    {

	   
   	super.paintComponent(g); 

   	Graphics2D g2 = (Graphics2D) g;
   	
	   
    	
   	
    	
    	g2.drawImage(image, w,x,this);


    			
    }
    
    public void doIt() { 
        try { 
            
            while (true) { 
                
              if(last==0){ 
                last = System.nanoTime(); 
              }else{ 
                delta = System.nanoTime() - last; 
                last = System.nanoTime(); 
              } 
                
                if (left) { 
                   w -= speed*(delta/mod); 
                } 
                if (right) { 
                   w += speed*(delta/mod); 
                } 
                if (up) { 
                   x -= speed*(delta/mod); 
                } 
                if (down) { 
                   x += speed*(delta/mod); 
                } 
                
                Thread.sleep(10); 
                repaint() ; 
            } 
            
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
    } 



    


    public static void main(String[] args) { 
    	
        image = Toolkit.getDefaultToolkit().getImage("Kugel.gif");
        JFrame f1 = new JFrame(); 
        f1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
        f1.setResizable(false); 
        f1.setSize(1280, 1024); 
        f1.setVisible(true); 
        game ga = new game(f1);
        f1.getContentPane().add(ga); 
        f1.add(ga); 
        
        ga.doIt(); 

    } 


    game(JFrame jf) { 
        KeyListener al1 = new MyListener(); 
        jf.addKeyListener(al1); 
    	
    } 

    class MyListener implements KeyListener { 

        public void keyPressed(KeyEvent event) { 
            switch (event.getKeyCode()) { 
            case (KeyEvent.VK_LEFT): 
                left = true; 
                break; 
            case (KeyEvent.VK_RIGHT): 
                right = true; 
                break; 
            case (KeyEvent.VK_UP): 
                up = true; 
                break; 
            case (KeyEvent.VK_DOWN): 
                down = true; 
                break; 
            } 
        } 

        public void keyReleased(KeyEvent event) { 
            switch (event.getKeyCode()) { 
            case (KeyEvent.VK_LEFT): 
                left = false; 
                break; 
            case (KeyEvent.VK_RIGHT): 
                right = false; 
                break; 
            case (KeyEvent.VK_UP): 
                up = false; 
                break; 
            case (KeyEvent.VK_DOWN): 
                down = false; 
                break; 
            } 
        } 

        public void keyTyped(KeyEvent arg0) { 
        } 
    } 
}

Also es geht jetz gut aber es ruckelt noch immer!
Ahja bitte sagts mir wo sich fehler verstekcne!

MFG
Exodus

 

[Quaxli]

Also bei mir ruckelt nichts. Ich habe allerdings noch ein paar Änderungen vorgenommen, bzw. ein paar Vorschläge.

1. Klassennamen werde in Java üblicherweise groß geschrieben. Bennene Deine Klasse doch mal in Game um

2. die Zeile f1.setVisible(true) sitzt noch immer falsch. Diese sollte erst kommen wenn alle Komponenten in den JFrame eingefügt wurden, z. B. so:

public static void main(String[] args) {
       

        JFrame f1 = new JFrame();
        f1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f1.setResizable(false);
        f1.setSize(800, 800);

        game ga = new game(f1);
        f1.getContentPane().add(ga);
        f1.add(ga);
        f1.setVisible(true);
        
        ga.doIt();

    }

3. Auf statische Variablen würde ich möglichst verzichten und daher das Einlesen der Grafik von der main-Methode in den Konstruktor des JPanels verschieben. Zusätzlich lese ich Grafiken etwas anders ein, überlege Dir, ob es Dir zusagt, man umgeht ein paar Probleme, wenn man das Programm z. B. über WebStart verteilen will. Natürlich kannst Du die Toolkit-Variante auch so lassen.

    game(JFrame jf) {
    	
      URL ball_url = this.getClass().getClassLoader().getResource("Kugel.gif");
      try {
				ball = ImageIO.read(ball_url);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    	
        KeyListener al1 = new MyListener();
        jf.addKeyListener(al1);
       
    }

4. Die Paint-Methode habe ich ausgedünnt. Wozu der Cast nach Graphics2D? Momentan ist er zumindest unnötig:

   protected void paintComponent(Graphics g){
      super.paintComponent(g);
      g.drawImage(ball, w,x,this);
    }

Nachdem das ein bißchen viel war, hier noch mal der komplette Code mit meinen Änderungen:

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.awt.image.VolatileImage;
import java.io.IOException;
import java.net.URL;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class Game extends JPanel{    
   
	private static final long	serialVersionUID	= 1L;
	//Kugel
    private int w = 100;
    private int x = 100;
    
    long last = 0;
    long delta = 0;
    double mod = 1000000000;
    int speed = 150;

    private boolean up = false;
    private boolean down = false;
    private boolean left = false;
    private boolean right = false;
   
    BufferedImage ball;


   protected void paintComponent(Graphics g){
      super.paintComponent(g);
      g.drawImage(ball, w,x,this);
    }
   
    public void doIt() {
        try {
           
            while (true) {
               
              if(last==0){
                last = System.nanoTime();
              }else{
                delta = System.nanoTime() - last;
                last = System.nanoTime();
              }
               
                if (left) {
                   w -= speed*(delta/mod);
                }
                if (right) {
                   w += speed*(delta/mod);
                }
                if (up) {
                   x -= speed*(delta/mod);
                }
                if (down) {
                   x += speed*(delta/mod);
                }
               
                Thread.sleep(10);
                repaint() ;
            }
           
        } catch (Exception e) {
            e.printStackTrace();
        }
    }



   


    public static void main(String[] args) {
       

        JFrame f1 = new JFrame();
        f1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f1.setResizable(false);
        f1.setSize(800, 800);

        Game ga = new Game(f1);
        f1.getContentPane().add(ga);
        f1.add(ga);
        f1.setVisible(true);
        
        ga.doIt();

    }


    Game(JFrame jf) {
    	
  	  URL ball_url = this.getClass().getClassLoader().getResource("Kugel.gif");
      try {
				ball = ImageIO.read(ball_url);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    	
        KeyListener al1 = new MyListener();
        jf.addKeyListener(al1);
       
    }

    class MyListener implements KeyListener {

        public void keyPressed(KeyEvent event) {
            switch (event.getKeyCode()) {
            case (KeyEvent.VK_LEFT):
                left = true;
                break;
            case (KeyEvent.VK_RIGHT):
                right = true;
                break;
            case (KeyEvent.VK_UP):
                up = true;
                break;
            case (KeyEvent.VK_DOWN):
                down = true;
                break;
            }
        }

        public void keyReleased(KeyEvent event) {
            switch (event.getKeyCode()) {
            case (KeyEvent.VK_LEFT):
                left = false;
                break;
            case (KeyEvent.VK_RIGHT):
                right = false;
                break;
            case (KeyEvent.VK_UP):
                up = false;
                break;
            case (KeyEvent.VK_DOWN):
                down = false;
                break;
            }
        }

        public void keyTyped(KeyEvent arg0) {
        }
    }
}


Gruß

Ralf

 

[Exodus155]

Ah jetz gehts! stimmtruckelt nichts mehr! ok ähm daran war set.visible true schuld!! HEHE danke ok also nächstes problem: wenn ich nach links drücke läuft der ball schneller alss wenn ich nach rechts drücke warum? Und wenn ich mehrere Grafiken einfügen will(hab nicht getan), dann fängts sicher an zu ruckeln oder? hast du für diese probs eine lösung?

MFG
Exodus

 

[Quaxli]

Die unterschiedliche Geschwindigkeit liegt an einem Rundungsfehler. Ändere mal die Variablen w und x in double um
und ändere die paint-Methode wie folgt:

   protected void paintComponent(Graphics g){
      super.paintComponent(g);
      g.drawImage(ball, (int)w,(int)x,this);
    }

Dann paßt's.

Was das Anzeigen mehrerer Objekte betrifft: Das macht man dann nicht mehr so. In dem Fall solltest Du Dich ein wenig mit Objektorientierung beschäftigen.

Schau Dir mal das Space-Invaders-Tutorial auf cokeandcode.com an. Das hat mir am Anfang auch sehr geholfen.
Hier ist der Link.

 

[Exodus155]

So ähm die geschwindigkeit is noch ziemlich lahm! wie kann ich es schneller machen?

MFG
Exouds

 

[Exodus155]

ok habs schon

!!

MFG
Exouds