Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Lenkraketen

  • 1
  • 2

Werbeanzeige

Unknown

Treue Seele

  • »Unknown« ist der Autor dieses Themas

Beiträge: 201

  • Private Nachricht senden

11

28.06.2009, 15:28

Tach,

habe das jetzt so verstanden :

r1 und r2 sind vektoren.
v1 ist nen skalar.

d1 ist dann r2 - r1.

Jetzt schreibst du :

"der beiden vektoren d1 und v1".

Ist v1 nicht ein Skalar ?

Bin bisschen durcheinander :/

Wieso funktioniert den meine Methode net :(

lg

K-Bal

Alter Hase

Beiträge: 703

Wohnort: Aachen

Beruf: Student (Elektrotechnik, Technische Informatik)

  • Private Nachricht senden

12

28.06.2009, 15:58

v1 ist auch ein Vektor, die Geschwindigkeit hat ja eine Richtung.
www.myspace.com/readytorock
www.facebook.com/PENCILCASE.MUSIC

physX

Treue Seele

Beiträge: 119

Wohnort: Dresden

  • Private Nachricht senden

13

28.06.2009, 17:17

ok, ich hab mal deinen code kommentiert umgeschrieben...

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

/* geschwindigkeitsvektor v besteht hier aus der komponente speedx und speedy

float speed = 1;
    float speedx = cos(m_rot)*speed;
    float speedy = sin(m_rot)*speed;
// ich nehme an m_rot soll der aktuellen drehung der Rakete entsprechen

   float d1 = sqrt(pow(m_targetX-m_xPos,2)+pow(m_targetY-m_yPos,2));
// wenn m_targetX/m_targetY den Zielkoordinaten und m_xPos/m_yPos 

// den Raketen Koordinaten entspricht, dann ist das genau der Abstand 

// zwischen den beiden.

  
//abstandsvektor zwischen rakete und ziel:

   float d1X=m_xPos-m_targetX;
   float d1Y=m_yPos-m_targetY;

   float laengeV1= sqrt(speedx*speedx+speedy*speedy) // =1 in deinem speziellen Fall;

    float deg = acos((d1X*speedx+d1Y*speedy)/(d1*laengeV1)); // das ist dann der winkel zwischen dem geschwindigkeitsvektor der rakete und dem vektor von rakete zu ziel


    m_xPos += speedx; //*time; z.B. zeit zwischen 2 frames // hier solltest du später mal noch die Zeit mit einbauen, da eigentlich x= vx*dt + x0; y=vy*dt + y0 gilt;

    m_yPos += speedy; //*time;

// also ort=aktueller ort + geschwindigkeit * vergangener Zeit


// in der abfrage rechnest du 180/360*2 was = 1 entspricht 

// wenn dein m_rot schon den winkel in rad angibt, brauchst auch nix umrechnen; die umrechnung bei dir ist auch so nicht richtig 

// also einfach


m_rot+=deg;


ok, ich hoffe ich hab jetzt selber in der eile keinen fehler eingebaut, aber das prinzip sollte so funktionieren.
Gruss

Unknown

Treue Seele

  • »Unknown« ist der Autor dieses Themas

Beiträge: 201

  • Private Nachricht senden

14

28.06.2009, 19:22

Tach,

hab das Problem anders behoben.
Hab einfach die falsche Formel benutzt ^^
Habs jetzt mit Kosinussatz gemacht.

danke

Unknown

Treue Seele

  • »Unknown« ist der Autor dieses Themas

Beiträge: 201

  • Private Nachricht senden

15

29.06.2009, 19:28

Tach,

hab jetz den Winkel rausbekommen.
Aber ich weiß nicht ob er nach link oder rechts lenken soll, immer nur die zahlen von 0 bis pi ausgibt, egal ob target oben oder unten ist.

Hier der relevante Code :

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

void cplayer::update(float vx, float vy)
{
    float speed = 4;
    float tempx = cos(rot)*speed;
    float tempy = sin(rot)*speed;

    float lineB = distance(vx,vy,x,y);
    float lineA = distance(vx,vy,x+tempx,y+tempy);
    
    float deg = innerRad(lineA, lineB, speed); // hier von 0 bis pi


    if(deg <= DegToRad(2.0f))
    {
        rot+= deg;
    }
    else if(deg >= 3.1415f)
    {
        rot+= DegToRad(2.0f);
    }
    else if(deg <= 3.1415f)
    {
        rot-= DegToRad(2.0f);
    }

    x += tempx;
    y += tempy;
}


C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#define pi 3.1415926f

inline float DegToRad(float deg)
{
    return 2.0f*pi*(deg/360.0f);
}

inline float distance(float x1, float y1, float x2, float y2)
{
    return sqrt(pow(x1-x2,2)+pow(y1-y2,2));
}

inline float innerRad(float lineA, float lineB, float lineC)
{
    return acos( ( pow(lineB,2)+pow(lineC,2)-pow(lineA,2) )/ (2*lineB*lineC ) );
}


lg

physX

Treue Seele

Beiträge: 119

Wohnort: Dresden

  • Private Nachricht senden

16

29.06.2009, 20:08

hallo, warum prüfst du nicht einfach ob die x-koordinate deiner rakete rechts oder links von der x-koordinate deines ziels liegt, dann weisst du direkt in welche richtung du drehen musst.

also sowas wie

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8

if (xRakete < xZiel)
{ 
  m_rot+=deg;
}
else if (xRakete > xZiel)
{
  m_rot-=deg;
}

Unknown

Treue Seele

  • »Unknown« ist der Autor dieses Themas

Beiträge: 201

  • Private Nachricht senden

17

29.06.2009, 20:33

Das ist doch in ganz speziellen Stellen falsch.

bin weiter für ideen offen.

lg

SirForce

Alter Hase

Beiträge: 802

Wohnort: Süddeutschland

  • Private Nachricht senden

18

29.06.2009, 21:12

Zitat von »"physX"«

hallo, warum prüfst du nicht einfach ob die x-koordinate deiner rakete rechts oder links von der x-koordinate deines ziels liegt, dann weisst du direkt in welche richtung du drehen musst.

also sowas wie

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8

if (xRakete < xZiel)
{ 
  m_rot+=deg;
}
else if (xRakete > xZiel)
{
  m_rot-=deg;
}


Dafür müsstest du aber auch wissen in welchem Winkel die Rakete neben dem Ziel liegt. Und dafür brauchst du dann halt wieder die Trigonometrie.
Nichts behindert so sehr die Entwicklung der Intelligenz wie ihre vollständige Abwesenheit.

Michail Genin

physX

Treue Seele

Beiträge: 119

Wohnort: Dresden

  • Private Nachricht senden

19

29.06.2009, 22:31

da habt ihr natuerlich recht... also musste es doch über vektoren lösen ;)

Gruss

Werbeanzeige

  • 1
  • 2