Abfangkurs berechnen

[Spoon]

Kann mir jemand dabei helfen, wie man einen Abfangkurs berechnet?
Abgefangen wird im 2D-Raum, ich versuche es die ganze zeit per Vektorrechnung, doch ich komm einfach nicht drauf!

Zur Erklärung hab ich ein Bild angehängt

Danke schonmal :angel2:

[Minz]

Hmm,

also könnte es nicht folgendermaßen gehen:

Die Zeit ist entscheidend, angenommen du willst den Abfangkurs in einem Zeitschritt berechnen, dann müsstest du nur die Pfeilspitzen der Vektoren aufeinandersetzen, diese Vektoren in Geradengleichungen umwandeln, und deren Schnittpunkt berechnen.

Das müsste doch die Grundidee sein, danach kommt halt die Zeit noch ins Spiel. Angenommen du willst den Feind erst in 2 Zeiteinheiten abfangen, dann müsstest du den Vektor für den abfangenden Panzer entsprechend in der Länge ändern. Hier jetzt also mal 2, oder du reduzierst die Geschwindigkeit auf die Hälfte, während du den Vektor für den abzufangenden Panzer doppelt so lang wählst...

[Spoon]

Soweit alles richtig, das Problem ist nur, dass eben gerade die Zeit (Frames) die unbekannte ist :)

Ich brauche theoretisch eine Funktion, die die Schnittpunkte der Geraden beinhaltet. Dann müsste ich diese Funktion Ableiten, um den Tiefpunkt zu bestimmen (kürzeste Zeit zum Abfangen). Nur leider schaff ichs nicht :wall:

[Minz]

Besitzen deine Panzer eine feste Geschwindigkeit? oder kann diese variieren?

[Spoon]

geschwindigkeit ist fest, sonst wirds viel zu kompliziert :mrgreen:

[Minz]

Also ich hätte den Weg wie ich darauf kommen könnte...
aber das ist mir zuviel Aufwand :mrgreen: deswegen beschreib ich dir den Weg

Du malst Panzer1 (P1) auf und Panzer 2 (P2)

Bekannt sind die Positionen der Panzer und deren Geschwindigkeit

Nun stellst du eine Liste auf:

Bewegungsrichtung P2 - variabel in Richtung der Bewegungsgeraden von P1
vergangene Zeit - Sekunden, Frames, etc.
Distanz der Panzer

z.B.:
vergangene Zeit: 1 Sekunde
1. P2 bewegt sich direkt auf P1 zu - Distanz 2 Meter
2. P2 bewegt sich auf die Bewegungsgerade von P1 zu mit +5° Unterschied zu 1. - Distanz 1,8 Meter
3. P2 bewegt sich auf die Bewegungsgerade von P2 zu mit +10° Unterschied zu 1. - Distanz 1,4 Meter
4. ...

vergangene Zeit: 2 Sekunden
1. ...

Daraus kannst du eine allgemeine Form der benötigten Formel herleiten...

[Elite-Koennen]

Tach!

Wenn die Geschwindigkeit der Panzer gleich ist, dann muss auch die Länge der beiden Vektoren gleich sein, damit der 2.Panzer am 1.Panzer nich' vorbeifährt:

a ist Vektor des 1.Panzers
b ist Vektor des 2.Panzers

ax^2 + ay^2 = bx^2 + by^2

dann muss noch Folgendes gegeben sein:

Panzer1.Pos.X + ax*Frame = Panzer2.Pos.X + bx*Frame
Panzer1.Pos.Y + ay*Frame = Panzer2.Pos.Y + by*Frame

da a bekannt ist, sind ax und ay bekannt

=> das Gleichungssystem hat 3 Unbekannte und ist theoretisch lösbar.

Wenn ich irgendwo ein Fehler gemacht hab', sagt bescheid!

[Spoon]

Hey danke,

bin nach längerem Überlegen auf die selbe Formel gekommmen.
Es über Nährungswerte zu machen, wie es Minz vorgeschlagen hat, hab ich auch schon überlegt, doch schien es mir nicht "elegant" genug ;)

Manchmal sieht man eben den Wald vor lauter bäumen nicht :)
Habe meine Gleichung nochmal angehängt, ist im Prinzip die selbe wie deine, muss diese jetzt nurnoch auflösen. (denn deine is irgendwie leichter) :wall:

Ich schau mal wie weit ich komme, vielen Dank schonmal ;)


Edit:

die geschwindigkeiten sind unterschiedlich, aber der Ansatz mit den Frames stimmt

[wuschel41]

hiho, ich war auch grad dabei nen abfangkurs zu berechnen, aber da ich grad zu faul bin, bekommt ihr den code in php und nich in delphi, wird ja wohl kein prob für euch sein den zu übersetzen.

geschwindigkeiten beider punkte sind konstant

die idee ist, ein lot auf die flugbahn des zieles zu legen, entfernung zu berechnen, dann die strecke zum startpunkt des ziels und dann den treffpunkt beider. es würd auch mit kreisen gehn, aber ich fands so leichter. der code is noch nich ganz fertig, gleiche geschwindigkeiten führen zu div by zero aber dann kann mans ja auch einfach ausrechnen. ich hoff es ich konnt euch en bissle helfen.

noch was zur erklärung:
ziel fliegt von $a nach $c mit der geschwindugkeit $v und abfänger startet in $b mit $u

habs jetzt doch nochmal kommentiert

Delphi-Quellcode:

<?
   function calcVekLen($a, $b){
      return sqrt($a*$a + $b*$b);
   }

   $a = array(1,2);
   $b = array(3,1);
   $c = array(6,4);

   $v = 1;
   $u = 5;
      
   if($u == $v){
      
   } else {
      //vektoren ziel-start -> ziel-ende , länge; vektor ziel-start -> abfänger-start
      $ac = array($c[0]-$a[0], $c[1]-$a[1]);
      $acLen = calcVekLen($ac[0], $ac[1]);
      $ab = array($b[0]-$a[0], $b[1]-$a[1]);
      
      //falls ziel bereits angekommen
      if($acLen == 0) return FALSE;
      
      //Abstand abfänger-start - ziel(-flug)-gerade
      $d = abs($ac[0]*$ab[1] - $ac[1]*$ab[0]) / $acLen;
      
      //fußpunkt
      $t0 = ($ab[0]*$ac[0] + $ab[1]*$ac[1]) / ($ac[0]*$ac[0] + $ac[1]*$ac[1]);
      $p = array($a[0] + $t0*$ac[0], $a[1] + $t0*$ac[1]);
      
      //vektor ziel-start -> fußpunkt, länge
      $ap = array($p[0]-$a[0], $p[1]-$a[1]);
      $x = calcVekLen($ap[0], $ap[1]);
      
      //hilfsvars   $o kann nicht 1 werden da geschwindigkeiten verschieden
      $o = $v/$u;
      $ph = (2*$x) / (1 - $o*$o);
      $qh = ($x*$x - ($o*$d)*($o*$d)) / (1 - $o*$o);
      
      //quadr. gleichung
      $y1 = -$ph/2 + sqrt(($ph/2)*($ph/2) -  $qh);
      $y2 = -$ph/2 - sqrt(($ph/2)*($ph/2) -  $qh);
      $y3 = -$y1;
      $y4 = -$y2;

      //einheits vektor des ziels in zielrichtung
      $e = array($ac[0]/$acLen, $ac[1]/$acLen);
      
      //2 mögliche schnittpunkte berechnen
      $schnitt1 = array($p[0] + $y1*$ac[0]/$acLen, $p[1] + $y1*$ac[1]/$acLen);
      $schnitt2 = array($p[0] + $y2*$ac[0]/$acLen, $p[1] + $y2*$ac[1]/$acLen);
      
      //prüfen ob in zielrichtung oder -zielrichtung
      if(!is_nan($schnitt1[0]) && !is_nan($schnitt1[1]) && (($schnitt1[0]-$a[0]) / $e[0] >= 0)){
         $targetX = $schnitt1[0];
         $targetY = $schnitt1[1];
         
         //code zum schiff losschicken
         return TRUE;
      } elseif(!is_nan($schnitt2[0]) && !is_nan($schnitt2[1]) && (($schnitt2[0]-$a[0]) / $e[0] >= 0)){
         $targetX = $schnitt2[0];
         $targetY = $schnitt2[1];
         
         //code zum schiff losschicken
         return TRUE;
      } elseif(!is_nan($schnitt3[0]) && !is_nan($schnitt3[1]) && (($schnitt3[0]-$a[0]) / $e[0] >= 0)){
         $targetX = $schnitt3[0];
         $targetY = $schnitt3[1];
         
         //code zum schiff losschicken
         return TRUE;
      } elseif(!is_nan($schnitt4[0]) && !is_nan($schnitt4[1]) && (($schnitt4[0]-$a[0]) / $e[0] >= 0)){
         $targetX = $schnitt4[0];
         $targetY = $schnitt4[1];
         
         //code zum schiff losschicken
         return TRUE;
      } else {
         echo "<pre>Abfangkurs kann nicht gesetzt werden !!\n";
         print_r($schnitt1);
         print_r($schnitt2);
         die("</pre>");
         return FALSE;
      }
   }
?>

[Seniman]

Hallo,

ich glaube ihr macht euch das alle etwas schwer. Das Problem wird einfacher, wenn man das ganze in einem anderen Bezugssystem sieht, und zwar so. Stellt euch vor, die Kamera bewegt sich mit dem Panzer, der abgefangen werden soll (Panzer 1). Dann bewegt sich der zweite Panzer zusätzlich zu seiner eigenen Bewegung konstant in die Gegenrichtung von Panzer 1. Jetzt muss die Richtung von Panzer 2 so gewählt werden, dass die Summe aus dem Bewegungsvektor von Panzer 2 und der Gegenrichtung von Panzer 1 parallel ist zu der Verbindungslinie P2-P1.
Das mag vielleicht etwas verwirrend klingen, ist aber ziemlich einfach.

Grüße
Seniman

[wuschel41]

jo, die idee is mir auch grad gekommen, als ich mein radar im bewegten objekt gezeichnet hab. da macht ma sowas die ganze zeit in der uni und zuhaus denk ma nich dran und machts sich schwer, tztz

[Cicaro]

Zitat:

Zitat von Seniman

ich glaube ihr macht euch das alle etwas schwer. Das Problem wird einfacher, wenn man das ganze in einem anderen Bezugssystem sieht, und zwar so. Stellt euch vor, die Kamera bewegt sich mit dem Panzer, der abgefangen werden soll (Panzer 1). Dann bewegt sich der zweite Panzer zusätzlich zu seiner eigenen Bewegung konstant in die Gegenrichtung von Panzer 1. Jetzt muss die Richtung von Panzer 2 so gewählt werden, dass die Summe aus dem Bewegungsvektor von Panzer 2 und der Gegenrichtung von Panzer 1 parallel ist zu der Verbindungslinie P2-P1.
Das mag vielleicht etwas verwirrend klingen, ist aber ziemlich einfach.

Dann rück doch einfach mal die Formel raus, wenn es so einfach ist !

[Seniman]

Hallo,

die Richtung kann man folgendermaßen konstruieren: Als erstes ziehst du den Bewegungsvektor des ersten Panzers von dem Ort des zweiten Panzers ab. Um diesen Punkt (nennen wir ihn P) zeichnest du einen Kreis mit Radius der Geschwindigkeit des zweiten Panzers. Dieser Kreis schneidet dann gegebenenfalls die Verbindungslinie von P2 und P1. Falls er das tut (sagen wir in Punkt Q) dann ist der Vektor PQ der Abfangkurs für den Panzer. Falls es keinen Schnittpunkt gibt, dann ist der zweite Panzer zu langsam, um den ersten abzufangen.
Beachte, dass der Kreis und die Gerade meistens zwei Schnittpunkte haben, und du denjenigen nehmen musst, der näher an P1 ist.

Grüße
Seniman

[Spoon]

Hier hat sich ja einiges getan :shock:

Der Ansatz von Seniman erscheint mir doch recht interessant, doch versteh ich nicht ganz, wie das System funktionieren soll, wenn das Ziel nicht sofort zu erreichen ist :?:

Dann müsste ich ja zweimal den Vektor abziehen, einen doppelt so großen Kreis zeichenen... dann alles 3 fach,4x ,5x...

Oder versteh ich da was grundsätzlich falsch ? :roll:

[Seniman]

Hallo,

Zitat:

Zitat von Spoon

Der Ansatz von Seniman erscheint mir doch recht interessant, doch versteh ich nicht ganz, wie das System funktionieren soll, wenn das Ziel nicht sofort zu erreichen ist :?:

Dann müsste ich ja zweimal den Vektor abziehen, einen doppelt so großen Kreis zeichenen... dann alles 3 fach,4x ,5x...

ich war von einem Echtzeit-Spiel ausgegangen. Das war dann so gedacht, das Panzer 2 einmal einen Abfangkurs berechnet und dann immer weiter in eine Richtung fährt, bis er Panzer 1 trifft. Deswegen muss man nur einmal rechnen und dann dem Kurs folgen.

Grüße
Seniman

[Blechwolf]

Salut,

also kann sein das ich das jetzt verkompliziere, aber eigentlich sollte das doch ein typisches Problem für Differentialgleichungen sein oder ? Stichwort Runge-Kutta bzw. Euler Verfahren
Wenn ich die Geschwindigkeit und die Richtung habe, dann kann ich doch mit ner DGL die Position zu jedem Zeitpunkt ausrechnen. Dann weiss ich wo mein Objekt zur Zeit t ist und kann dann einfach nen Vektor von der Position zur aktuellen Position von Objekt2 ziehen und hab die Richtung.
Um dann den Spaß-Faktor zu erhöhen kann mein ürsprüngliches Objekt noch zu jeder Zeiteinheit die Richtung und die Geschwindigkeit ändern...

Soviel zur theoretischen Lösung.

Grüße

Wolf

[generic]

ein praktisches beispiel der oben genannten formel kann man auch im spiel pascal-robots sehen