Punkt auf Kugel berechnen / Kreisbah in 3D

  • GM 8
  • Punkt auf Kugel berechnen / Kreisbah in 3D

    Ich falle mal gleich mit der Tür ins Haus; ich will einen Punkt auf einer Kugel berechnen.

    Mit diesem Code geht das auch und ich kann mich rund um die Kugel bewegen:

    GML-Quellcode

    1. radius = point_distance_3d(x,y,z,new_originx,new_originy,new_originz);
    2. x = radius * cos(beta) * cos(alpha); //beta = drehung der y-achse
    3. y = radius * cos(beta) * sin(alpha);//alpha = drehung der z-achse (direction)
    4. z = radius * sin(beta);
    5. x += new_originx;
    6. y += new_originy;
    7. z += new_originz;


    damit bekomme ich folgende Bewegung um eine Kugel hin:


    das Problem dabei ist;
    -die Geschwindigkeit mit der ich den Orbit beschreite ist immer gleich egal wie groß die Kugel ist.
    -wenn ich an die Pole meiner Kugel komme dann drehe ich einfach nur einen kleinen horizontalen Kreis anstatt eines Orbits der vertival steht.
    -also drehe ich mich immer nur um die z-achse und kann meine höhe mithilfe der y-achse einstellen
    -ich muss immer beide Winkel ständig ändern um mich fortzubewegen

    ich möchte so etwas erreichen:


    ich habe versucht mit den lengthdir funktionen durch zu kommen, da ich mit denen auch wunderbar den orbit und den wechsel zwischen 2 orbits in 2 dimensionen hinbekomme.

    GML-Quellcode

    1. direction = point_direction(x,y,new_originx,new_originy);
    2. x += lengthdir_x(antrieb,alpha+90) * lengthdir_x(1,beta);
    3. y += lengthdir_y(antrieb,alpha+90) * lengthdir_x(1,beta);
    4. z -= lengthdir_y(antrieb,beta);


    Mit der Methode kann ich durch "antrieb" die Geschwindigkeit ändern mit der ich den Orbit beschreite. Und ich kann mein Schiff immer perfekt an die Oberfläche der Kugel ausrichten, aber:
    -ich kann mich nur in einer ebene oder einer 8er Schleife um zwei Viertel meiner Kugel bewegen und mache demnach keine echten Umdrehungen.
    -ich kann den radius meines Orbits nicht ändern


    ich habe heute in der Arbeit viel darüber nachgedacht und skizziert aber ich komme einfach auf keinen grünen Zweig.

    Optimum wäre:
    -ich verändere die Blickrichtung meines Schiffs, bzw die Nase und daraus wird dann der Orbit errechnet.
    -ich kann eine geschwindigkeits variable ändern um mich fortzubewegen
    -mein schiff steht immer normal zum mittelpunkt der Kugel auf der ich mich bewege
    -ich kann den radius der kugel ändern

    Welche Variablen habe ich momentan damit ich mit ihnen arbeiten kann?
    -die x,y,z koordinate meines Punkts um den ich drehe
    -ich kann die Drehwinkel des Raumschiffs ändern
    -die Distanz abfragen zum mittelpunkt

    Ich sollte mir doch einen Vektor holen können der aus zwei Winkeln einem Radius und einem ursprung mir einen Punkt holen kann und einen Vector der mir anzeigt wohin ich mich weiter bewege?
    Mit den sinus, cosinus funktionen geht das zwar, aber es ist nciht gut das man sich eigtl immer nur um die z-achse bewegt und für kompliziertere Manöver beide Winkel mal in den + mal in den - bereich bewegen muss.
    Außerdem muss ich immer eine Verschiebung dazuberechnen und wenn ich in eine andere Kreisbahn schwenken will geht das überhaupt nicht...

    Das blaue ist mein Raumschiff und die Richtung in die es zeigt. Auf der linken seite fliegt das Schiff ständig im Kreis und umkreist immer den Orbitmittelpunkt während der sich langsam zur zweiten Kugel bewegt. Dabei fliegt es auch mal rückwärts (nicht gut). Rechts dreht sich das Schiff einfach und richtet sich an den neuen Orbit aus. Mit verschiebung entlang der direction+90 lässt sich der radius nun verkleinern auf die gewünschte Orbithöhe.

    Noch ein Bild damit man sich etwas vorstellen kann, wenn es gebraucht wird kann ich zwei Versionen hier hochladen, einmal mit sinus/cosinus berechnugsart und einmal mit lengthdir, damit ihr seht wie man sich dabei bewegt. Ich bin mit meinen Mathekenntnissen leider nun ziemlich am Ende^^


    ancient-pixel.com
    youtube.com/user/SebastianMerkl <<< ich freu mich über einen Besuch ;)
  • Verstehe ich es richtig, das dein eigentliches Problem ist:
    Bisher kannst du dich nur um die Z-Achse um die Kugeln drehen.
    Dein Ziel ist es, sich variabel, unabhängig von irgendwelchen Achsen, um die Kugeln bewegen zu können?

    Werde leider nicht komplett schlau aus dem Text, auch wenn er schön zu lesen ist. :)
    Aktuelles Projekt: Aufbau - Strategiespiel.
    Aktueller Entwicklungsschritt: Planung | Grundengine entwickeln.

    Wichtig ist nicht, besser zu sein als alle anderen.
    Wichtig ist, besser zu sein als du gestern warst.





  • Das ist natürlich eine etwas aufwändigere Sache die die da realisieren möchtest.
    Ich bin mir jetzt nicht 100%ig sicher ob mein Gedankengang genau dem entspricht was du haben möchtest, aber nichtsdestotrotz könnte das für dich als Denkanstoß ausreichen.

    Ich nehme jetzt mal an dass wir das Raumschiff bereits auf einer Kugel (mit beliebigen Radius) platziert haben und dass das Raumschiff bereits in eine Richtung (auf der Kugel) gedreht wurde in die es fliegen soll.
    Nun, das erste was wir berechnen wollen ist wie weit das Raumschiff sich (auf der Kugel) bei der jeweiligen geschwindickeit (die du vorgibst) bewegen soll. (Das war soweit ich lesen konnte ja ein ungelöstes Problem.)

    Nun, es gibt eine Formel die ich im Netz gefunden habe, welche dir erlaubt die Bogenlänge eines Kreisauschnittes zu berechnen. Die formel lautet etwa so:

    GML-Quellcode

    1. /*b = die gesuchte bogenlänge.
    2. alpha = Der Winkel des Teil-kreises
    3. r = radius des Teil-kreises
    4. */
    5. b=(2*r*pi*alpha)/360

    Ein Bild zur veranschaulichung:


    Die Bogenlänge ist die gesuchte distanz, die dein Raumschiff (bei der jeweiligen geschwindichkeit) auf der Kugel zurücklegen soll.
    Das ganze kann man umformen um den Alpha-wert zu kommen:

    GML-Quellcode

    1. alpha = (b*360)/(2*r*pi)

    Auf die weise kannst du dir eine Funktion schreiben, Mithilfe des Parameters "Geschwindickeit" (z.B: bewegung pro step) und den "Radius" der Kugel den dazugehörigen Winkel zurückgibt.
    Der Alpha-wert kann dann verwendet werden um das Raumschiff (wie bei deinen vorherigen ansätzen) auf der Kugel zu bewegen.

    So wie hier auf deinem Bild:


    Das einzige Problem das jetzt noch gegeben ist, wie man das raumschiff in jede beliebige Richtung weiterbewegen könnte.
    Nunja, nehmen wir an dass die Richtung des Raumschiffes in einem Winkel von 0 bis 360 Grad angegeben ist. (sodass die richtung wie in 2D angegeben ist, nur dass es sich dabei auf einem Runden planeten bewegt.)

    Wir haben uns also bereits den Winkel (mit der obrigen formel) ausgerechnet, um den das Schiff sich in die blickrichtung bewegen soll.
    Wir müssen diesen berechneten Winkel nun zu den bereits existenten alpha und beta winkel dazuaddieren.
    Dafür müssen wir uns aus der Blickrichtung und den Bewegungs-winkel eine Art "Vektor" für den Alpha und Beta winkel ausrechnen.

    (bzw. hab bei den sin- und cos funktionen degtorad() eingefügt,da diese den Winkel in radianten als Parameter erwarten.)

    GML-Quellcode

    1. w= (b*360)/(2*r*pi)//w ist der Winkel um den sich das Schiff auf dem Planeten bewegt.
    2. //b ist die distanz die du zurücklegen möchtest.
    3. //r ist der Radius des planeten.
    4. //bewegung um den winkel wird ausgeführt. (Wie eine Vektorberechnung, nur eben für den Winkel statt für das typische Koordinatensystem.)
    5. alpha+= cos(degtorad(ship_direction)) * w;//ship_direction = blickrichtung des Schiffes auf dem Planeten
    6. beta+= sin(degtorad(ship_direction)) * w;
    7. //cos und sin wird einen Wertebereich von -1 und +1 zurückgeben. Wenn wir das mit dem Winkel multiplizieren, bekommen wir den jeweiligen "translationswinkel" auf der y- und z-achse. (wie bei vektoren.)
    8. //neue position
    9. x= radius * cos(degtorad(beta)) * cos(degtorad(alpha)); //beta = drehung der y-achse
    10. y= radius * cos(degtorad(beta)) * sin(degtorad(alpha));//alpha = drehung der z-achse (direction)
    11. z= radius * sin(degtorad(beta));
    Alles anzeigen


    Der code wurde nicht geprüft. Sollte vom gedankengang her aber funktionieren.
    Hoffe ich konnte dir da ein wenig aushelfen.

    Dieser Beitrag wurde bereits 7 mal editiert, zuletzt von LEWA ()

  • Ich versuch dann auch mal zu interpretieren, worum es hier eigentlich geht: Du willst, dass sich dein Raumschiff grundsätzlich auf einem Großkreis bewegt (solange keine Kraft wirkt)? Deine Idee mit Kugelkoordinaten zu arbeiten war schon ganz richtig, des Problemes Lösung ist aber etwas subtiler. Fangen wir vorne an:



    Zunächst einmal wollen wir die Kinetische Energie T des Raumschiffs kennen. Dazu gehe ich nun von konstantem Radius aus. Im folgenden werde ich wie in der Physik üblich zeitliche Ableitungen von größen mit einem Punkt über der Größe kennzeichnen. In kartesischen Koordinaten gilt



    Die in dieser Gleichung enthaltenen Ableitungen können wir einfach Ausrechnen:



    Und die Quadrate:



    Wenn wir das zusammenaddieren dann vereinfacht sich das ganze wie folgt:



    Okay, so sieht also die Kinetische Energie in Kugelkoordinaten bei konstantem Radius aus. Mit den Lagrange-Gleichungen können wir nun Berechnen, wie sich die Winkelgeschwindigkeiten ändern werden. Zunächst für Alpha:



    Wie man eventuell erwarten würde ändert sich die Alpha-Winkelgeschwindigkeit also nicht. Nun zu Beta:



    Und hier liegt der Hase im Pfeffer begraben: Wie wir sehen ändert sich die Beta-Winkelgeschwindigkeit ständig! Du musst einfach in jedem Step die Beta-Winkelgeschwindigkeit entsprechend anpassen.

    Edit: Da hat sich leider ein Vorzeichenfehler in der letzten Gleichung eingeschlichen, der ist jetzt aber korrigiert.
  • Danke für die zahlreichem Antworten :) Leider habe ich es noch nicht hinbekommen :/

    @Michealp800
    Wenn ich Multiplayer eingebaut habe und die Kollision im Raum gelöst habe, dann ja ^^ bis dahin ist es einfach ein Proof of Konzept.

    @gamer
    Korrekt

    @LEWA
    Das mit der Bogenlänge ist super für die Geschwindigkeit, vom Verständnis her, aber als ich deinen Code eingebaut habe, hat sich mein Schiff selbst bei minimalsten Veränderung wie wild herumgedreht um den Planeten und ich konnte nichts mehr erkennen. Auch hat sich mein Schiff im z Bereich nur ganz gerade auf und ab bewegt und dabei die x und y Koordinaten nicht verändert.

    @boxxar
    Whaaat? Nach dem Großkreis bin ich ausgestiegen. Ich nehme an T bringt mir auch eine gewisse Längeneinheit über Zeit die ich für die Geschwindigkeit nutzen kann?


    Nach weiteren Denksitzungen ist mir eingefallen dass es vielleicht ganz anders und einfacher? funktionieren könnte.
    Also ich kann mein Raumschiff ja drehen wie ich will, aber es immernoch mit dem Bauch auf den Mittelpunkt des Planeten zeigen lassen.
    In einer Ebene lässt sich das mit lengthdir_x und lengthdir_y prima umsetzen. Das ist dann auch quasi der Großkreis. Kann ich diesen Kreis irgendwie kippen dadurch das ich die Nase vom Raumschiff nach oben ziehe?
    Die direction(alpha) zeigt immer auf den Planeten (berechnet x und y koordinaten des Punkts)
    Das Raumschiff selbst hat 3 drehbare Achsen die ich verändern kann:
    - rotz (bauch zu rücken)
    - roty (linker flügel zu rechte flügel)
    - rotx (nase zu arsch)
    Ich bräuchte einen vector der immer von nase zu 1(oder Geschwindigkeit) vor nase zeigt. Dann versucht das Raumschiff gerade aus zu fliegen, wird aber im nächsten Schritt wieder an die Kugel ausgerichtet weil der Radius immer gleich bleiben muss und der Bauch auf den Mittelpunkt der Kugel. Damit würde doch das Raumschiff immer auf einem Großkreis der Kugel fliegen, oder?
    Aber wie komme ich an die z Komponente des Vektors?
    lenghtdir_x(geschwindigkeit,alpha) ist die anzusteuernde x koordinate
    lengthdir_y(geschwindigkeit,alpha) die anzusteuernde y korrdinate (vektorkomponente)
    wie komme ich an die z komponente? die ja dann auch die x und y komponente beeinfluss muss?


    EDIT: Wenn ich mein Raumschiff rotiere, rotiert es immer nur um sich selbst? Das muss doch irgendwie auch um einen Punkt rotieren können?

    GML-Quellcode

    1. d3d_transform_set_identity();
    2. d3d_transform_add_rotation_x(rotx);
    3. d3d_transform_add_rotation_y(roty);
    4. d3d_transform_add_rotation_z(rotz);
    5. d3d_transform_add_translation(x, y, z);//<--- die werte zu ändern hat mein Schiff versetzt aber es rotiert immernoch um sich selbst...
    6. d3d_model_draw(model_ship, 0, 0, 0, tex_ship);
    7. d3d_transform_set_identity();

    ancient-pixel.com
    youtube.com/user/SebastianMerkl <<< ich freu mich über einen Besuch ;)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Aku_Ryou ()

  • Ich bräuchte einen vector der immer von nase zu 1(oder Geschwindigkeit) vor nase zeigt. Dann versucht das Raumschiff gerade aus zu fliegen, wird aber im nächsten Schritt wieder an die Kugel ausgerichtet weil der Radius immer gleich bleiben muss und der Bauch auf den Mittelpunkt der Kugel. Damit würde doch das Raumschiff immer auf einem Großkreis der Kugel fliegen, oder?

    Ich hatte diesen Gedankengank auch am anfang gehabt, jedoch wird die tätsächliche geschwindickeit mit der sich das raumschiff auf den Planeten bewegt, verfälscht, da durch das zurücksetzen auf den korrekten Radius des Planeten praktisch ein stück des gefahrenen Weges verloren geht. (Es könnte sogar sein dass das Schiff dann sogar schneller bewegt als erwartet. Hängt vom Vektor als auch von der Planetengröße ab.)
    Deshalb habe ich den Ansatz mit der Winkelberechnung genommen, da du da haargenau errechnen kannst wie groß der zurückgelegte Weg auf dem Planeten tatsächlich ist.

    Zu dem Problem mit der implementierung:
    Keine Ahnung wieso das Schiff bei minimalsten Werten praktisch ausflippt. Hast du überprüft ob die werte die zu den alpha und beta winkeln addiert werden im Korrekten Bereich liegen?
    Vielleicht übersehe ich da auch was beim System selber?

    Ich nehme mal an dass du kein example hast was das System verwendet, sodass ich mir dies mal anschauen könnte? XD


    /edit:
    Wenn du das raumschiff um einen bestimmten Punkt rotieren möchtest, dann musst du die rotation erst nach der Translation ausführen:

    GML-Quellcode

    1. d3d_transform_set_identity();
    2. d3d_transform_add_translation(2, 0, 0);//schiff wird auf der x-achse um den Wert 2 verschoben.
    3. d3d_transform_add_rotation_z(45);//nun wird das ganze Modell um den Ursprungspunkt im Modell-koordinatensystem rotiert. (0/0/0) Da das schiff vorher um den wert 2 auf der x-achse versetzt wurde, rotiert es sich nun im Kreis.
    4. d3d_model_draw(model_ship, 0, 0, 0, tex_ship);
    5. d3d_transform_set_identity();

  • Doch doch, hätte ich, nur muss ich dann wieder alles zurückbauen XD ich sollte echt mal öfter speichern. Ich lade noch ein example mit deiner implementierung hoch.

    Ich habe jetzt rausgefunden dass ich mit

    GML-Quellcode

    1. d3d_model_draw(model_ship, 0, 0, 0, tex_ship);

    dem hier den offset setzen kann.
    wenn ich statt 0,0,0 meinen Kugelmittelpunkt - x,y,z einsetze dann rotiert mein Schiff mit dem korrekten Radius um die Stelle wo normalerweise das Schiff ist. Ich habs noch nicht raus wie ich es um den eigtl Mittelpunkt rotieren lassen kann.

    ancient-pixel.com
    youtube.com/user/SebastianMerkl <<< ich freu mich über einen Besuch ;)
  • das mit dem Offset bei d3d_model_draw funktioniert auch wenn du davor einfach ein translate verwendest.
    Das ganze system mit dem rotieren und verschieben ist eigentlich ganz einfach wenn man es erstmal verstanden hat.

    Wenn du ein objekt zeichnen möchtest, dass sich einfach rotiert, dann rufst du vor dem draw-befehl einfach ein "d3d_transform_add_rotation()" befehl auf.
    Dadurch wird das objekt (bz.w alle vertexe) am Ursprungspunkt (x=0,y=0,z=0) um die jeweilige achse "rotiert".

    Wenn du nach dem rotieren einen Translate befehl zum verschieben verwendest (oder einfach die koordinaten bei d3d_model_draw einfügst > kommt auf dasselbe hinaus) wird das objekt NACH dem Rotieren auf der jeweiligen Achse verschoben.
    Dadurch rotiert sich das objekt visuell immernoch um den ursprünglichen Koordinatenursprungspunkt. (da die vertexe um den originpunkt 0/0/0 rotiert wurden und erst DANNACH verschoben wurden.)

    Aber:
    Nehmen wir mal an dass wir das objekt erstmals verschieben und dann rotieren. Was passiert dann?
    Nunja, wenn wir das objekt als erstes verschieben, so werden zu allen Vertexen (in einem Internen Koordinatensystem) auf den jeweiligen achsen verschoben.
    Wenn wir so z.B: auf der x-achse den wert 2 hinzufügen, so wird zu allen werten der x-wert 2 dazuaddiert.
    > der ORIGINPUNKT für transformationen entfernt sich somit vom objekt.

    Wenn du nach der verschiebung dann eine Rotation anwendest, so wird das objekt um den Originpunkt (xyz = 0/0/0) rotiert. Da du aber davor die Vertexe auf der x-achse um 2 verschoben hast, befindet sich das Modell (intern) nicht mehr auf dem Modellursprungspunkt 0/0/0 sondern eben 2/0/0.
    Die rotation führt somit dazu, dass das Modell sich wie die Spitze eines uhrzeigers im Kreis rotiert.

  • Genau das habe ich gerade gemacht :) und du hast Recht es bewegt sich schneller als vorgesehen und wenn man 2 Winkel auf einmal ändert dann wird es unkontrolliert schnell. Also ist das nur eine mäßige Lösung, aber es führt auf jedenfall schon mal zur richtigen bewegung so wie ich sie haben möchte. Leider wirft es wie immer auch noch mehr probleme auf wie vorher^^

    Also muss es noch eine andere Lösung geben. ich müsste hinter die Mathematik hinter der Translate funktion kommen oder zu einer guten Lösung mit den cos, sin, winkelbogen funktionen

    ancient-pixel.com
    youtube.com/user/SebastianMerkl <<< ich freu mich über einen Besuch ;)
  • Ach du meine güte, ich habe da was komplett durcheinandergebracht.
    In dem letzten Codeblock habe ich für die Berechnung des winkels die falsche formel verwendet.
    So sollte der code eigentlich ausschauen:

    GML-Quellcode

    1. w= (b*360)/(2*r*pi)//w ist der Winkel um den sich das Schiff auf dem Planeten bewegt.
    2. //b ist die distanz die du zurücklegen möchtest.
    3. //r ist der Radius des planeten.
    4. //bewegung um den winkel wird ausgeführt. (Wie eine Vektorberechnung, nur eben für den Winkel statt für das typische Koordinatensystem.)
    5. alpha+= cos(degtorad(ship_direction)) * w;//ship_direction = blickrichtung des Schiffes auf dem Planeten
    6. beta+= sin(degtorad(ship_direction)) * w;
    7. //cos und sin wird einen Wertebereich von -1 und +1 zurückgeben. Wenn wir das mit dem Winkel multiplizieren, bekommen wir den jeweiligen "translationswinkel" auf der y- und z-achse. (wie bei vektoren.)
    8. //neue position
    9. x= radius * cos(degtorad(beta)) * cos(degtorad(alpha)); //beta = drehung der y-achse
    10. y= radius * cos(degtorad(beta)) * sin(degtorad(alpha));//alpha = drehung der z-achse (direction)
    11. z= radius * sin(degtorad(beta));
    Alles anzeigen


    Würde evtl. die unkontrollierten Bewegungen des Schiffes bei dir erklären.
    /Edit: Hab den Code auch im obrigen Post ausgebessert...

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von LEWA ()

  • Danke für die Überarbeitung, die unontrollierten Bewegungen sind weg, aber mein Schiff bewegt sich nun nurmehr auf oder ab auf der z achse und gar nicht um den planeten herum.

    Ich schick hier mal mein projekt mit. Der Code ist nach dem vielen rumprobieren entsprechent konvulut, also nicht wundern^^ its all over the place!
    Meine anderen Bewegunsansätze aus dem Code rauszulösen könnte schwierig werden, bei bedarf stell ich eine andere Version rein.
    Wenn du das Spiel startest, dann kannst du mit der rechten Maustaste den neuen Orbit festelegn und dich mit WASDQE Pfeiltasten bewegen und bei gedrückter STRG und Mausbewegegung die Kamera ändern.

    Achja, mein Ziel übrigens ist es das das Schiff den angepasst Orbit automatisch fliegt damit man nicht ständig iwelche Tasten drücken muss, das war die Grundidee für den Flug in Kreisbahnen.
    Dateien

    ancient-pixel.com
    youtube.com/user/SebastianMerkl <<< ich freu mich über einen Besuch ;)
  • Oha...
    Hatte es schwer nachzuvollziehen was du da eigentlich machst.^^
    Wieso hast du beispielsweise die Formel zur berechnung des Kreisbogens an der "rotz" variable angewendet und da die werte addiert?
    Oder wo werden die xyz werde des Schiffes denn zum orbitursprungspunkt dazuaddiert?
    (Waren halt Sachen, die mich anfangs etwas verwirrten. ^^)

    GML-Quellcode

    1. x= radius * cos(degtorad(beta)) * cos(degtorad(alpha));

    Wo wird da der aktuelle orbitmittelpunkt dazuadiert um das ganze relativ zu machen? (So funktioniert das System doch, oder? Machst du mit den Koordinaten irgendetwas spezielles?)
    Hab dies im verbesserten example geändert. funtzt auch... hoffe ich zumindest... XD
    Die unterschiedlichen Steuerungsarten die da noch herumlungern machten die sache auch nicht verständlicher. XD

    Hoffe das ist ungefähr das was du dir vorstellst. (Evtl muss die grafische Schiffrotation angepasst werden.)
    W und S ist der Antrieb während A und S das Schiff "dreht" (relativ zum Orbitursprung). (Dabei ging ich davon aus, dass das schiff wie in der top-Down perspektive gesteuert wird. Stell dir vor dass du das Schiff immer von der Top-Down perspektive siehst, wie es um einen Planeten rumfliegt.)
    Beispiel:

    GML-Quellcode

    1. alpha+= cos(degtorad(ship_direction)) * w;//ship_direction = blickrichtung des Schiffes auf dem Planeten

    die Ship_direction ist nicht die direction vom Schiff zum planeten/orbitursprung (glaube zumindest dass du das so gehabt hast), sondern die Richtung des Schiffes auf der "planetenhülse". (damit kannst du praktisch bestimmen, in welcher Richtung der Großkreis verläuft.)
    Dateien

    Dieser Beitrag wurde bereits 6 mal editiert, zuletzt von LEWA ()

  • Ja, wie gesagt, sehr konvulut^^ lauter Leichen der verschiedenen Versuche...

    mit:

    GML-Quellcode

    1. x += new_originx;
    2. y += new_originy;
    3. z += new_originz;


    wird der Punkt nach den Sinus Cosinus berechnungen verschoben. Wenn ich den Punkt nicht verschiebe sieht dein Lösungsansatz auf der Top down map ganz gut aus :) Aber ich sehe mein Schiff nicht mehr obwohl ich es an x,y,z zeichnen lasse. Wenn ich die Verschiebung durchführe lande ich überhaupt irgendwo also er fliegt davon. Und wenn ich eine Pol durchschreite dreht sich die rotz achse meines Schiffes um 180 grad.

    Ich ladt hier mal die Version hoch, wo die bewegung des Schiffs durch art wie ich es drawen lasse korrekt ist, aber die x,y,z Position dabei leider nicht die Position des Schiffes ist.
    Wenn du beim starten auf den nähesten Planeten klickst sodass du einen möglichst nahen Orbit um diesen hast, dann kannst auf allen Kamera ganz gut verfolgen wie sich das Schiff bewegt. Es muss doch möglich sein, das Schiff nicht nur an diesen Positionen die da errechnet werden zu drawen sondern auch springen zu lassen?

    ein bisschen hab ich auch aufgeräumt W und S regeln die Geschwindigkeit und die Pfeiltasten neigen die Kreisbahn um zwei achsen.
    Dateien

    ancient-pixel.com
    youtube.com/user/SebastianMerkl <<< ich freu mich über einen Besuch ;)
  • Hab da jetzt eine halbe Stunde lang rumexperimentiert. XD
    Hab dann die korrekten Koordinaten rausbekommen.
    Hoffe dass ist genau das was du suchst. Allerdings weiss ich jetzt nicht ob bei deiner Methode die Drehung um den Planeten herum so eingebaut wurde wie du es haben möchtest.

    Das einzige was ich geändert habe ist die draw-funktion des schiffes und (glaube) die Parameter die an die funktion übergeben werden.
    Dateien

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von LEWA ()

  • ich fühl mich schon richtig schlecht, dass du dich so sehr ins Zeug legst^^

    Also das Schiff fliegt nun wieder nur auf einer ebene im kreis und kippt die nase ohne dabei die Richtung oder höhe zu ändern bzw die Kreisbahn zu kippen.


    Ich glaube aber ich muss das ganze nochmal komplett von 0 aufbauen, also die Bewegung. Und zwar mit einem ganz anderem Ansatz. Ich hoffe ich werde nicht zu anstrengend. Ich werde auf jedenfall dein jetziges Script mit noch anderen bewegunsarten ausprobieren und mich damit noch mehr spielen! Vielleicht bekomm ich s ja noch hin.

    In 2D ist es so einfach, warum kann das nicht in 3D nur ein bisschen komplizierteer sein anstatt nahezu unmöglich XD

    Spoiler anzeigen
    Nur noch eine Zusammenfassung aller Versuche:
    -Raumschiff dreht sich immer auf der x,y ebene, steigt entlang der z-achse und verringert dabei den kreis auf der x,y ebene
    -Raumschiff dreht sich immer auf der x,y ebene, steigt entlang der z-achse und beschreibt damit eine Spirale, radius bleibt gleich
    -Raumschiff beschreibt durch das draw event die richtige bahn, durch eine ekliptik der kreisbahn, x,y,z bleiben aber in der zweiten dimension auf der x,y ebene


    Spoiler anzeigen
    Ein ganz anderer Ansatz: denn ich denke ich sollte auch einmal alles rauslöschen und doe bewegung von vorne beginnen:
    ich denke ich berechne beta, den winkel an der z-achse, falsch. ich brauche so etwas wie den mittelvektor zwischen x-achse und y-achse sowie dann der z-achse.


    EDIT:
    HEUREKA! Ich habs!!!!

    Also fast^^ solange ich die Tasten gedrückjt halte bewege ich mich mit diesem Code perfekt um eine Kugel mit stabilem Radius und mein Schiff sieht immer in die richtige Richtung ohne unerwartete Drehungen:

    GML-Quellcode

    1. x = x + lengthdir_x(antrieb,rotz) * lengthdir_x(1, roty)
    2. y = y + lengthdir_y(antrieb,rotz) * lengthdir_x(1, roty)
    3. z = z - lengthdir_y(antrieb, roty)
    4. x = x + lengthdir_x(seittrieb,rotz+90) * lengthdir_x(1, roty)
    5. y = y + lengthdir_y(seittrieb,rotz+90) * lengthdir_x(1, roty)
    6. z = z - lengthdir_y(seittrieb, rotx)


    je größer mein speed ist desto größer ist mein radius, wenn ich die rot variablen von meinem Radius abhängig machen bzw beeinflussen lasse sollte ich unterschiedlich schnell auf der selben bahn bleiben können. Also damit sich die kreisbahn nicht verkleinert beim abbremsen. Holy Moly ich hoffe das funktioniert, ich freu mir gerade einen haxen aus

    ancient-pixel.com
    youtube.com/user/SebastianMerkl <<< ich freu mich über einen Besuch ;)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Aku_Ryou ()

  • So halbwegs, ich kann mich jetzt entscheiden ob ich völlig frei fliege also gerade aus und immer der nase nach egal wohin diese zeigt. Wenn ich dann auf stabilen Orbit umschalte rotiere ich in der x,y ebene und kann wenn ich beständig die nase in die höhe ziehe, dreh ich mich auf einem weiteren Kreis der auf dem Orbit steht. Wenn ich die Nase nur ein bisschen in die hähe zeigen lasse dann wird aus der Kreisbahn eine Spirale. Aber ich kreuze nie den Mittelpunkt bzw die Pole des Planeten.
    Hier mal wieder ein Bild zur veranschaulichung:
    *das bild wird noch rein editiert*

    ancient-pixel.com
    youtube.com/user/SebastianMerkl <<< ich freu mich über einen Besuch ;)