Fahrzeug Simulation: Physik, Canvas & Co

[Cöster]

Zitat von boserPascal:

Aber was bitte ist EES?

Ich nehme an, er meint Energieerhaltungssatz

[Jazzman_Marburg]

Hallo Gemeinde,

> "Newtonsche Axiome"
> "Impulserhaltung"
> "Energieerhaltung"
> "Drehimpulserhaltung"
> "Bewegungsgleichungen"

Liebe Leute, habt ihr es nicht eine Nummer kleiner?
Ich wollte doch nicht den Flug der "Apollo 13" simulieren -- ich sehe schon einige wieder die Tastatur zücken und sagen "im Prinzip gelten auch für die Apollo die gleichen Gesetze", ich weiss...

Es ging darum, dass ich ein Rechteck über den Monitor bewege, welches ein Nachfahre der Klasse TFahrzeug ist, die wiederum so Eigenschaften wie
- eingeschlagener Winkel,
- Geschwindigkeit,
- Zielgeschwindigkeit sowie
- Beschleunigung
besitzt.

Dazu eine Prise einschlägiger Physik:
1. s(t) = v * t (wenn das TFahrzeug gleichförmig fährt)
2. s(t) = a / 2 * t^2 (wenn das TFahrzeug beschleunigt wird)
(mit s = Weg, a = Beschleunigung, t = Zeit)

Also an sowas hatte ich gedacht -- in der Hoffnung, dass sich schon jemand mal dran versucht hat und mir das Rahmengerüst zur Verfügung stellen könnte.

Ich denke meine lange -- aber eben doch missinterpretierte Anfrage ist an den eher allgemein gehaltenen Lösungsvorschlägen nicht ganz unschuldig.

Dennoch nix für ungut

Gruss
Jasmin

[Daniel B]

Dann mach es eben leichter.

http://www.delphipraxis.net/internal...highlight=auto

Oder: Autorennspiel das erste Ergebnis ist sogar OS, dann knnst dir ja ein bisschen was anschauen.

[boserPascal]

Hallo,

dann brauchst im Prinzip nur ein Verhältnis von Meter zu Pixel zu finden. So kannst du deine Bewegung abbilden. Die Zwischenbilder für deine Animation erhälst du indem du deine Zeit inkrementierst.

Beispiel:

Zitat:

Formel: s(t)=v0*t+s0
Geschwindigkeit v0=10m/s
Weg s0=0m
Pixel: px

5m sind 1Pixel

t in s....0....1....2....3....4....5
-------------------------------------
s in m....0...10...20...30...40...50
-------------------------------------
px........0....2....4....6....8...10

d.h. du mußt s durch 5 teilen um die Verschiebung zu erhalten.

Analog läßt sich natürlich auch die Zeit strecken und stauchen.

Hoffe das hilft!

[TStringlist]

Hallo, ich würde mir die Sache einfach machen und sie in mehrere voneinander völlig unabhängige Arbeitsschritte auftrennen:

1. in eine von allem unabhängige Ortsanzeige. D.h. hier müsste immer grundsätzlich ermittelt werden, welcher Pixel zu kennzeichnen ist, der dieser oder jenen Koordinate am nähesten kommt. In Abhängigkeit des aktuellen Größenverhältnisses (bei deiner Landkartenwiedergabe) und der jeweils aktuellen Koordinate in der linken oberen Canvas-Ecke, wären das dann nur noch mehr ein paar ganz simple Verhältnisrechnungen, mit denen ein solcher gesuchter Pixel dann ermittelbar wäre.

2. in einer Bestimmung der aktuellen Geschwindigkeit, die das Objekt zu einer jeweiligen Sekunde inne hat, und zwar immer auf der Basis einer leicht ausrechenbaren Änderung der Geschwindigkeit zu derjenigen vor dieser Sekunde. Eine solche Geschwindigkeitsänderung wäre dann natürlich auch wieder abhängig von der Beschleunigung, der Masse und event. noch einem Luftwiederstand...

3. der Richtung in der sich das Fahrzeug bewegt. Auch hier bräuchte man im Grunde genommen ebenfalls wieder nur eine Richtungsänderung pro Sekunde ermitteln (und diese dann mit der Richtung in einer jeweiligen Sekunde davor verrechnen).

4. mittels der Punke 2 & 3 hätte man dann also für jede Sekunde eine eindeutige Geschwindigkeit und Richtung in der sich das Fahrzeug bewegt und könnte damit auch seine exakte Position ermitteln (eben auch wieder ausgehend von der jeweiligen Position vor dieser Sekunde) und diese über Punkt 1 ohne Probleme so oder so künstlerisch anzeigen.


Wenn man eine solche Betrachtung also in einzelne Sekundenintervalle aufteilt, dann kann man die einzelne Bewegung darin auch quasi immer als eine linear gleichförmige betrachten, dh. die Ortsänderungen daher immer wieder einfachst möglich so ermitteln: Geschwindigkeit mal Zeit in einer jeweiligen Richtung ...

Die einzelnen Größen, wie die Geschwindigkeit oder die Richtung, könnten dabei natürlich als einzelne Klassen definiert werden, in denen die hierfür nochmals relevanten Parameter wie Schub oder Masse oder Winkelgeschwindigkeit (bei einer Richtungsänderung) die einzelnen Properties wären....

(oder eben alles ganz ganz so ähnlich, natürlich)


edit: musste noch kleines Missverständnis beheben

[Jazzman_Marburg]

Hallo werte Gemeinde,
nachdem ich nun eure Vorschläge (inbes. den letzten Beitrag) versucht habe umzusetzen, komme ich zu folgendem Code -- dessen Richtigkeit mir aber nicht ganz geheuer ist, zumal das Auto sich auch sehr merkwürdig benimmt (erinnert eher an eine Karusellfahrt). Vielleicht habt ihr eine Idee, was da physikalisch nicht ganz korrekt ist:

Delphi-Quellcode:

procedure TForm1.StartBtnClick(Sender: TObject);
var ...
Begin
  XOffset := Auto.width  div 2;
  YOffset := Auto.height div 2;
  
  X := Auto.left + XOffset;
  Y := Auto.top  + YOffset;
  
  Theta    := 0;
  DegToRad := Pi/180;

  StartTime:= Now;
  Tag      := 0;
  
  While tag = 0  do
  Begin
    Sleep(100);
    Application.ProcessMessages;
  
    Vx     := edit1.value;
    Vy     := edit2.value;
    Omega  := edit3.value;
    Radius := edit4.value;

    Currtime := Now;
    dt := (Currtime - Starttime)* secsperday;
    Starttime := Currtime;
    
    dx     := vx * dt;
    dy     := vy * dt;
    x      := x + dx;
    y      := y + dy;
    dTheta := DegToRad * omega * dt;

    Theta  := Theta + dTheta;

    x := x + Radius * cos(Theta);
    y := y + Radius * sin(Theta);
    
    Auto.left := round(x) - xoffset;
    Auto.top  := round(y) - yoffset;
  End;
End;

Meine Frage ist nun, läßt sich die Bewegung eines Fahrzeugs mit allein den vier Angaben:
Linear:
1 Vx := edit1.value;
2 Vy := edit2.value;
Angular:
3 Omega := edit3.value;
4 Radius := edit4.value;

korrekt simulieren?

Danke euch!

Gruss
Jasmin

[Nikolas]

Du solltest dich für ein Koordinatensystem entscheiden und nicht polar und kartesisch zusammenschmeissen.

Delphi-Quellcode:

dx     := vx * dt;
    dy     := vy * dt;
    x      := x + dx;
    y      := y + dy;
    dTheta := DegToRad * omega * dt;

    Theta  := Theta + dTheta;

    x := x + Radius * cos(Theta);
    y := y + Radius * sin(Theta);

Könntest du das mal kommentieren? Welche Bewegung soll da rauskommen? Mit den ersten vier Zeilen könntest du schön eine gleichmäßige Fahrt simulieren. Mit den radialen Codezeilen drehst du das Auto etwas komisch. Auch müsste es y:=y-radius* ; heissen, da die y-Koordinate nach unten größer wird.

[TStringlist]

Also ich würde es ungefähr so machen: ...und zwar zuerst mal von einem anfangs wohl immer richtungsunabhängigem V ausgehen, welches nämlich ganz alleine bloß davon abhängig ist, ob man Gas gibt oder bremst (oder nichts von beidem tut).

v = v + dv;


Danach wäre die Richtung interessant, in der sich das Fahrzeug bewegt:

Richtung = Richtung + dRichtung;
bzw.
Richtung = Richtung + Winkelgeschwindigkeit (z.B. in Grad/0.1sec);

...möglichst also in Grad, wobei 0Grad=Norden, 90Grad=Westen, 180Grad=Süden u. 270Grad=Osten wäre.


Und erst mit diesen beiden Größen kannst Du ja dann auch die Geschwindigkeit in ihre jeweils beiden Richtungskomponenten (vx u. vy) zerlegen, event. etwa so:

vx = vx + round (cos(2*Pi/360 * (Richtung+90)) * dV); // o.ä.
vy = vy + round (sin(2*Pi/360 * (Richtung+90)) * dv); // o.ä.


...um danach schließlich auch diese vier zentralen Zeilen deines Codes

dx := vx * dt;
dy := vy * dt;
x := x + dx;
y := y + dy;

auch durchaus so benutzen zu können ...und womit auch eine jeweilige Ortsveränderung so eigentlich schon fertig ermittelt wäre und dann nur noch mehr in deine Canvas-Grafik reingemalt werden müsste.


Zur event. genauen Bestimmung eines jeweiligen dv´s oder einer jeweiligen Winkelgeschwindigkeit kannst Du ja dann entsprechende Codezeilen noch vor der Verwendung dieser Größen ausführen ...und dabei dann wiederum Parameter mit einfließen lassen, die dann dafür wieder maßgeblich sind (also eine negative oder positive Beschleunigung (a) für dv bzw. einen Lenkradeinschlag plus der aktuellen Geschwindigkeit für die Winkelgeschwindigkeit)...


edit: ...und Norden sollte dann natürlich auch oben auf deinem Screen sein, wie bei allen Landkarten üblich.

...außerdem ist es natürlich auch minimaler Unsinn, ein jedes neues vx u. vy immer aus einem jeweils vorherigen vx u. vy aufzubauen. Besser: vx u. vy errechnet sich immer wieder völlig neu, und zwar nur aus der aktuellen normalen Geschwindigkeit und deren momentaner Richtung:

vx := round (v * cos(2*Pi/360 * (FFahrtrichtung+90)));
vy := round (v * sin(2*Pi/360 * (FFahrtrichtung+90)));

[Codewalker]

Hallo zusammen. Auch wenn der Thread schon älter ist, möchte ich ihn nochmal ausgraben. Ich suche eine gute Anleitung, um ein 2D-Rennspiel zu programmieren, wo das Fahrzeug auch schlittern kann (also z.B. das Heck ausbrechen kann). (Die reine 2D-Bewegung habe ich schon programmiert, aber es nicht unglaublich schön geworden. )

[Codewalker]

*push*

Bin soweit, alles korrekt in einer Richtung umzusetzen, aber das realistische Lenken und Schlittern fehlt mir noch. Hat jemand da ein paar Ansätze, wie man das umsetzen kann (gute Mischung aus Realismus und Arkade)?