Lenkrakete

Vielen Dank für die schnelle Antwort.

Ja ich meinte, die Punkte auf der Verbindungsgerade.
Ich schau mir das mal genauer an und versuch es mal umzusetzen,
ich meld mich dann wieder.
Vielen Dank

Was ich noch nicht ganz verstehe ist die Sacht mit dem vRak.

Betrag der Geschindigkeit im Sinne von
Summe, also xRak + yRak?

Ich hab gelsen, dass man die Norm eines Vektors auch als Betrag bezeichnet, aber dieses Thema wurde im Unterricht noch nicht behandelt, sprich ich weiß nichts darüber.

Könntest du vRak nochmal näher definieren?

An sonsten ist mir alles klar geworden, nochmal vielen Dank.

Nein, für die Gesamtgeschwindigkeit müsstest du den Satz von Pythagoras verwenden, also vRat²=xRak²+yRak²

Nexus

Nico12 schrieb:

Ich hab gelsen, dass man die Norm eines Vektors auch als Betrag bezeichnet, aber dieses Thema wurde im Unterricht noch nicht behandelt, sprich ich weiß nichts darüber.

Das habe ich gemeint. Wenn du einen Vektor (x,y) hast, ist dessen Betrag die Länge des Vektors, also die Wurzel aus x^2+y2 (siehe auch Wikipedia).

vRak soll dabei eine von dir festgelegte Grösse sein, die aussagt, wie schnell sich die Rakete fortbewegt. Als Einheit musst du dabei irgendetwas Sinnvolles festlegen, wie Pixel pro Frame oder sowas.

Ok, vielen Dank,
ich probiers mal aus.

Ich bins, nochmal,
ich habs jetzt mal ausprobiert, aber ich bekomme es einfach nicht hin.
Ich hab mal einen Teil der Funktion gepostet, vllt wisst ihr ja weiter,
ich hab wohl noch nicht alles verstanden, egal welchen Wert ich für vRak nehme, entweder wird die Rakete garnicht abgebildetet bzw ausserhalt des Sichtfelds oder sie bewegt sich nicht und bleibt an ihrer Startposition.

//player == Flugzeug
//en == enemy
if(en->rocket_fire == 1)
{
	float winkel = atan2( (player->y - en->rocket_y),         
                              (player->x - en->rocket_x) );

	en->rocket_xspeed = vRak * cos(winkel);
	en->rocket_yspeed = vRak * sin(winkel);

        if(player->x < en->x)
        {
	     en->rocket_x -= en->rocket_xspeed;
	     en->rocket_y -= en->rocket_yspeed;
        }else
        {         
         en->rocket_x += en->rocket_xspeed;
	     en->rocket_y += en->rocket_yspeed;
        }

        //scroll routine (horizontal scrolling game)
	    en->rocket_x -=STEP;

//Rakete auf dem Buffer abbilden
pivot_scaled_sprite(buffer, enemy_rocket_b , en->rocket_x, en->rocket_y, 
                    0, 0, ftofix(en->rocket_angle), ftofix(en->rocket_scale));

}

Nexus

Das If-Else ist nicht nötig, da Sinus und Cosinus auch negative Werte liefern können und somit alle Richtungen abgedeckt sind. Addiere die Geschwindigkeit immer zur Position, ohne Fallunterscheidung.

Wenn die Y-Achse deines Koordinatensystems nach unten zeigt, nimm -sin(winkel) statt sin(winkel) . Probier am besten ein wenig aus.

Ich weiss zwar nicht ob es noch aktuell ist, hatte bis eben in etwa das gleiche problem (bin noch blutiger anfänger).
Auf folgende Lösung bin ich gekommen.

const double PI = 3.14159265;
const double RadToDeg = 180 / PI;
const double DegToRad = PI / 180;

dreieck_a = position_ist_x-position_soll_x;
dreieck_b = position_ist_y-position_soll_y;
dreieck_c = sqrt (pow (dreieck_a,2) + pow (dreieck_b,2));
winkel_alpha = asin (dreieck_a / dreieck_c )*RadToDeg;
winkel_beta = 90 - winkel_alpha;
dreieck_c = speed * time;
dreieck_a = dreieck_c * cos(winkel_beta*DegToRad);
dreieck_b = sqrt (pow(dreieck_c,2) - pow(dreieck_a,2));
position_ist_x = ceil(position_ist_x - dreieck_a);
position_ist_y = ceil(position_ist_y - dreieck_b);

Evtl. konnte ich ja helfen.

Fellhuhn

Warum nicht einfach so? (wenn du schon Allegro benutzt...)

float player_x, player_y; // irgendwo von dir festgelegt
  float rakete_x, rakete_y; // aktuelle position oder raketenwerfer position
  float rakete_speed; // speed der rakete in pixeln

  float dist_x, dist_y, dist_z;
  dist_x = player_x - rakete_x;
  dist_y = player_y - rakete_y;
  dist_z = 0;

  normalize_vector_f(&dist_x, &dist_y, &dist_z);
  dist_x *= rakete_speed;
  dist_y *= rakete_speed;

  rakete_x += dist_x;
  rakete_y += dist_y;

EDIT:

Pi ist übrigens als M_PI in <cmath> definiert.

Nexus

Fellhuhn schrieb:

Pi ist übrigens als M_PI in <cmath> definiert.

Leider ist M_PI weder in C noch in C++ standardisiert und somit nicht portabel.

Phoemuex

Nexus schrieb:

Fellhuhn schrieb:

Pi ist übrigens als M_PI in <cmath> definiert.

Leider ist M_PI weder in C noch in C++ standardisiert und somit nicht portabel.

Man kann ja immer noch acos(1)*2 verwenden

Felix

Nexus

Phoemuex schrieb:

Man kann ja immer noch acos(1)*2 verwenden

Null? Dann ist ja sogar sqrt(10.f) noch genauer.

Phoemuex

Nexus schrieb:

Phoemuex schrieb:

Man kann ja immer noch acos(1)*2 verwenden

Null? Dann ist ja sogar sqrt(10.f) noch genauer.

Ups , ich meinte natürlich asin(1)*2