Java/Mathe zu punkt bewegen?
Wie bewege ich mit einer konstanten geschwindigkeit Gegner auf der diagonalen zu spieler
Ich bin in der Lage die x und y Werte der Punkte Gegner und Spieler in einer variable zu nutzen
Ich habe schon versucht die Steigung auszurechnen doch Dan bewegt sich Gegner viel schneller umso steiler die Diagonale ist
Ich brauche einen Deltas und einen Deltas wert
2 Antworten
Aus mathematischer Sicht würde ich Vektorrechnung verwenden. Mit deinem Input: Sei (s1,s2) die Position des Spielers und (g1,g2) die Position des Gegners. Dann ist
(s1-g1,s2-g2) der Vektor, in dessen Richtung sich der Gegner bewegen muss. Diesen Vektor müssen wir normieren, damit die Geschwindigkeit nicht von der Distanz abhängt:
Das wäre der Vektor, den der Gegner in einer Zeiteinheit zurücklegt. Wenn du ihn z.B. schneller machen willst, kannst du den Vektor mit irgendeiner Zahl k > 1 multiplizieren.
Ok danke bin in der 8 klasse und muss mich da erstmal einlesen aber es wäre nicht das erste
Schon klar, aber Vektorrechnung funktioniert in jeder Dimension ;)
Vermutlich kannst du auch irgendwie die Steigung verwenden, aber dann kriegst du Probleme, sobald der Gegner und der Spieler dieselbe x-Komponente haben.
@invader7 @MagicalGrill ich glaube ich habe etwas falsch gemacht umso näher punkt gegner punkt spieler kommt umso langsamer wird er um das zu beweißen habe ich mir immer deltaX und deltaY ausgeben lassen
X: 10
Y: 10
X: 9
Y: 9
X: 8
Y: 9
X: 7
Y: 9
X: 6
Y: 9
X: 5
Y: 8
X: 5
Y: 8
X: 4
Y: 8
X: 4
Y: 8
X: 3
Y: 7
X: 3
Y: 7
X: 3
Y: 7
X: 2
Y: 7
X: 2
Y: 7
X: 2
Y: 6
X: 2
Y: 6
X: 2
Y: 6
X: 1
Y: 6
X: 1
Y: 6
X: 1
Y: 6
X: 1
Y: 5
X: 1
Y: 5
X: 1
Y: 5
X: 1
Y: 5
X: 1
Y: 5
X: 1
Y: 5
X: 1
Y: 5
X: 0
Y: 4
X: 0
Y: 4
X: 0
Y: 4
X: 0
Y: 4
X: 0
Y: 4
X: 0
Y: 4
X: 0
Y: 4
X: 0
Y: 4
X: 0
Y: 4
X: 0
Y: 3
X: 0
Y: 3
X: 0
Y: 3
X: 0
Y: 3
X: 0
Y: 3
X: 0
Y: 3
X: 0
Y: 3
X: 0
Y: 3
X: 0
Y: 3
X: 0
Y: 3
X: 0
Y: 3
X: 0
Y: 3
X: 0
Y: 3
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 2
X: 0
Y: 1
X: 0
Y: 1
X: 0
Y: 1
X: 0
Y: 1
X: 0
Y: 1
X: 0
Y: 1
X: 0
Y: 1
X: 0
Y: 1
X: 0
Y: 1
X: 0
Y: 1
X: 0
Y: 1
X: 0
Y: 1
X: 0
Y: 1
Das ist der output den ich erhalte
Mein code:
private int getDeltaX(int x1, int x2) {
int Xdistanz = x2 - x1;
int diagonale = (int) Math.sqrt((int) Math.pow(x2, 2) + (int) Math.pow(x1, 2));
int deltaX = Xdistanz * enemyspeed / diagonale;
return deltaX;
}
private int getDeltaY(int y1, int y2) {
int Ydistanz = y2 - y1;
int diagonale = (int) Math.sqrt((int) Math.pow(y2, 2) + (int) Math.pow(y1, 2));
int deltaY = Ydistanz * enemyspeed / diagonale;
return deltaY;
}
while (1 == 1) {
System.out.println("X: " + getDeltaX(enemyX, playerX));
System.out.println("Y: " + getDeltaY(enemyY, playerY) + "\n");
enemyX += getDeltaX(enemyX, playerX);
enemyY += getDeltaY(enemyY, playerY);
frame.repaint();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
ich weiß nicht ob ihr euch mit programmieren auskennt aber falls nicht:
-Math.pow(zahl,potenz) = hochnehmen
-Math.sqrt(zahl) = wurzel ziehen
ich rufe in einer schleife von 1000ms die bewegung auf
Doch wie man am text output erkennt und in folgendem Video sieht wird der gegner langsamer
Du kannst die Länge der Diagonale nicht mit nur der x-Komponente oder nur der y-Komponente berechnen. So funktioniert Pythagoras einfach nicht ;)
Was du im Wesentlichen bräuchtest (ohne auf die Typisierung zu achten), wäre:
diagonale = Math.sqrt(Math.pow(Xdistanz,2) + Math.pow(Ydistanz,2))
Danke ja das war dumm von mir hätte ich selbst drauf kommen müssen
es hat mit dem richtigen pythagoras funktioniert
Der Vektor ist das was über dem Bruch strich steht unter dem bruchstrich wird einfach per Pythagoras die länge der strecke berechnet oder
Und beim bruchstrich muss ich vermutlich y des Vektor und x des Vektor teilen oder
Das was über dem Bruchstrich steht, ist der Vektor von Gegner nach Spieler. Unter dem Bruchstrich steht die Länge dieses Vektors, die in der Tat mit Pythagoras ausgerechnet wird.
Statt des großen Bruchs kannst du auch die beiden einzelnen Komponenten des Vektors durch diese Länge teilen und kommst damit auf den normierten Richtungsvektor des Gegners, der immer dieselbe Länge hat. Deswegen eignet sich dieser Vektor gut, um ihn für die Geschwindigkeit zu verwenden.
Wenn du ihn z.B. schneller machen willst, kannst du den Vektor mit irgendeiner Zahl k > 1
Oder eben k < 1 für langsamere Gegner.
der Geschwindigkeitsbetrag soll gleich sein.
Also musst du die Geschwindigkeit erst einmal als Vektor schreiben und deren betrag bestimmen.
Es handelt sich um 2d ne