# Schwerkraft mit festen objekten darstellen



## StrikeTom (24. Apr 2010)

Hallo Leute, 
ich bin ganz neu in der Spieleprogrammierung und mache deshalb vielleicht nicht immer intelligente Beiträge
Ich möche ein Spiel machen, wo man  einen Kreis bewegt.
Dieser Kreis geht immer nach unten(beabsichtigt um die Schwerkraft darzustellen).
Jetzt möchte ich, das er, wenn er auf z.B. einem Rechteck "landet" dort stehen blebt(also soll das rechteck ein "festes" rechteck sein).
Dieses Rechteck möchte als Objekt machen, aber ich habe keinen ansatz, wie ich anfangen soll.
Hier meine Main:

```
import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
 
import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MidiUnavailableException;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class v extends JFrame 
{
    private int x = 50, y = 30;
 
    private boolean[] keyPressed = new boolean[4];
 
    private int UP = 0, RIGHT = 1, DOWN = 2, LEFT = 3;
 
    private int[] a = {2,2,44,5}; 
    
    private int arx[] = {50,50,230,120,80,80,100,100,80,80};
    private int ary[] = {130,40,40,70,100,100,100,130,130,170};

    
    private JPanel ocean = new JPanel() 
    {
    	 public void keyPressed(KeyEvent event)
    	   {
    		   if (event.getKeyCode() == KeyEvent.VK_ESCAPE)
    		     {
    			   System.exit(0);
    		     }
    	   }
   
        public void paintComponent(Graphics g) 
        {
            super.paintComponent(g);
            this.setBackground(Color.white);
            g.setColor (Color.black);
            g.fillOval (x, y, 10, 10);
            
            g.drawRect (100, 100,200, 200);
            g.drawLine(20, 20, 10, 10);
            g.setColor (Color.blue);
            g.setColor (Color.darkGray);
            g.setColor (Color.red);
            int x = 10, y = 80;
            int sizex, sizey = 0;
            g.setColor(Color.black);
            g.drawPolygon(arx,ary,arx.length);

            while (x < 280 && y < 180)
            {
               sizex = 209;
               if (6 > 0.5)
               {
                  y += sizey;
                  sizey = 4 + 6;
               }
               g.drawRect(x+200,y+200,sizex,sizey);
               x += sizex;
            }
        }
    };
    public v() 
 {
        super("Spiel");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setAlwaysOnTop(true);
        this.setLocationByPlatform(true);
        this.setResizable(false);
        this.addKeyListener(new KeyAdapter()
        {
            public void keyPressed(KeyEvent e) 
            {
                update(e, true);
            }
 
            public void keyReleased(KeyEvent e)
            {
                update(e, false);
            }
 
            public void update(KeyEvent e, boolean pressed) 
            {
                if (e.getKeyCode() == KeyEvent.VK_UP)
                {
                	keyPressed[UP] = pressed;
                	//Hier möchte ich es irgendwie noch machen, dass man nicht belibig hoch            
                        //springen kann            
                }
                if (e.getKeyCode() == KeyEvent.VK_RIGHT)
                {
                    keyPressed[RIGHT] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_LEFT)
                {
                    keyPressed[LEFT] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_W)
                {
                    keyPressed[UP] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_D)
                {
                    keyPressed[RIGHT] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_A)
                {
                    keyPressed[LEFT] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_ESCAPE)
                {
                	 System.exit(0);
                }
            }
        });
 
        new Thread()
        {
            public void run() 
            {
                while (true) 
                {
                    y -= (keyPressed[UP] ? 10 : 0);
                    x += (keyPressed[RIGHT] ? 7 : 0);
                    y += (keyPressed[DOWN] ? 10 : 5);
                    x -= (keyPressed[LEFT] ? 7 : 0);
                  
                    ocean.repaint();
                    try 
                    {
                        Thread.sleep(100);
                    } 
                    catch (InterruptedException e) 
                    {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
 
        ocean.setPreferredSize(new Dimension(480, 320));
 
        this.add(ocean, BorderLayout.CENTER);
        this.setSize(600,600); 
        this.setVisible(true);
    }
 
    public static void main(String[] args) throws InterruptedException, MidiUnavailableException, InvalidMidiDataException 
    {
        new v();   
    }
}
```
Danke schonmal im vorraus


----------



## Antoras (25. Apr 2010)

Du hast zwei Dimensionen, einen Kreis und ein Rechteck, die jeweils eine x- und y-Koordinate besitzen. Des weiteren besitzen sie eine Größe (Radius für den Kreis; a und b für das Rechteck). Mehr musst du doch gar nicht wissen. Du musst einfach überprüfen ob der Kreis das Rechteck schneidet. Wenn ja, hältst du den Kreis an, wenn nein lässt ihn weiter fallen.

Die einzige Schwierigkeit sehe ich beim Rechteck, weil du dich da entscheiden musst von wo du zu zeichnen anfängst (an einer Ecke oder im Mittelpunkt des Rechtecks).

Den Schnittpunkt bekommst du auch ganz einfach (hier: Rechteck-Anfang an der Ecke links oben):

```
if Kreis.y - Kreis.radius <= Rechteck.y //unten
  Kreis.stopFallbewegung()
else
  Kreis.beschleunige()
end

if Kreis.x - Kreis.radius <= Rechteck.x + Rechteck.a //links
  Kreis.stopLinksbewegung()
end

if Kreis.x + Kreis.radius >= Rechteck.x //rechts
  Kreis.stopRechtsbewegung()
end
```
Die Größe des Rechtecks musst du natürlich auch noch berücksichtigen. Nicht, dass die Kugel stoppt wenn sie am Rechteck vorbei fliegt.


----------



## StrikeTom (25. Apr 2010)

Danke
Eine Frage noch: wie errechne ich den radius des Kreises und wie würde das in meinem Code aussehen(code)?
mfg


----------



## Antoras (25. Apr 2010)

Den errechnest du überhaupt nicht, der ist doch gegeben. Wenn du einen Kreis zeichnen möchtest, der 10cm groß ist, dann benötigst du einen Radius von 5cm.
Falls du damit noch Probleme hast, hier noch etwas zum nachlesen: Kreis (Geometrie) ? Wikipedia
In Java legst du eine Variable an, der du diesen Radius zuweist (nur, dass es hier Pixel und keine cm sind).


----------



## StrikeTom (25. Apr 2010)

Danke,
Ich probiere es gleich mal aus


----------



## StrikeTom (25. Apr 2010)

Ich habe es jetzt probliert, aber eine Sache fehlt noch:
Das mit Rchteck.x, dass soll doch eine Linie sein, wenn ja, wie finde ich diese herraus?


----------



## Antoras (25. Apr 2010)

Was willst du herausfinden? Die Länge der Linie/des Rechtecks oder wie du die Länge festlegst?

Festlegen tust du es über den a- und b-Wert, den du selbst wählen kannst.
Die Länge findest du über 
	
	
	
	





```
x + a = Breite
```
 und 
	
	
	
	





```
y + b = Höhe
```
 heraus (wenn du beim linken oberen Eckpunkt zu zeichnen anfängst). Zeichne dir das mal auf Papier, dann wird das schnell klarer.


----------



## StrikeTom (25. Apr 2010)

Und was ist bei der Berechnung die Variable x bzw y?
Danke


----------



## Antoras (25. Apr 2010)

Also, ich versteh gerade nicht was du nicht verstehst; x und y sind doch die Koordinaten der Objekte.

```
class Rechteck {
  int x; //x-Koordinate
  int y; //y-Koordinate
  int a; //Höhe
  int b; //Breite
}

class Kreis {
  int x; //x-Koordinate
  int y; //y-Koordinate
  int r; //Radius
}
```


----------



## StrikeTom (25. Apr 2010)

Wie würde das den bei meinem Code aussehen?
Die Berechnung und eine Klasse für das Objekt namens "festesRechteck".


----------



## Antoras (25. Apr 2010)

Du hast doch deine Schleife, in der du abfragst ob ein Taste gedrückt wurde. Hier darfst du jetzt halt nicht sofort eine Positionsänderung durchführen, sondern musst davor noch überprüfen ob die Änderung erlaubt ist.

```
y -= (keyPressed[UP] && !isCollision() ? 10 : 0);
```
Nach deinem Code. Und wie die Kollision genau funktionieren soll, dazu hab ich schon was geschrieben. Wenn es eine Kollision gibt, dann gibst du true zurück, ansonsten false.
Und wie der Algorithmus für die Methode in Java umgesetzt wird überlegst dir jetzt selber.


----------



## StrikeTom (25. Apr 2010)

Danke ich probiere es gleich mal
Das nervt wahrscheinlich schon, aber wie soll ich die Höhe bzw die Breite des Rechtecks herrausfinden?


----------



## StrikeTom (25. Apr 2010)

Hier mein Code (eclipse sagt mir einen Fehler)
Weiß jemand wo der Fehler ist?

```
import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
 
import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MidiUnavailableException;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class v extends JFrame 
{
    private int x = 50, y = 30;
    private int beschleunigung = 5;
    private boolean[] keyPressed = new boolean[4];
    private int radius = 4;
    private int UP = 0, RIGHT = 1, DOWN = 2, LEFT = 3;
 
    private int[] a = {2,2,44,5}; 
    
    int xr = 100;
    int yr = 100;
    int ar = 100;
    int br = 100;
    
    private int arx[] = {50,50,230,120,80,80,100,100,80,80};
    private int ary[] = {130,40,40,70,100,100,100,130,130,170};

    
    private JPanel ocean = new JPanel() 
    {
    	 public void keyPressed(KeyEvent event)
    	   {
    		   if (event.getKeyCode() == KeyEvent.VK_ESCAPE)
    		     {
    			   System.exit(0);
    		     }
    	   }
   
        public void paintComponent(Graphics g) 
        {
            super.paintComponent(g);
            this.setBackground(Color.white);
            g.setColor (Color.black);
            g.fillOval (x, y, 10, 10);
            
            g.drawRect (100, 100,200, 200);
            g.drawLine(20, 20, 10, 10);
            g.setColor (Color.blue);
            g.setColor (Color.darkGray);
            g.setColor (Color.red);
            int x = 10, y = 80;
            int sizex, sizey = 0;
            g.setColor(Color.black);
            g.drawPolygon(arx,ary,arx.length);

            while (x < 280 && y < 180)
            {
               sizex = 209;
               if (6 > 0.5)
               {
                  y += sizey;
                  sizey = 4 + 6;
               }
               g.drawRect(x+200,y+200,sizex,sizey);
               x += sizex;
            }
        }
    };
    public v() 
 {
        super("Spiel");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setAlwaysOnTop(true);
        this.setLocationByPlatform(true);
        this.setResizable(false);
        this.addKeyListener(new KeyAdapter()
        {
            public void keyPressed(KeyEvent e) 
            {
                update(e, true);
            }
 
            public void keyReleased(KeyEvent e)
            {
                update(e, false);
            }
 
            public void update(KeyEvent e, boolean pressed) 
            {
                if (e.getKeyCode() == KeyEvent.VK_UP)
                {
                	keyPressed[UP] = pressed;
                	//Hier möchte ich es irgendwie noch machen, dass man nicht belibig hoch            
                        //springen kann            
                }
                if (e.getKeyCode() == KeyEvent.VK_RIGHT)
                {
                    keyPressed[RIGHT] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_LEFT)
                {
                    keyPressed[LEFT] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_W)
                {
                    keyPressed[UP] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_D)
                {
                    keyPressed[RIGHT] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_A)
                {
                    keyPressed[LEFT] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_ESCAPE)
                {
                	 System.exit(0);
                }
            }
        });
 
        new Thread()
        {
            public void run() 
            {
                while (true) 
                {
                    y -= (keyPressed[UP] && !isCollision() ? 10 : 0);
                    x += (keyPressed[RIGHT] ? 7 : 0);
                    y += (keyPressed[DOWN] ? 10 : beschleunigung);
                    x -= (keyPressed[LEFT] ? 7 : 0);
                  
                    ocean.repaint();
                    try 
                    {
                        Thread.sleep(100);
                    } 
                    catch (InterruptedException e) 
                    {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
 
        ocean.setPreferredSize(new Dimension(480, 320));
 
        this.add(ocean, BorderLayout.CENTER);
        this.setSize(600,600); 
        this.setVisible(true);
    }
    public void anhalten()
    {
    	keyPressed[UP] = false;
    	keyPressed[DOWN] = false;
    	keyPressed[LEFT] = false;
    	keyPressed[RIGHT] = false;
    }
    public boolean isCollision()
    {
    	if (y - radius <= yr) //unten
    	{
    		keyPressed[DOWN] = false;
    		beschleunigung = 0;
    		return true;
    	}
    	else
    	{
    		beschleunigung = 5;
    		return false;
    	}
    	if (x - radius <= xr + ar) //links
    	{
    		 keyPressed[LEFT] = false;
    		 return true;
    	}
    	else
    	{
    		beschleunigung = 5;
    		return false;
    	}
    	if (x + radius >= xr)//rechts
    	{
    		 keyPressed[RIGHT] = false;
    		 return true;
    	}
    	else
    	{
    		beschleunigung = 5;
    		return false;
    	}
    }
    public static void main(String[] args) throws InterruptedException, MidiUnavailableException, InvalidMidiDataException 
    {
        new v();       
    }
}
```


----------



## eRaaaa (25. Apr 2010)

StrikeTom hat gesagt.:


> Weiß jemand *wo* der Fehler ist?



Jo, ab Zeile 173


----------



## Antoras (25. Apr 2010)

```
if (y - radius <= yr) //unten
        {
            keyPressed[DOWN] = false;
            beschleunigung = 0;
            return true;
        }
        else
        {
            beschleunigung = 5;
            return false;
        }
        if (x - radius <= xr + ar) //links
        {
             keyPressed[LEFT] = false;
             return true;
        }
```
Du verlässt in dem else-Zweig die Methode. Da else immer aufgerufen wird wenn der if-Zweig nicht true ergibt können alle Anweisungen nach dem else nicht mehr ausgeführt werden.
Eine Möglichkeit das zu umgehen wäre bspw. für jede Seite eine extra Methode zu erstellen, also z.B. isCollisionAtTop(), isCollisionAtBottom(), ...


----------



## StrikeTom (25. Apr 2010)

Danke, jetzt habe ich den Code aktualisiert, aber es funktioniert immer noch nicht richtig.
Weiß jemand warum?

```
import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
 
import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MidiUnavailableException;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class v extends JFrame 
{
    private int x = 50, y = 30;
    private int beschleunigung = 5;
    private boolean[] keyPressed = new boolean[4];
    private int radius = 4;
    private int UP = 0, RIGHT = 1, DOWN = 2, LEFT = 3;
 
    private int[] a = {2,2,44,5}; 
    
    int xr = 100;
    int yr = 100;
    int ar = 100;
    int br = 100;
    
    private int arx[] = {50,50,230,120,80,80,100,100,80,80};
    private int ary[] = {130,40,40,70,100,100,100,130,130,170};

    
    private JPanel ocean = new JPanel() 
    {
    	 public void keyPressed(KeyEvent event)
    	   {
    		   if (event.getKeyCode() == KeyEvent.VK_ESCAPE)
    		     {
    			   System.exit(0);
    		     }
    	   }
   
        public void paintComponent(Graphics g) 
        {
            super.paintComponent(g);
            this.setBackground(Color.white);
            g.setColor (Color.black);
            g.fillOval (x, y, 10, 10);
            
            g.drawRect (100, 100,200, 200);
            g.drawLine(20, 20, 10, 10);
            g.setColor (Color.blue);
            g.setColor (Color.darkGray);
            g.setColor (Color.red);
            int x = 10, y = 80;
            int sizex, sizey = 0;
            g.setColor(Color.black);
            g.drawPolygon(arx,ary,arx.length);

            while (x < 280 && y < 180)
            {
               sizex = 209;
               if (6 > 0.5)
               {
                  y += sizey;
                  sizey = 4 + 6;
               }
               g.drawRect(x+200,y+200,sizex,sizey);
               x += sizex;
            }
        }
    };
    public v() 
 {
        super("Spiel");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setAlwaysOnTop(true);
        this.setLocationByPlatform(true);
        this.setResizable(false);
        this.addKeyListener(new KeyAdapter()
        {
            public void keyPressed(KeyEvent e) 
            {
                update(e, true);
            }
 
            public void keyReleased(KeyEvent e)
            {
                update(e, false);
            }
 
            public void update(KeyEvent e, boolean pressed) 
            {
                if (e.getKeyCode() == KeyEvent.VK_UP)
                {
                	keyPressed[UP] = pressed;
                	//Hier möchte ich es irgendwie noch machen, dass man nicht belibig hoch            
                        //springen kann            
                }
                if (e.getKeyCode() == KeyEvent.VK_RIGHT)
                {
                    keyPressed[RIGHT] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_LEFT)
                {
                    keyPressed[LEFT] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_W)
                {
                    keyPressed[UP] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_D)
                {
                    keyPressed[RIGHT] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_A)
                {
                    keyPressed[LEFT] = pressed;
                }
                if (e.getKeyCode() == KeyEvent.VK_ESCAPE)
                {
                	 System.exit(0);
                }
            }
        });
 
        new Thread()
        {
            public void run() 
            {
                while (true) 
                {
                    y -= (keyPressed[UP] ? 10 : 0);
                    x += (keyPressed[RIGHT] && !isCollisionOnRight() ? 7 : 0);
                    y += (keyPressed[DOWN] && !isCollisionOnTop() ? 10 : beschleunigung);
                    x -= (keyPressed[LEFT] && !isCollisionOnLeft() ? 7 : 0);
                  
                    ocean.repaint();
                    try 
                    {
                        Thread.sleep(100);
                    } 
                    catch (InterruptedException e) 
                    {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
 
        ocean.setPreferredSize(new Dimension(480, 320));
 
        this.add(ocean, BorderLayout.CENTER);
        this.setSize(600,600); 
        this.setVisible(true);
    }
    public void anhalten()
    {
    	keyPressed[UP] = false;
    	keyPressed[DOWN] = false;
    	keyPressed[LEFT] = false;
    	keyPressed[RIGHT] = false;
    }
    public boolean isCollisionOnTop()
    {
    	if (y - radius <= yr) //unten
    	{
    		keyPressed[DOWN] = false;
    		beschleunigung = 0;
    		return true;
    	}
    	else
    	{
    		beschleunigung = 5;
    		return false;
    	}
    }
    public boolean isCollisionOnLeft()
    {
    	if (x - radius <= xr + ar) //links
		{
		 keyPressed[LEFT] = false;
		 return true;
		}
    	else
    	{
		beschleunigung = 5;
		return false;
    	}
    }
    public boolean isCollisionOnRight()
    {
    	if (x + radius >= xr)//rechts
    	{
    		keyPressed[RIGHT] = false;
    		return true;
    	}
    	else
    	{
    		beschleunigung = 5;
			return false;
    	}
    }
    public static void main(String[] args) throws InterruptedException, MidiUnavailableException, InvalidMidiDataException 
    {
        new v();       
    }
}
```


----------



## Antoras (25. Apr 2010)

Zeichne dir ein Bild und überlege dir ganz genau was du machen willst. Du hast jetzt nur meinen Pseudocode abgetippt ohne dir dessen Sinn zu überlegen - mir ist da außerdem gerade aufgefallen, dass eine Abfrage nicht mal korrekt ist.
Wenn du das richtig machen willst benötigst du nicht nur eine, sondern vier Abfragen pro Seite (bei einem Viereck). Das wären dann 16 insgesamt. Aber das ginge vorerst zu weit.

Fang am besten mit einem Viereck an (und nur mit geraden Seiten) und wenn du das dann verstanden hast kannst es immer noch beliebig erweitern. Noch besser ist für dich wahrscheinlich erst mal eine horizontale Linie, die keine Höhe besitzt. Dann kannst du da immer noch Seite für Seite ergänzen.


----------



## StrikeTom (25. Apr 2010)

Ich habe es erstmal mit einer Linie probiert.
Aber es schein immernoch ein fehler zu exstieren!?
Erstmal habe ich den berührungspunkt gemacht:

```
int berührungspunkt = y-radius;
```
Dann habe ich die while schleife gemacht:

```
y -= (keyPressed[UP] ? 10 : 0);
                    x += (keyPressed[RIGHT] ? 7 : 0);
                    y += (keyPressed[DOWN] && isCollisionOnTop() ? 10 : beschleunigung);
                    x -= (keyPressed[LEFT] ? 7 : 0);
```
Und zum Schluss die Methode isCollisionOnTop():

```
public boolean isCollisionOnTop()
    {
    	if (berührungspunkt <= startY) //unten
    	{
    		keyPressed[DOWN] = false;
  			beschleunigung = 0;
  			return true;
    	}
  		else
  		{
  			beschleunigung = 5;
  			return false;
  		}
    }
```
Weiß jemand Rat???


----------



## Antoras (25. Apr 2010)

Top bedeutet, dass du am oberen Rand des Rechtecks auf eine Kollision überprüfen möchtest (egal ob das Rechteck über dem Kreis ist oder darunter):

```
public boolean isCollisionOnTop() {
  if (Kreis.y + Kreis.radius >= Rechteck.y) {
    return true;
  }
  return false;
}
```
Das erste Beispiel von mir war fehlerhaft; hab ich aber schon geschrieben. Und ich sag es noch mal: Zeichne dir das aufs Papier, sonst wirst du es nie verstehen.


----------



## StrikeTom (26. Apr 2010)

Hier geht es aber erstmal um eine Linie


----------



## Antoras (26. Apr 2010)

Ein Rechteck besteht aus lauter Linien. 
Mit dem Code des vorigen Beitrags von mir kannst du den oberen Rand (->eine Linie) des Rechtecks auf Kollision überprüfen. Wenn es dir nicht passt, dann tausch einfach das Rechteck durch Linie aus...


----------



## StrikeTom (26. Apr 2010)

Hallo irgendwie scheint das programm einen Fehler in fer Funktion isCollisionOnTop() zu haben(der Inhalt der Funktion(nur als test)):

```
if(0==0)
    	{
    		System.exit(0);
    		keyPressed[DOWN] = false;
    		anhalten();
  			beschleunigung = 0;
  			return true;
    	}
  		else
  		{
  			beschleunigung = 5;
  			return false;
  		}
```
Und der test:

```
y += (keyPressed[DOWN] && !isCollisionOnTop() ? 10 : beschleunigung);
```
Aber das Programm beendet sich nicht!?
Warum???


----------



## StrikeTom (26. Apr 2010)

Hat sich geklärt(keyPressed[DOWN) war garnicht true)


----------



## StrikeTom (26. Apr 2010)

Das ist nur für eine Linie von oben, aber wenn ich die Linie jetzt länger mache, dann fällt der Ball einfach durch!?
Weiß jemand warum, bitte um Hilfe(hoffelndlich dass letzte mal):

```
if ((y+10 >= startY) && !(x >= endeY) && !(x+10 <= startX)) 
    	{
    		keyPressed[DOWN] = false;
  			return true;
    	}
  		else
  		{
  			beschleunigung = 5;
  			return false;
  		}
```


----------



## Antoras (26. Apr 2010)

Gewöhn dir bitte an Objekte zu benutzen:

```
class Kreis {
  int x, y, r; // r = radius
}
class Linie {
  int x, y, l; // l = länge
}
class Rechteck {
  int x, y, w, h; // w = weite, h = höhe
}
```
Dann Kannst du folgendes schreiben:

```
Kreis k = new Kreis();
Linie l = new Linie();
Rechteck r = new Rechteck();

k.r = 10 // Wertezuweisung
...
```
Und dein Code wird leserlicher:

```
if ((k.y+10 >= l.y) && !(k.x >= l.y) && !(k.x+10 <= l.x)) 
        {
            keyPressed[DOWN] = false;
            return true;
        }
        else
        {
            beschleunigung = 5;
            return false;
        }
```
Du hast hier aber x- und y-Achse vertauscht und die Ausrufezeichen haben da auch nichts zu suchen:

```
if (k.y + k.r >= l.y && k.x + k.r > l.x && k.x < l.x + l.l) // => Kollision aufgetreten
```


----------



## StrikeTom (27. Apr 2010)

DANKE


So besser?

```
class Kreis 
{
	  int x, y, r; // r = radius
	  public Kreis(int arg0, int arg1, int arg2)
	  {
	  x = arg0;
	  y = arg1;
	  r = arg2;
	  }
}
public class v extends JFrame 
{
	Kreis Figur = new Kreis(50,30,4);
    private int x = Figur.x, y = Figur.y;
//usw...
```
Wie berechne ich die Länge der Linie?

Habe ich was vertauscht?:

```
int startY = 300;
    int startX = 100;
    int endeY = 300;
    int endeX = 400;
```
Und die Linie(noch nicht mit einem Objekt):

```
g.drawLine(startX, startY, endeX, endeY);
```


----------



## Antoras (27. Apr 2010)

> Wie berechne ich die Länge der Linie?


Ahhhhh, liest du überhaupt das was ich schreib? Guck mal ein Beitrag weiter oben, letzte Zeile.
Ich hab den Eindruck, dass dir hier viel Grundlagenwissen fehlt. Ein Tipp: Frag mal deinen Mathelehrer ob er dir nach dem Unterricht mal schnell den geometrischen Aufbau von Kreisen, Rechtecken usw. erklärt.



> So besser?


Ja, wobei da immer noch einiges nicht passt.


```
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;

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


public class CircleLineCollision implements Runnable {
	
	Circle c = null;
	Line l = null;
	JPanel pnlPaint = null;
	
	public static void main(String[] args) {
		new CircleLineCollision();
	}
	
	public CircleLineCollision() {
		c = new Circle(90, 20, 20);
		l = new Line(50, 150, 100);
		
		JFrame f = new JFrame("CircleLineCollision");
		f.setPreferredSize(new Dimension(200, 200));
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setLocation(500, 500);
		f.add(createPanelPaint());
		f.pack();
		f.setVisible(true);
		new Thread(this).start();
	}
	
	@Override
	public void run() {
		while (true) {
			if (!doIntersect()) {
				c.y += 1;
			}
			pnlPaint.repaint();
			
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	private boolean doIntersect() {
		if (c.y + c.a >= l.y && c.x + c.a > l.x && c.x < l.x + l.l) {
			return true;
		}
		return false;
	}
	
	private JPanel createPanelPaint() {
		if (pnlPaint == null) {
			pnlPaint = new JPanel() {
				@Override
				protected void paintComponent(Graphics g) {
					super.paintComponent(g);

					c.paint(g);
					l.paint(g);
				}
			};
			pnlPaint.setBackground(Color.WHITE);
			pnlPaint.setFocusable(true);
		}
		return pnlPaint;
	}

	class Line {
		int x, y, l;
		
		Line(int x, int y, int l) {
			this.x = x;
			this.y = y;
			this.l = l;
		}
		
		public void paint(Graphics g) {
			g.drawLine(x, y, x + l, y);
		}
	}

	class Circle {
		int x, y, a;
		
		Circle(int x, int y, int a) {
			this.x = x;
			this.y = y;
			this.a = a;
		}
		
		public void paint(Graphics g) {
			g.fillOval(x, y, a, a);
		}
	}
}
```
Angucken, lernen und umsetzen. Und bei deinem nächsten Post wäre es schön wenn in deinem Programm die Kollision endlich komplett funktionieren würde und du verstanden hast was da programmieren willst.


----------



## StrikeTom (4. Mai 2010)

Danke
Es tut mir leid, dass ich nicht so richtig überlegt habe


----------

