Grafik auf einem JPanel bewegen.

[headset]

Ich habe ein Programm, wo sich Kreise bewegen und von einander abprallen.
Jetzt mochte ich aber die Kreise durch eine Grafik ersetzen.
Mein Code:
[JAVA=1]
package de.elias.grafik;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.ImageCapabilities;

import javax.swing.ImageIcon;

/**
* Diese Klasse ist der Bauplan, für die Kugeln
*
* @author Elias
*
*/
public class Kugel extends Thread {
/**
* Das ist die Grösse von einer Kugel
*/
private int durchmesser = 50;
/**
* Das ist die Farbe der Kugeln
*/
private Color farbe = Color.BLACK;
/**
* Das Panel aus dem Fenster übergeben
*/
private Screen screen = null;
/**
* Das ist die X Position der Kugel
*/
private double x = 0;
/**
* Das ist die Y Position der Kugel
*/
private double y = 0;
/**
* das ist die Geschwindigkeit, mit der sich die Kugel auf der x Koordinate
* bewegt.
*/
private double xSpeed = 0;
/**
* das ist die Geschwindigkeit, mit der sich die Kugel auf der y Koordinate
* bewegt.
*/
private double ySpeed = 0;


private double masse = 0;

/**
* Der Konstruktor nimmt die Eingenschaften auf
*
* @param screen
* Das ist das Panel im Fenster
* @param x
* Das ist die X Position der Kugel
* @param y
* Das ist die Y Position der Kugel
* @param xSpeed
* das ist die Geschwindigkeit, mit der sich die Kugel auf der x
* Koordinate bewegt.
* @param ySpeed
* das ist die Geschwindigkeit, mit der sich die Kugel auf der y
* Koordinate bewegt.
*@param durchmesser
* Da ist der Durchmesser der kugel
*/
public Kugel(Screen screen, int x, int y, double xSpeed, double ySpeed,
int durchmesser) {
this.screen = screen;
this.xSpeed = xSpeed;
this.ySpeed = ySpeed;
this.durchmesser = durchmesser;
this.x = x;
this.y = y;
// -- Berechnung der Masse von der Kugel mit hilfe der Volumenformel bei
// einer Dichte von 1: (4/3*Pi*radius³)
this.masse = 4 / 3 * Math.PI * Math.pow(durchmesser / 2, 3);
}
/**
* Hier verändert die Kugel ihre Position
*/
public void bewege() {
// -- this.x = x + xSpeed;
this.x += xSpeed;
this.y += ySpeed;
kolisionKugel();
kolisionScreen();
}

@Override
public void run() {
// super.run();
while (true) {
try {
sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
bewege();
}
}

/**
* hier werden die kugeln gezeichnet
*
* @param g
* das ist das Objekt, was die Kugeln zeichnet.
*/
public void paint(Graphics g) {
// bewege();

g.setColor(farbe);
g.drawOval((int) x - durchmesser / 2, (int) y - durchmesser / 2,
durchmesser, durchmesser);
}

/**
* Hier wird überprüft, ob zwei Kugeln Kolisieren.
*/
private void kolisionKugel() {
boolean start = false;
for (Kugel kugel : screen.getKugeln()) {
// -- Fehlerprüfung
if (kugel == this) {
start = true;
continue;
}
if (!start) {
continue;
}

// -- Verarbeitung
double xAbstand = kugel.x - x;
double yAbstand = kugel.y - y;
if (xAbstand == 0 && yAbstand == 0)
continue;
// -- Satz des Pythagoras
double entfernung = Math.sqrt(Math.pow(xAbstand, 2)
+ Math.pow(yAbstand, 2));

double minEntfernung = durchmesser / 2 + kugel.durchmesser / 2;

if (x - kugel.x > minEntfernung)
continue;
if (y - kugel.y > minEntfernung)
continue;

if (entfernung <= minEntfernung) {
kolision(xAbstand, yAbstand, entfernung, kugel);
// System.out.println("Kolision");
}

}
}

private void kolision(double xAbstand, double yAbstand, double entfernung,

Kugel kugel) {
// -- Bei bestimmten Konstelationen reagiert die Berechnung fehlerhaft.
if (x == kugel.x && y == kugel.y && xSpeed == kugel.xSpeed
&& ySpeed == kugel.ySpeed)
return;

// -- Wir estellen eine Matrix mit den neuen
// Koordinatenachsen(parallel/senkrecht zum Stoß)
double matrix_1_x = xAbstand / entfernung;
double matrix_1_y = -yAbstand / entfernung;
double matrix_2_x = yAbstand / entfernung;
double matrix_2_y = matrix_1_x;

// -- Koordinatentransformation
double vP1 = xSpeed * matrix_1_x + ySpeed * -matrix_1_y;
double vS1 = xSpeed * -matrix_2_x + ySpeed * matrix_2_y;
double vP2 = kugel.xSpeed * matrix_1_x + kugel.ySpeed * -matrix_1_y;
double vS2 = kugel.xSpeed * -matrix_2_x + kugel.ySpeed * matrix_2_y;

// -- Wenn die Kugeln sich von einander entfernen, findet keine Änderung
// statt.
if (vP1 - vP2 < 0)
return;

// -- Der zentrale Stoß
double mTod = masse + kugel.masse;
double vP1_ = (masse - kugel.masse) / mTod * vP1 + 2 * kugel.masse
/ mTod * vP2;
double vP2_ = (kugel.masse - masse) / mTod * vP2 + 2 * masse / mTod
* vP1;

// -- berechnung der Rücktransvormation
xSpeed = vP1_ * matrix_1_x + vS1 * matrix_1_y;
kugel.xSpeed = vP2_ * matrix_1_x + vS2 * matrix_1_y;
ySpeed = vP1_ * matrix_2_x + vS1 * matrix_2_y;
kugel.ySpeed = vP2_ * matrix_2_x + vS2 * matrix_2_y;

// xSpeed = vX1;
// ySpeed = vY1;
// kugel.xSpeed = vX2;
// kugel.ySpeed = vY2;
}

/**
* Hier wird überprüft, ob eine Kugel gegen eine Wand fliegt
*/
private void kolisionScreen() {
farbe = Color.YELLOW;
// System.out.println("1 yspeed: " + ySpeed);
if (x + durchmesser / 2 >= screen.getSize().width && xSpeed > 0) {
xSpeed *= -1;
} else if (x - durchmesser / 2 <= 0 && xSpeed < 0) {
xSpeed *= -1;
}

if (y + durchmesser / 2 >= screen.getSize().height && ySpeed > 0) {
ySpeed *= -1;
} else if (y - durchmesser / 2 <= 0 && ySpeed < 0) {
ySpeed *= -1;
}

}
}
[/Java]
Ich hab keine Idee mehr.

 

[Gast2]

statt

g.drawoval

einfach

g.drawimage

nehmen ???:L

 

[headset]

Ja, aber ich bekomme das mit dem Pfad angeben nicht
[Java]
private Image kugel = new Image(null, getClass().getResourceAsStream("bilder/kugel.png"));
[/Java]
die Klasse liegt in src/grafik
und die Grafik in src/bilder

 

[SlaterB]

mit ../ kann man in ein höhere Verzeichnis wechseln,


dein ganzer Code ist irrelevant, es geht nur um das Laden des Bildes?

 

[headset]

das mit dem drawimage() hab ich hinbekommen, aber ich hab das krieg das Bild nicht rein

 

[SlaterB]

getClass().getResourceAsStream("../bilder/kugel.png"));

 

[headset]

und wo fang ich an?
Auf meiner Festplatte: C:\Users\Elias\workspace\Kugel\src\bilder\kugeln.png
oder
/Kugel/src/bilder/kugeln.png???

 

[Quaxli]

Klick mal auf den Link in meiner Signatur