Objekt auf Kreisbahn bewegen

[Dirty Oerti]

Ah da liegt das Problem.
Hm...
Es wäre jetzt natürlich kein Problem, deine Objekte per Koordinaten zu bewegen. Wenn du aber zusätzlich Kollisionskontrolle willst ist die Möglichkeit, einfach die Koordinaten zu verändern natürlich nicht mehr gegeben.

Dann wirds etwas komplizierter.

Ich kenn mich jetzt nicht mit dem neuen Bewegungssystem aus, aber ich nehme mal an, es basiert, wie das alte, auf Vektoren. Und wenn ich mich recht entsinne gibt es eine Funktion, um aus 2 Punkten einen Vektor zu errechnen (zur Not schreiben wir halt eine selbst..).

Also machen wir folgendes:

Du hast zu Beginn folgende Situation:

Du weißt den Ort A vom Objekt.
Das soll um Mittelpunkt P kreisen.
Aus Radius R.

Nun kommt ein Tastendruck (z.b. Cursor Right).

Danach soll sich das Objekt nun an Position B befinden.
Die rechntest du wie oben erwähnt aus.

Nun erstellst du einen Vektor von A nach B.
Heißt:

Vektor.X = B.X - A.X
Vektor.Y = B.Y - A.Y

Diesen Vektor benutzt du jetzt, um dein Objekt zu bewegen.

Ich hoff es klappt so.
Bzw ich hoff du verstehst mich

MfG
Daniel

[Kerli]

Da war wohl wer schneller
Naja egal ich hab ja auch was anderes geschrieben:

Kein Problem an die Position des Spielers zu kommen. In dem Fall wäre es "zeiger.x" und "zeiger.y".

Dann ist es eigentlich ganz einfach. Entweder du setzt statt player_speed.x/y die Werte von zeiger.x/y oder du berechnest dir, so wie ich dir vorher gesagt habe, die Bewegungsrichtung, was eigentlich schöner und leichter erweiterbar ist.

Code: Alles auswählen

// Vektor vom Kreismittelpunkt zum Spieler berechnen
vec_radius.x = zeiger.x - mittelpunkt.x;
vec_radius.y = zeiger.y - mittelpunkt.y;

// Den normalisierten Normalvektor berechnen
vec_length = sqrt( vec_radius.x*vec_radius.x + vec_radius.y*vec_radius.y );
vec_normal.x = vec_radius.y / vec_length;
vec_normal.y = vec_radius.x / vec_length;
if( key_cur ) vec_normal.x *= -1; // Falls es sich verkehrt herum dreht einfach x/y vertauschen
if( key_cul ) vec_normal.y *= -1;

// und mit der Geschwindigkeit multipliziert als Bewegungsvektor setzen
player_speed.x = speed * vec_normal.x;
player_speed.y = speed * vec_normal.y;

So in etwa sollte es funktionieren

[The Dust]

Puuuuh Habe versucht eure Lösungsvorschläge umzusetzen aber das Ergebniss ist mehr oder weniger ein Ball der sich in manchmal kryptischen Bahnen fortbewegt oder aber garnichts macht. Fangen wir vorne an :

@Dirty Oerti
Also so sieht mein Code aus wenn ich deinem Lösungsvorschlag folge:

Code: Alles auswählen

while (1)
  {
     key_richtung = false;
     if (key_cur) 
     {
        key_richtung = true;
        winkel = winkel + 1;
      }
     if (key_cul) 
     {
        key_richtung = true;
        winkel = winkel - 1;
     }
     if (key_richtung == true)
     {
        player_pos2.x = camera.x + 100* cos(winkel); //player_pos2 wäre jetzt dein "B"
        player_pos2.y = camera.y + 100* sin(winkel);
        player_speed.x = player_pos2.x - zeiger.x;
        player_speed.y = player_pos2.y - zeiger.y;
      }
     else
     {
        player_speed.x = 0;
        player_speed.y = 0;
     }    
     phent_addtorqueglobal (zeiger, player_speed);
     cam();
     wait (1); 
  }

So, wenn ich nach rechts drücke macht das Objekt einen Kreis aber nicht um die Kamera. Wenn ich nach links drücke bewegt sich der Player in einer Art Ellipse
Jedenfalls vermute ich dass ich da was falsch gemacht habe.
Also es gibt bei Lite-C eine Funktion die zwei Vectoren verrechnet :"vec_sub(vector1,vector2)" Im Manual steht: "Subtracts the second vector from the first, and copies the difference to the first."

@Kerli
Wenn ich statt player_speed.x/y zeiger.x/y einsetze passiert alles mögliche. Das Objekt rotiert bewegt extrem schnell und bleibt in der Welt stecken, ich sehe nichts mehr usw...Also das scheint dem Gamestudio nicht zu gefallen Wenn ich mich nach deinem zweiten Vorschlag richte sieht dass dann so aus bei mir:

Code: Alles auswählen

 while (1)
{ 
     key_richtung = false;
     if (key_cur) 
     {
        key_richtung = true;
        vec_normal.x *= -1;
     }
     if (key_cul) 
     {
        key_richtung = true;
        vec_normal.y *= -1;
     }
     if (key_richtung == true)
     {
              
       //Vektor vom Kreismittelpunkt zum Spieler berechnen
       vec_radius.x = zeiger.x - camera.x;
       vec_radius.y = zeiger.y - camera.y;

       // Den normalisierten Normalvektor berechnen
      vec_length = sqrt( vec_radius.x*vec_radius.x + vec_radius.y*vec_radius.y );
      vec_normal.x = vec_radius.y / vec_length;
      vec_normal.y = vec_radius.x / vec_length;

  // und mit der Geschwindigkeit multipliziert als Bewegungsvektor setzen
      player_speed.x = 100 * vec_normal.x;  //ich habe statt "speed" 100 eingesetzt, ist das ok ?
      player_speed.y = 100  * vec_normal.y;
  }
     else
     {
        player_speed.x = 0;
        player_speed.y = 0;
     } 
    phent_addtorqueglobal (zeiger, player_speed);
     cam();
     wait (1); 
  }

Jetzt bewegt sich der Player, ob ich rechts oder links drücke ist egal, immer in eine Richtung. Ziemlich seltsam.

Also ich hoffe ihr habt noch die Geduld mir zu helfen. Ich denke es fehlt nicht mehr viel, damit mein Ball entgültig um die Kamera zirkelt

[Kerli]

Jetzt bewegt sich der Player, ob ich rechts oder links drücke ist egal, immer in eine Richtung. Ziemlich seltsam.

Das ist auch ganz klar, wie sollte er auch auf einen Tastendruck reagieren, wenn du dann den Wert erst wieder überschreibst. Du musst zuerst den Vektor berechnen und setzen und dann erst 'x' oder 'y' mit '-1' multiplizieren.
Am Besten baust du deine etwas überladenen ifs überhaupt etwas um:

Code: Alles auswählen

while (1)
{
  if( key_cur | key_cul )
  {
    //Vektor vom Kreismittelpunkt zum Spieler berechnen
    vec_radius.x = zeiger.x - camera.x;
    vec_radius.y = zeiger.y - camera.y;

    // Den normalisierten Normalvektor berechnen
    vec_length = sqrt( vec_radius.x*vec_radius.x + vec_radius.y*vec_radius.y );
    vec_normal.x = vec_radius.y / vec_length;
    vec_normal.y = vec_radius.x / vec_length;

    // und mit der Geschwindigkeit multipliziert als Bewegungsvektor setzen
    player_speed.x = 100 * vec_normal.x;  //ich habe statt "speed" 100 eingesetzt, ist das ok ?
    player_speed.y = 100  * vec_normal.y; // hängt davon ab wie schnell der spieler sich bewegen soll ;)

    if( key_cur ) vec_normal.x *= -1; // Bei Bedarf x/y vertauschen
    else            vec_normal.y *= -1;       
  }
  else
  {
    player_speed.x = 0;
    player_speed.y = 0;
  }

  phent_addtorqueglobal (zeiger, player_speed);
  cam();
  wait (1);
}

[The Dust]

[quote="Kerli] Du musst zuerst den Vektor berechnen und setzen und dann erst 'x' oder 'y' mit '-1' multiplizieren[/quote]

Das ist einleuchtend, ich konzentriere mich öfters zuviel auf den Code selber und schau dann nicht mehr auf die Reihenfolge. Aber die Codeänderung bringt keinen merklichen Effekt.

[Kerli]

Aber die Codeänderung bringt keinen merklichen Effekt.

Was tut dein Spieler denn jetzt genau bzw. was nicht?

[The Dust]

Das Objekt macht das gleiche wie vorher, es bewegt sich immer in eine Richtung ob links oder recht. Es bewegt sich in -x -Richtung wenn das hilft.

[Xin]

Das Objekt macht das gleiche wie vorher, es bewegt sich immer in eine Richtung ob links oder recht. Es bewegt sich in -x -Richtung wenn das hilft.

Mir fehlt hier die Kreisberechnung.

Eigentlich verstehe ich gar nicht, was da berechnet wird, sind das alles globale Variablen? Und wenn ja, was wird mit ihnen gemacht?

[Dirty Oerti]

Also den Kreis zu errechnen ist kein Problem. Das geht mit Sinus und Cosinus.

Jetzt mal die Frage:

Was stehen dir für Funktionen zur Verfügung, um deinen Spieler zu bewegen und was für Parameter möchten diese Funktionen haben?

Gibt es eigentlich noch "move" ?

[The Dust]

Also den Kreis zu errechnen ist kein Problem. Das geht mit Sinus und Cosinus.

Jetzt mal die Frage:

Was stehen dir für Funktionen zur Verfügung, um deinen Spieler zu bewegen und was für Parameter möchten diese Funktionen haben?

Gibt es eigentlich noch "move" ?

Das ist im Grunde das Problem. Ich kann nur dieses "phent_addtorqueglobal " benutzen. Die praktischen "move"-Funktionen funktionieren nicht mit Physik. "phent_addtorqueglobal" gibt dem Objekt Drehmoment, mein Ball rollt. Da würde ein direkte Koordinatenänderung eben ein bisschen komisch ausschauen.
Mit Hilfe von x = radius * cos(winkel) usw. haben wir den Ball ja schon zum Kreisen gebracht, jetzt muss er nur mehr gezwungen werden um die Kamera kreisen.