hallo leute!
es geht um folgendes:
ich programmier ein spiel, wo man mit einem raumschiff rumfliegen soll..
das mit dem rumfliegen klappt auch alles wunderbar! das problem ist nur, das das raumschiff quasi ohne trägheit rumfliegt! wenn ich z.b. in eine richtung fliege und dann genau entgegengesetzt gas gebe, dann fliegt das schiff sofort mit voller geschwindigkeit in die andere richtung ohne vorher quasi die trägheit zu überwinden :/

hier mal meine momentane steuerungsprozedur:

zusammenfalten · markieren

Delphi-Quellcode:

if(isUp in Main.DXInput.States)then
begin
  if(speed < max_speed) then
  begin
    speed := speed + 0.5;
  end;
  drive_angle := angle;
  dx := cos256(drive_angle)*speed;
  dy := sin256(drive_angle)*speed;
end;

x := x + dx;
y := y + dy;

also wie gesagt.. es funktioniert zwar schon "in etwa" so wie es sollte, dennoch fehlt die trägheit momentan und ich habe keine ahnung wie ich das realisieren soll :/

ich hab hier nochmal 2 videos aufgenommen, eins richtig - eins falsch, bei dem man genau sehen kann was ich meine...

Videos.zip (5,62 mb)

ich hoffe jemand kann mir hier helfen..
greetz GeMo

Deine Bewegung ist einfach umzusetzen, nämlich indem dein Schiff drei Vektoren hat: Position, Geschwindigkeit und Beschleunigung. Mit deinen Schubkontrollen setzt du dann nur die Beschleunigung neu. Die Berechnung ist dann im Prinzip einfach:

Geschwindigkeit := Geschwindigkeit + Beschleunigung * Zeit;
Position := Position + Geschwindigkeit * Zeit;

Das ist alles.

wow...
erstmal danke für die schnelle antwort!
also rein von der theorie her hab ich mir genau das schon gedacht.. nur leider hab ich keine ahnung wie ich das in delphi umsetzen kann
kannst du mir da weiterhelfen?
grüße

Ist DXInput DelphiX? Wenn ja, kann ich da nicht direkt was zu sagen. Wenn du jedoch richtiges DirectX verwendest, hast du dort in Form von D3DX eine Mathe-Bibliothek inklusive Vektoren zur Verfügung, mit denen dann im Prinzip wirklich genauso gerechnet werden kann wie in meinem Pseudo-Code. Wenn nicht, musst du dich vielleicht kurz in Vektoren einarbeiten (ist nicht kompliziert) und dabei einfach nur folgendes beachten: Die Zeit machst du in Sekunden, und die Geschwindigkeit musst du dann auch normalisieren auf Weg pro Sekunde (und Beschleunigung dementsprechend in Weg pro Sekunde im Quadrat). Und wenn du sowas wie maximale Geschwindigkeit oder Beschleunigung haben willst, musst du zu diesem Zweck die Länge der Vektoren überwachen.

Edit:
Ich bin in Delphi nicht mehr so sicher, insofern weiß ich auf Anhieb nicht, wie ich es dort umsetzen würde. In C# ist ein Vektor typischerweise eine Struktur, die aus 2/3/4 Elementen besteht (x, y, z, w) und für die die arithmetischen Operatoren überladen wurden, damit man damit "natürlich" rechnen kann. In Delphi ist möglicherweise ein record die übliche Lösung, und, soweit Operatoren für Records nicht unterstützt werden, eine Handvoll Methoden, die das Rechnen damit ermöglichen. Für den Anfang bräuchtest du nur:
Addition: Vektor + Vektor
Multiplikation: Vektor * Zahl
Berechnung der Länge: Abs(Vektor)
und später vielleicht noch
Skalarprodukt: Vektor * Vektor
Kreuzprodukt: Vektor x Vektor
Sowohl in der XNA-Doku als auch in der D3D-Doku findest du viele Erklärungen dazu (oder in entsprechenden Tutorials).

danke nochmals für deine antwort!
ich habs jetzt anders gelöst. und zwar kann man auch einfach mit hilfe eines rechtwinkligen dreiecks die gewollte bewegung ausrechnen und diese anschliessend zur momentanen bewegung addieren!

zusammenfalten · markieren

Delphi-Quellcode:

max_speed : Integer = 20;

moveX, moveY : Extended;
speed : Extended;
drive_angle, Angle : Integer;

if(isUp in Main.DXInput.States) then
begin
  if(speed < 1) then
  begin
    speed := speed + 0.25;
  end;
  
  beschleunigung := 1;

  newx := beschleunigung * cos256(drive_angle);
  newy := -beschleunigung * sin256(drive_angle);

  if(movex <= max_speed) and (movey <= max_speed) and (movex >= -max_speed) and (movey >= -max_speed) then
  begin
    movex := movex + newx;
    movey := movey + newy;
  end;
end;

x := x + movex*speed;
y := y + movey*speed;

das funktioniert ganz gut eigentlich! hab da jetzt noch ein paar optimierungen drin und dann klappt alles schon sehr gut!
danke für die Hilfe!!

greetz

Das, was du da hast, ist im Prinzip ein spezieller Fall der Vektorrechnung, die ich oben beschrieben habe. Für den Anfang kannst du damit ruhig weiter arbeiten. Langfristig wirst du aber vermutlich feststellen, dass es einfacher ist, die ganze Berechnung nur einmal, nämlich im Rahmen der Vektorfunktionen, zu programmieren, anstatt sie für verschiedene Situationen anpassen zu müssen. Aber bis dahin, viel Spaß