[ot]
Hmja. Im Archiv liegen sie noch, https://web.archive.org/web/20140810151816/http://www.heise.de/ct/creativ/08/02/ergebnisse/ , aber das Applet müßte man sich noch irgendwoherzaubern.
[/ot]
[ot]Den findet man auch noch: Asteroid-Spieler in Java 
Die Spielaufzeichnungen und Sourcen kann man in der waybackmachine ja noch problemlos laden.[/ot]
Danke für den Code und die Hilfe.
Vielleicht ist es aber garnicht so schlecht, wenn ich eine eigene “addForce-Methode” schreibe.
Laut dem Buch muss ich den Vektor, den ich bereits auf eine bestimmte länge gesetzt habe nun zu meiner bewegung der Spielfigur hinzuaddieren.
Nun zerbreche ich mir schon länger den Kopf darüber wie ich das machen soll.
Ich habe einen Körper in meinem Fall eine Spielfigur, zu diesem soll ich nun einen Vektor hinzu addieren.
Wie soll ich das machen?
Wenn ich von der bewegung meine Spielfigur spreche, dann ist damit eigentlich die Y-Position des Spielers gemeint.
Denn die Y-Position bestimmt ja, wo sich meine Spielfigur befindet (ich gehe jetzt mal davon aus, das sich die Spielfigur in der Luft nur Vertikal bewegen kann.)
Jetzt frage ich mich nur, wie ich einen Vektor zu einer scalaren Größe addieren soll??
“Y” ist doch nur ein Zahlenwert.
Es scheint mehrere Punkte zu geben, an denen grundsätzliche Verständnisschwierigkeiten bestehen.
Beschreib’ vielleicht nochmal genauer, was du vorhast.
Wenn du die Gravitation meinst, die auf “die y-Koordinate einer Spielfigur” Einfluss hat, dann ist die Gravitationskonstante ziemlich sicher NICHT das, was du suchst.
Einfach nur 3 Stichworte ein Google eintippen, und das erstbeste Codestück aus irgendeinem Buch übernehmen, ist nicht zielführend.
Die Fragen (schon in ihrer Formulierung, a la “Warum wird das rot unterstrichen?”, und ~“Was hat ein Vektor mit einer y-Komponente zu tun?”) deuten darauf hin, dass du versuchst, ein Jump+Run zu schreiben, aber noch nicht so genau weißt, was eine “Methode” oder ein “Vektor” eigentlich sind. Nix für ungut, aber … das kann frustrierend sein.
Ja, es geht um eine Jump & Run game wie z.B. Super Mario.
Was Vektoren sind, habe ich mir bereits angeeignet. Wie ich sie in Java erzeuge auch.
Ich weiß was eine Methode ist, die Java-Grundlagen sind mir bekannt.
Ich möchte nur gerne Wissen, wie die Methode “addForce” funktioniert.
Leider bin ich kein Physiker und daher habe ich da meine Probleme.
Ich hatte bereits zwei Gravitationen in meinem Spiel, doch leider haben beide nicht so 100% funktioniert.
Damit man eine gute Gravitation erhält, muss man Vektoren verwenden.
Vektor gibt es auch eindimensional…
wenn es um den freien Fall geht, kann man den natürlich (grob) berechnen,
etwa
Freier Fall - Weg, Zeit und Geschwindigkeit berechnen
1 sec eingetippt
->
Weg 4,9 m gefallen, Geschwindikeit 35 km/h
da wäre es also denkbar, eine Y-Konstante um 4,9m zu modifizeren (+ Aufschlagschaden zu bestimmen…)
was genau du meinst ist weiterhin unklar
und Sätze wie ‘Damit man eine gute Gravitation erhält, muss man Vektoren verwenden.’ klingen bedenklich
an erster Stelle kommt immer der Verstand, die Intelligenz Situationen + Aufgaben + Argumente in gute Worte zu fassen,
weiter dahinter irgendwann Standardsätze von irgendwo…
Wenn das ein Jump+Run werden soll, muss man sich über das gewünschte Verhalten klar sein. Bei vielen JnRs ist es so, dass man in der Luft noch nach links oder rechts steuern kann, was mit “Physik” dann nichts zu tun hat.
Auf Basis der bisherigen Fragen muss ich aber sagen: Dafür ist es zu früh! Wenn schon die Gravitation solche Schwierigkeiten macht, dann kann z.B. die Kollisionserkennung nur ein planloses Gestolper werden.
Aber wie auch immer. Der physikalische Teil läuft recht einfach ab: Das Objekt hat
- Position
- Geschwindigkeit
- Beschleunigung (=Kraft/Masse)
In jedem Zeitschritt, dessen Dauer mal mit “t” beschrieben sei, macht man
- NeuePosition = Position + t * Geschwindigkeit
- NeueGeschwindigkeit = Geschwindigkeit + t * Beschleunigung
- NeueBeschleunigung = Kraft / Masse
Und dabei ist egal, ob das ganze nun 1D oder 2D ist. Impementiert ist das ganze schon in dem Beispiel aus https://forum.byte-welt.net/java-forum/java-grundlagen/21014-slick2d-vektor.html#post137606 . “Particle” wäre hier die Spielfigur.
[quote=Marco13]- NeuePosition = Position + t * Geschwindigkeit
[…]
Und dabei ist egal, ob das ganze nun 1D oder 2D ist.[/quote]
naja, die erste Formel ist schon eher was nur für 1D 
, mir klarer Richtung,
ob links oder rechts bzw. nach oben oder nach unten in dem 1D lasse ich mal als vorgegeben gelten
wenn 2D eine Bedeutung haben soll, neue Position in 2 Koordinaten abweichend möglich,
dann braucht es schon auch einen Bewegungsvektor (edit: Richtungsvektor) :
1D:
NeuePosition Y2 = Position Y1 + t * Geschwindigkeit
2D:
NeuePosition X2,Y2 = Position X1,Y1 + t * Geschwindigkeit * normierter Richtungsvektor XR, YR
in 3D und weiteren D genauso, ebenso in 1D dazuzudenken, nur ist es dort ein trivialer Vektor (1) oder (-1), je nach Richtung
Unity - Position und Bewegung Teil 2 — Keldrik
Vector3.Normalize
Zur Berechnung einer Richtung nutzen wir die Normalize Methode oder die normalized Property. Damit wird die maximale Länge eines Vectors auf 1 reduziert, was bei der Bewegung eine gleichbleibende Geschwindigkeit unabhängig von der Entfernung garantiert.
Vector3 wegZumZiel = zielPosition - this.transform.position;
// oder wir nutzen Normalize Methode um einen neuen Vector zu erzeugen.
Vector3 richtung = Vector3.Normalize(wegZumZiel);
// Mit der Richtung können wir dann die eigentliche Bewegung berechnen.
this.transform.position += richtung * geschwindigkeit * Time.deltaTime;
Dass das für den „Physikalischen“ Fall war, hatte ich ja geschrieben. Das, was da dann abläuft, kann man auch bullshittig als Explizites Euler-Verfahren – Wikipedia bezeichnen und mit vielen Formeln und Integralen und mathematischen Begriffen ausschmücken, und mit links zu Runge-Kutta-Verfahren – Wikipedia und Verlet-Algorithmus – Wikipedia ausschmücken, aber… es geht um ein Jump+Run
Oder so: Dass man den Fall der horizontalen Bewegung ggf. getrennt betrachten muss, wenn man noch in der Luft steuern können will, kann man noch erwähnen, ja.
EDIT: Ach moment, ging es darum, dass „Geschwindigkeit“ klingt, als wäre es nur eine Zahl? Ja, da könnte man sagen, dass die Aussage mißverständlich war. Bei allen Größen geht es um solche, die die gleiche Dimension haben (außer Masse). In dem Unity-Beispiel wird die 2D-Geschwindigkeit eben durch „Richtung+Länge“ bechrieben. Aber ein einfacher (nicht-normierter) Vektor tut’s auch.
Ich habe bereits erklärt was ich machen will, wenn nach mehrmaligen erklären nicht klar ist was ich meine, dann liegt das sicherlich NICHT AN MIR!
Wenn ich klipp und klar schreibe, das ich ein „Jump&Run“ spiel programmiere und wissen möchte wie so eine “addForce“ Methode funktioniert” und ich noch immer Fragen bekomme wie “Was möchtest du eigentlich” dann weiß ich auch nicht mehr weiter.
Ich habe das Gefühl das ihr es auch nicht so wirklich wisst, ansonsten hättet ihr mir das in einen Beitrag erklären können.
Mittlerweile sind wir schon auf Seite zwei und es hat nichts gebracht.
Ich bekomme Antworten wie: „Das die Kollisionsermittlung ein planloses Gestolper wird“. Echt?
Komischerweise funktioniert die Kollisionserkennung bei mir schon seit einiger Zeit sehr gut. Sie erkennt nicht nur eine Kollision von zwei Hitboxen, sondern bestimmt auch von welcher Richtung die Kollision stattgefunden hat.
Leider bin ich nicht als programmierer vom Himmel gefallen. Wenn ich es wüsste, dann würde ich hier vermutlich nicht schreiben.
Wie bereits erwähnt hatte ich schon zwei Gravitationen für mein Spiel.
Bei der ersten habe ich einfach eine Variable heruntergezählt (ein Tipp von einem YouTuber der Spiele programmiert), leider sieht das echt schei*e aus.
Die zweite war schon etwas aufwändiger. Bei dieser habe ich eine vereinfachte Formel aus einem anderen Forum bekommen. Funktionierte im Großen und Ganzen recht gut, doch leider war die Berechnung recht ungenau und die Spielfigur steckte ständig im Boden fest.
Daraufhin hieß es, dass man eine genaue Gravitation mit Vektoren erhalten kann.
Daraufhin habe ich Google befragt und dieses Buch gefunden. Dieses Buch war recht gut erklärt, bis auf die addForce-Methode. Da diese nicht erklärt war, wollte ich diese einfach nur verwenden.
Da ich diese aber nicht so einfach importieren kann, dachte ich mir vielleicht ist es gar nicht mal so schlecht eine eigene Methode zu programmieren die meinen Kraftvektor zur bewegung des Spielers hinzuaddiert.
So sieht das ganze bei mir aus.
MfG
Im Boden feststecken? Klingt nach einem Fehler bei der Kollisionserkennung :rolleyes:
Dass es um ein Jump’n’Run geht, hast du, wenn ich das richtig sehe, im fünfundzwanzigsten Beitrag dieses Threads das erste mal erwähnt. Davor war von Gravitation und Gravitationskonstanten die Rede, so dass man davon ausgehen musste, dass es sich eher um eine N-Body-Simulation geht (GROB sowas wie ein Sonnensystem, mit Körpern, die sich gegenseitig anziehen, und die Massen haben, bei denen die Gravitationskonstante Sinn macht).
Also, zur addForce-Methode:
private void addForce(Vector2f force)
{
this.force.x += force.x;
this.force.y += force.y;
}
Und das war’s dann auch schon.
(Und wenn du jetzt das Gefühl hast, dass ich dich veräppeln will, verstehe ich das. Es ist aber nicht darin begründet, dass ich dich veräppeln will, sondern nur darin, dass du das Problem offenbar noch nicht genau genug beschrieben hast. Die addForce-Methode muss nicht mehr machen, als das, was da oben steht).
*** Edit ***
Nochmal schnell hingeschrieben, ähnlich wie die Partikel-Sache, aber mit „addForce“-Methode, die einen Vector2f verwendet, dessen Funktionen den relevanten Funktionen des Slick-Vektors entsprehen. Steuerung mit den Cursortasten.
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
public class DerSpringendePunkt
{
public static void main(String[] args)
{
SwingUtilities.invokeLater(() -> createAndShowGUI());
}
private static void createAndShowGUI()
{
JFrame f = new JFrame("Der springende Punkt");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
BodyPanel p = new BodyPanel();
BodyEngine e = new BodyEngine(p);
p.setBodyEngine(e);
f.getContentPane().add(p);
f.setSize(500,500);
f.setLocationRelativeTo(null);
f.setVisible(true);
}
}
class Vector2f
{
public float x;
public float y;
Vector2f()
{
}
Vector2f(float x, float y)
{
this.x = x;
this.y = y;
}
Vector2f add(Vector2f v)
{
x += v.x;
y += v.y;
return this;
}
}
class Body
{
private final float mass;
private final Vector2f position;
private final Vector2f velocity;
private final Vector2f acceleration;
private final Vector2f force;
Body(float posX, float posY)
{
this.mass = 1.0f;
this.position = new Vector2f();
this.velocity = new Vector2f();
this.acceleration = new Vector2f();
this.force = new Vector2f();
this.position.x = posX;
this.position.y = posY;
}
float getMass()
{
return mass;
}
Vector2f getPosition()
{
return position;
}
Vector2f getVelocity()
{
return velocity;
}
Vector2f getAcceleration()
{
return acceleration;
}
Vector2f getForce()
{
return force;
}
void addPosition(Vector2f v, float f)
{
position.x += v.x * f;
position.y += v.y * f;
}
void addVelocity(Vector2f v, float f)
{
velocity.x += v.x * f;
velocity.y += v.y * f;
}
void addAcceleration(Vector2f v, float f)
{
acceleration.x += v.x * f;
acceleration.y += v.y * f;
}
void addForce(Vector2f force)
{
this.force.x += force.x;
this.force.y += force.y;
}
}
class BodyEngine
{
private final BodyPanel bodyPanel;
private final float floorY = 400;
private final Vector2f gravity = new Vector2f(0, 9.81f * 20);
private final Body body;
boolean left = false;
boolean right = false;
boolean up = false;
private long previousStepNs = -1;
BodyEngine(BodyPanel bodyPanel)
{
this.bodyPanel = bodyPanel;
this.body = new Body(200, 100);
Thread thread = new Thread(() -> run());
thread.setDaemon(true);
thread.start();
}
Body getBody()
{
return body;
}
float getFloorY()
{
return floorY;
}
private void run()
{
while (true)
{
performTimeStep();
bodyPanel.repaint();
try
{
Thread.sleep(20);
}
catch (InterruptedException e)
{
Thread.currentThread().interrupt();
return;
}
}
}
private void performTimeStep()
{
if (previousStepNs == -1)
{
previousStepNs = System.nanoTime();
}
long deltaNs = System.nanoTime() - previousStepNs;
float deltaS = deltaNs / 1e9f;
deltaS *= 3.0f;
body.addPosition(body.getVelocity(), deltaS);
body.addVelocity(body.getAcceleration(), deltaS);
body.addAcceleration(body.getForce(), deltaS);
body.addVelocity(body.getVelocity(), -0.01f);
body.getForce().x = 0;
body.getForce().y = 0;
body.addForce(gravity);
body.getAcceleration().x = body.getForce().x / body.getMass();
body.getAcceleration().y = body.getForce().y / body.getMass();
if (left)
{
body.getAcceleration().x = -100;
}
if (right)
{
body.getAcceleration().x = 100;
}
collisionDetection();
//System.out.println("p "+body.getPosition().x+", "+body.getPosition().y);
//System.out.println("v "+body.getVelocity().x+", "+body.getVelocity().y);
//System.out.println("a "+body.getAcceleration().x+", "+body.getAcceleration().y);
//System.out.println("f "+body.getForce().x+", "+body.getForce().y);
previousStepNs = System.nanoTime();
}
private void collisionDetection()
{
if (body.getPosition().y > floorY)
{
body.getPosition().y = floorY;
body.getVelocity().y = 0;
}
if (body.getPosition().x < 0)
{
body.getPosition().x = bodyPanel.getWidth() + body.getPosition().x;
}
if (body.getPosition().x > bodyPanel.getWidth())
{
body.getPosition().x = body.getPosition().x - bodyPanel.getWidth();
}
if (up && body.getPosition().y > floorY - 10)
{
body.getVelocity().y = -300;
}
}
public void setState(boolean left, boolean right, boolean up)
{
this.left = left;
this.right = right;
this.up = up;
}
}
class BodyPanel extends JPanel
{
private BodyEngine bodyEngine;
void setBodyEngine(BodyEngine bodyEngine)
{
this.bodyEngine = bodyEngine;
setFocusable(true);
requestFocus();
addKeyListener(new KeyListener()
{
boolean left = false;
boolean right = false;
boolean up = false;
@Override
public void keyReleased(KeyEvent e)
{
int keyCode = e.getKeyCode();
switch (keyCode)
{
case KeyEvent.VK_LEFT:
left = false;
break;
case KeyEvent.VK_RIGHT:
right = false;
break;
case KeyEvent.VK_UP:
up = false;
break;
}
bodyEngine.setState(left, right, up);
}
@Override
public void keyTyped(KeyEvent e)
{
}
@Override
public void keyPressed(KeyEvent e)
{
int keyCode = e.getKeyCode();
switch (keyCode)
{
case KeyEvent.VK_UP:
up = true;
break;
case KeyEvent.VK_LEFT:
left = true;
break;
case KeyEvent.VK_RIGHT:
right = true;
break;
}
bodyEngine.setState(left, right, up);
}
});
}
@Override
protected void paintComponent(Graphics gr)
{
super.paintComponent(gr);
Graphics2D g = (Graphics2D)gr;
g.setRenderingHint(
RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g.setColor(Color.WHITE);
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(Color.BLACK);
g.draw(new Line2D.Double(
0, bodyEngine.getFloorY(),
getWidth(), bodyEngine.getFloorY()));
Body body = bodyEngine.getBody();
float x = body.getPosition().x;
float y = body.getPosition().y;
g.setColor(Color.RED);
g.fill(new Ellipse2D.Double(x, y-20, 20, 20));
}
}
Gehen wir mal die Basis in der Physik durch.
Die Gravitation die jede Masse durch eine andere Masse erfährt ist keine Kraft sondern eine Beschleunigung.
Für die Erde beträgt sie 9.81 Meter pro Sekunde zum Quadrat.
–> g = 9.81 m/s^2
Die Beschleunigung die eine Masse erfährt ist definiert durch die einwirkende Kraft “F” auf das Objekt geteilt durch seine Masse.
–> g = F / m
bzw. die Kraft die die Gravitation auf ein Objekt auslöst wird berechnet durch
–> F = g * m
Ist deine Spielfigur also z.B. Super Mario mit 80kg dann berechnet sich die Kraft folgendermaßen:
–> F = 9.81 * 80 = 784,8 Newton (Kraft)
oder bei einem Panzer mit 80 Tonnen
–> F = 9.81 * 80000 = 784800 Newton (Kraft)
und diese Kraft addierst du auf den Kraftvektor deiner Spielfigur bei jedem Schleifen-Durchlauf wie Marco13 es über mir gesagt hat.
Du hast doch eine Spiel-Schleife oder?
An der Stelle sei auch gesagt, dass die Kraft aber sowieso wieder zurück in die Beschleunigung umgerechnet werden muss. Den Umweg könnte man sich also auch sparen und direkt die Gravitation auf die y-Beschleunigung des Objektes addieren. Aber das sei nur nebenbei bemerkt und soll die Dinge nicht erstmal unnötig verkomplizieren.
Was die Kollisionserkennung angeht kann man wieder nur ins Blaue raten. Ein Steckenbleiben kann viele Gründe haben, wenn du aber alles Berechnungen selber ausführst würde ich mal behaupten dass du dein Spielobjekt nicht richtig zu einer “gültigen” Position nach einer Kollision zurücksetzt.
Das sieht man häufiger, dass Objekt kollidiert ab y < 2 und das Objekt ist im nächsten Schleifen-Durchlauf von
y = 2.5 auf y = 1.9 gesetzt worden, dann muss das Objekt auf y = 2 korrigiert werden. Sonst bleibt es stecken.
Das stimmt so nicht. Im Laufe des Threads wurde das ja schon (aus gegebenem Anlass, nämlich der unklaren Fragestellung) etwas auseinandergepflückt. Die Gravitation is schon eine Kraft. Und sie wirkt zwischen Massen. Und wenn auf eine Masse eine Kraft wirkt, dann erfährt die Masse eine Beschleunigung. Wenn der Mario nun also einen Schritt über eine Klippe macht, und zu fallen anfängt, dann geschieht das aufgrund der Gravitation ZWISCHEN Mario und der Erde. D.h. die Erde zieht Mario zu sich, aber Mario zieht auch die Erde zu sich. Es bleibt aber für praktische Zwecke nur noch die Beschleunigung von Mario zur Erde hin übrig, und die Beschleunigung der Erde zu Mario hin ist praktisch 0. Das ist auch in Gravitation – Wikipedia ganz knackig beschrieben.
An der Stelle sei auch gesagt, dass die Kraft aber sowieso wieder zurück in die Beschleunigung umgerechnet werden muss. Den Umweg könnte man sich also auch sparen und direkt die Gravitation auf die y-Beschleunigung des Objektes addieren. Aber das sei nur nebenbei bemerkt und soll die Dinge nicht erstmal unnötig verkomplizieren.
Ja, das wurde auch schon angedeutet: Man kann die Gravitation als Kraft eigentlich weglassen, und direkt mit der Beschleunigung arbeiten (in sofern ist „DerSpringendePunkt“ oben auch „falsch“ implementiert, aber … da sollte ja ums Verrecken irgendwo eine „addForce“ vorkommen :rolleyes: …)
Ja das stimmt. „Die Gravitation“ ist Begriffstechnisch eine Kraft da hab ich mich vertan.
Als Kraft aber insofern irrelevant weil sie immer so groß ist das jeder Körper die gleiche Beschleunigung erfährt. Ein Gewicht fällt genau so schnell wie eine Feder im Vakuum.
Damit ist die Gravitationskraft von Körper zu Körper unterschiedlich, die Gravitationsbeschleunigung aber ist eine Konstante.
Naja das haben wir jetzt hoffentlich genug ausgewrungen.
die neuesten Tiraden von Javaman1991 erinnern mich wieder an vorherige Postings, etwa
[QUOTE=Javaman1991]Hat keinen Sinn hier, werde mich in einem anderen Forum schlau machen.
Habe keine Lust darauf, das jeder was anderes sagt.
Weiß nicht warum es nicht möglich ist, das mir einer das kurz und einfach erklärt.
Aber dazu sind die Leute leider nicht in der Lage.[/QUOTE]
oder als geniales Ergebnis in einem anderen Thread
[QUOTE=Javaman1991;134139]DANKE CyborgBeta, genau solche Leute wie du es bist braucht das Forum hier.
[/QUOTE]
eigentlich schade was hier alles an Postings investiert ist,
so dass ich mal diese Warnung hier poste, wenn auch allgemein natürlich keine schöne Sache
@Javaman1991
wenn du dich doch in quasi jedem Thread über das Unverständnis anderer beschweren musst und alle (bis auf CyborgBeta freilich ) keine Hilfe bringen,
warum postest du dann weiter hier?
SlaterB, du investierst ja sehr viel Zeit und Energie um meine Beiträge zu durchforsten.
Anstatt diese Energie zu verschwenden für unnötige Beiträge, wäre es vielleicht besser das du diese Energie in einen einfach und gut erklärten Beitrag investierst.
Sei mir bitte nicht Böse, aber Du bist das beste Beispiel für meine Aussage.
Wenn jemand etwas nicht versteht, dann versuche ich es ihm so einfach wie möglich zu erklären.
Dabei helfen Links zu Wikipedia und co leider nicht weiter.
Ich bin jedem hier sehr Dankbar für seine Hilfe, nur wenn ich merke das es keinen Sinn hat, dann muss ich einen anderen Weg finden.
Das problem ist, das man selber irgendwann keine Lust mehr hat.
Die Kollision funktioniert nur nicht, wenn ich von einen Block auf die Erde springe, dann sinkt der Spieler im Boden ein.
Er sinkt aber nicht immer gleich tief ein. Wenn ich einen Block von links, rechts oder von unten treffe, funktioniert es einwandfrei.
Darum wird es an der Gravitationsberechnung liegen bzw. lag es daran.
MfG und Danke.
mal abgesehen von mir als Glanzbeispiel und dem einen, der sich von dir Lob verdient hat,
wie steht es um den Rest, sind denn nicht fast alle unter deiner Würde? und doch postest du hier weiter?
na, nun genug gemeckert,
aber überdenke, ob es mit dieser Einstellung hier weiter Sinn hat,
und mal sehen ob sonst wer weiter investiert…
Also, sowas wie DerSpringendePunkt sind ja unterhaltsame Fingerübungen, und immer, wenn mal wieder jemand nach Gravitation fragt, kann man das eine oder andere Schnipselchen davon verwursten (obwohl ich das jetzt, OBWOHL sowas wie ThouHeartlessBitch schon hier rumlag, from scratch neu geschrieben hatte).
Inwieweit die (nicht vorhanenden) Fragen jetzt beantwortet oder die (nicht spezifisch (genug) benannten) Probleme jetzt gelöst sind, ist aber nicht klar.
Leute, hört mir mal bitte kurz zu.
Ich wollte hier niemanden beleidigen oder schlecht machen! Wenn ich das getan habe, dann tut es mir Leid es war keine Absicht.
Ich bin einfach nur etwas gereizt, da ich schon lange an dieser schei* Gravitation herumbastle und es geht nichts weiter!
Versteht mich bitte, dass eure Antworten mir nicht wirklich weiterhelfen.
Nun nochmal zu meinem Problem:
Wie programmiert man eine Gravitation (so habe ich das Verstanden):
Als erstes muss man den Abstand zwischen den beiden Objekten ermitteln (bei der Abstand zwischen der Spielfigur und dem Boden).
Dies geschieht einmal in x und y Richtung.
Mit diesen zwei Werten (x, y) kann ich nun einen Vektor erzeugen in Java.
(Warum ein Vektor jetzt genau benötigt wird, habe ich noch nicht ganz verstanden.
Was ein Vektor ist, ist mir klar. Aber warum er jetzt genau für die Gravitation benötigt wird weiß ich leider nicht.)
Als nächstes wird das „Newtonsche-Gravitationsgesetz“ herangezogen. Bei diesem Gesetz geht es um die Massenanziehung, also zwei Körper die sich gegenseitig mit einer bestimmten Kraft anziehen. Genau diese Kraft möchte ich nun berechnen, das mache ich mit der Formel: F = (Gm1m2)/r^2.
Als nächstes kann ich die Beschleunigung berechnen indem ich die Kraft durch die Masse dividiere (Steht alles so im Buch).
Anschließend muss ich meinen Vektor auf die korrekte Länge setzen mit meiner gerade eben berechnete Beschleunigung mit: “setForce(Beschleunigung)”.
Denn die Bewegung meiner Spielfigur hängt nicht nur von der Gravitationskraft sondern auch von der Beschleunigung ab, da die Masse eine Rolle spielt.
Jetzt kommt der Punkt wo ich nicht mehr weiter komme, ab hier muss ich meinen Vektor zur Bewegung meiner Spielfigur hinzuaddieren.
Das macht man laut dem Buch mit der „addForce-Methode“ die ich ja nicht habe.
Deshalb habe ich euch gefragt, wie man einen Vektor zu der Bewegung einer Spielfigur hinzuaddiert, damit ich diese Methode selber programmieren kann?
Das ist mein Wissensstand zum Thema Gravitation.
MfG
Dein Ansatz ist aber falsch (genauer: für deinen Anwendungsfall zu kompliziert).
Die Formel die du dort hast, modelliert die Gravitation zu genau für deinen Anwendungsfall. Wie @Marco13 bereits geschrieben hat, berechnet man damit die Anziehung von zwei Körpern aufeinander, wie bei einem Planetensystem.
Bei dir ist die Anziehungskraft, die von der Spielfigur auf den Boden wirkt, vernachlässigbar, weil die Anziehungskraft vom Boden auf die Figur um viele Größenordnungen größer ist.
Du brauchst nicht unbedingt einen Vektor, um die Gravitation zu berechnen, weil diese immer genau in y-Richtung wirkt und daher keine Auswirkung auf die Geschwindigkeit in x-Richtung hat. Es reicht aus, wenn du mit der Formel [tex]v_t = t \cdot a + v_0[/tex] rechnest, wobei [tex]v_0[/tex] die Geschwindigkeit in y-Richtung im letzten Frame ist, [tex]t[/tex] die Dauer in Sekunden, die ein Frame angezeigt wird und [tex]a = 9,81…\frac{m}{s^2}[/tex].
Genauere Ergebnisse erhältst du, wenn du das t über mehrere Frames streckst, weil dann weniger Rundungsfehler entstehen.
Der Ansatz mit “addForce” ist überkompliziert und daher ungeeignet!