Fahrzeug Simulation: Physik, Canvas & Co

[Jazzman_Marburg]

Hallo werte Gemeinde!
Hat sich zufällig jemand von der anwesenden Gemeinde mal an einer Simulation eines Fahrzeugs versucht? Nicht mit OpenGl, DeplhiX oder wie all die anderen Grafik-Libs heissen, sondern mit den Onboard Mitteln von Delphi: Canvas & Co.
Mir geht es nicht um die Grafik (double Buffer und OffScreen usw.) sondern eher um die Physik (wohl eher klass. Mechanik) die hinter einer solchen Simulation steckt: Geschwindigkeit, Richtung, Beschleunigung. Mir ist klar, dass man eine solche Simulation beliebig kompliziert machen kann, aber darum geht es mir nicht (jetzt nicht...). Ich habe versucht die einschlägigen Schul-Physik Bücher zu konsultieren, aber es scheitert dann schon an der Frage, wie ich denn Pixel pro Tick so definiere, dass irgendwas sinnvolles an simulierter Geschindigkeit in Bezug auf die Masse oder Kraft herauskommt. (Der wohlwollende Leser wird spätenstens hier merken, dass mir vielleicht auch einige physik. Begriffe nicht ganz klar sind).
Ich suche also sowas wie eine Klasse TFahrzeug, die sich mit einer best. Geschwindigkeit und Richtung auf dem Canvas bewegt. Nachkömmlinge dieser Klasse kann ich dann hoffentlich mit immer feineren Paramtern bestücken, die der Realität immer näher kommen.
Hoffe es ist halbwegs klar geworden, was ich meine...

Würde mich sehr über Kommentare, Links oder gar CodeSchnipsel freuen.

Vorab schon mal einen schönen Tach.

Gruss
Jasmin

[Nikolas]

Die Beschreibung ist etwas vage. Wo liegt denn dein Problem? Nwewtonsche Axiome, Bewegungsgesetze, Reibung? Oder wie man mit einem Timer ein Objekt bewegen kann, ohne dass die Geschwindigkeit vom Rechner abhängt?

[Jazzman_Marburg]

Hallo!

>Wo liegt denn dein Problem? Nwewtonsche Axiome
Ja.

>Bewegungsgesetze
Ja, auch.

>Reibung?
Juups!

> Oder wie man mit einem Timer ein Objekt bewegen kann, ohne dass die Geschwindigkeit vom Rechner abhängt?
Genau!

Mir fehlt eigentlich jeglicher Ansatz, der physikalisch gesehen irgendeinen Sinn macht. Ich habe kein Problem ein Shape von links nach rechts wandern zu lassen, was ja auch eine Art Bewegung ist (naja, zumindest fürs Gehirn). Aber ich weiss nicht wie ich meine Klasse auf vernünftigen physikalischen Boden stelle: Also einen Parameter für Masse, Geschwindigkeit etc.

Ich weiss weiterhin etwas vage, aber das Ziel der Simulation ist doch klar, oder ist das auch nicht zu verstehen?

Vielen Dank für die Prompte Reaktion
Gruss
Jasmin

[Der_Unwissende]

Hi und Herzlich Willkommen in der DP :dp:
Deine Frage zu beantworten dürfte etwas schwer fallen. Wie schon gesagt wurde (und du ja auch selbst siehst) ist die Physik ein sehr großes Gebiet, deine Frage sehr allgemein und die Antwort kann beliebig komplex werden.
Das Problem ist also, mit was möchtest du anfangen? Wo scheiterst du hier genau? Und was weißt du schon.

Die meisten Antworten dürften ähnlich unscharf wie deine Frage werden, hier kannst du natürlich schauen, was gerade in die richtige Richtung geht und da dann weiter fragen, aber schöner ist es natürlich immer, wenn du eine halbwegs konkrete Vorstellung hast.

Es gibt ein paar Wichtige Gesetze in der Physik, die du dir anschauen solltest. Für eine Bewegung denke ich fängst du am Besten mit der Impulserhaltung an. Dies ist ein absolutes Grundgesetz und damit kannst du die ersten Zusammenhänge schon gut berechnen. Wie die korrekt formuliert sind findest du sicherlich in jedem (auch schlechten) Physikbuch.
Grob gesagt geht es darum, dass ein Körper, der sich bewegt einen Impuls besitzt. Dieser kann aus der Masse und der Geschwindigkeit des Körpers berechnet werden. Stossen zwei Körper zusammen, so könntest du im einfachsten Fall erstmal annehmen, dass ein solcher Stoss voll-elastisch ist. Das heißt, dass es keine Verformung oder Ähnliches gibt, der Gesamtimpuls muss erhalten bleiben (das gilt immer für geschlossene Systeme) und es ändert sich nur die Geschwindigkeit der beiden Körper. Auch hier sollte dir ein Physikbuch Anhaltspunkte liefern.
Wie gesagt, es wäre der (imho) einfachste Fall mit dem du anfangen könntest. Schau dir einfach mal die Punkte an. Am besten dann direkt dazu weiterfragen (insbesondere auch, wenn du dort einen Teil nicht verstehst).

Ansonsten ist eine Simulation natürlich virtuell. Wenn du einen Körper simulieren möchtest, der sich mit 100.000.000 km/s bewegt, dann wirst du das kaum 1:1 umsetzen können. Einerseits wäre das eine Geschwindigkeit die kein realer Körper annehmen kann und andererseits dürften wenige Monitore 100.000.000 km breit oder hoch sein (und das wäre die pro simulierte Sek. benötigte Größe). Das heißt du setzt das was du zeigen möchtest virtuell um. Du kannst dabei alles mit einem eigenen Maßstab versehen. Das was eine Simulation macht ist die Berechnung was wann wo passiert. Du hast damit die Freiheit deine Zeit beliebig laufen zu lassen. Dann kannst du auch einen Maßstab von 100 Pixel = 1 m oder 100 Px = 1000 m oder oder festlegen. Die Geschwindingkeit mit der du einen Körper bewegst hängt dann von der virtuellen Zeit und der virtuellen Strecke ab. Diese kannst du ganz gewohnt berechnen und in reale Koordinaten auf deinem Bildschirm/in deiner Simulation übertragen.

Gruß Der Unwissende

[markusj]

Einspruch! Ich würde mit der Energieerhaltung beginnen, macht für seine Thematik mehr Sinn^^

mfG

Markus

[Tubos]

Hier noch ein allgemeiner Tip von mir: Das Canvas arbeitet mit Ganzzahlen, man kann da nur ganze Pixel ansprechen.
Du solltest daher die Physik mit Floats berechnen und erst beim Zeichnen in einen Integer umwandeln. Ansonsten würde das viel zu ungenau laufen.

[Der_Unwissende]

Zitat:

Zitat von markusj

Einspruch! Ich würde mit der Energieerhaltung beginnen, macht für seine Thematik mehr Sinn^^

Nun ja, ein Impuls ist eine gerichtete Größe. Es ging hier um die Geschwindikeit (die auch ein Vektor sein sollte und damit auch eine gerichtete Größe, die zudem auch noch die Richtung des Impuls bestimmt). Die Energie ist natürlich ungerichtet, sehe also nicht ganz den Sinn in deinem Einspruch.
An sich wären allerdings Energieerhaltung und Drehimpulserhaltung die nächsten wichtigen Grundgesetze der Physik.

[boserPascal]

Hallo,

das verfolgte Ziel ist zwar immer noch nicht klar, aber sollte man nicht erstmal mit den drei Bewegungsgleichungen anfangen? Evtl. sind Impuls und Energie im vorliegenden Problem vollkommen unrelevant.

@Jasmin
Für die Gleichungen müßtest du allerdings die Randbedingungen schildern.
Also Anfangsgeschwindigkeit, Beschleunigung etc.. Damit kann man dir dann auch
im Bezug ob evtl doch Impuls-, Energie-Erhaltung einen Ansatz liefern.

MfG

[Nikolas]

Welche drei Bewegungsgleichungen meinst du? Einfach so ins blaue schießen, ohne zu wissen, was eigentlich gemacht werden soll ist nicht sehr sinnvoll. Bei manchen Problemen kommt man fast nur mit EES hin, bei anderen bringt er nichts, weil man an ihm keine Zeitabhängigkeit sehen kann. (Was ja gerade der Witz am EES ist. In der theoretischen Mechanik wird er gerade darüber begründet, dass eine Verschiebung in der Zeit an Bewegungsgleichungen nichts ändert)

[boserPascal]

Beschleunigungs-Zeit-Gesetz und die daraus ableitbare Geschwindigkeit und der Weg. Eben die Gleichungen die du in den ersten Physik-Vorlesungen zu Gesicht bekommen wirst. Aber was bitte ist EES?

MfG

[Cöster]

Zitat:

Zitat von boserPascal

Aber was bitte ist EES?

Ich nehme an, er meint Energieerhaltungssatz :zwinker:

[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)?

[mr.winkle]

Das Schlittern würde mich auch interessieren. Realistisch lenkende, fahrtüchtige Autos habe ich in meinem Einparkspiel programmiert, kannst ja mal hier in der Delphi Praxis nach "Einparken" suchen. Auf Wunsch kann ich dir die entsprechende Unit auch zukommen lassen (PN).

mfg, mr.winkle