Mehrere gleiche Objekte durch den Raum schicken?

[Ganon]

Hi,

ich will mein kleines Raumschiff mit ein paar Waffen ausstatten. Naja! Ich dachte das wäre ja nicht so schwer nur leider hänge ich gerade.

Wenn ich z.B. einen Laser habe, dann muss ja bei jedem Schuss ein neues Laser-Modell erzeugt werden, damit dieser sich durch den Raum bewegen kann, oder?

Was müsste ich logisch machen, damit die Modelle unabhängig von der Anzahl sind? Also damit ich rumballern kann und jedes Objekt seinen Weg geht.

OpenGL/ANSI C++ (gcc)

Danke!

[Demirug]

Was meinst du mit "Laser-Modell"?

Was du brauchts ist pro Schuss ein neues Object in einer Liste. Und beim Rendern wird dann eben für jedes Objekt in dieser Liste die Geometrie einmal gerendert. Dabei wird dann vorher jedesmal die Matrix entsprechend gesetzt.

[Ganon]

Hi,

mit Laser-Modell meine ich das Modell für den Laser-Strahl. Also das Objekt welches sich durch den Raum bewegt.

Was für eine Liste meinst du? Einen Array?

[Demirug]

Also das Geometrische Modell für den Laser brauchst du nur einmal. Es soll ja immer gleich aussehen.

Ein Array Ginge im Prinzip schon nur hast du dann das Problem das du eine vorher festgelegte maximale Anzahl von Strahlen im Spiel haben kannst.

Eine verkettet Liste wäre da schon besser.

Du solltest dir aber vielleicht einmal ein paar grundsatzliche Gedanken über dein Design machen. Für jede einzelne Sache immer wieder das Gleiche zu machen macht auf Dauer einfach keinen Spass.

Überlege dir also am besten einmal was alles Vorkommen kann und in welchem Verhältniss das alles zueiander steht und wo es gemeinsamkeiten gibt.

[Ganon]

Danke erst mal! Ich werde mir das ganze mal angucken.

[Ganon]

Hi,

Ich habe jetzt mal etwas fertig gemacht. Ich bräuchte aber noch Hilfe beim Löschen von bestimmen Einträgen. Dazu gibt es die Funktion "erase" für einen Vector. Aber ich habe keine Ahnung wie ich das benutzen soll. Die Lösch-Funktion wie sie jetzt ist, ist unbrauchbar, da sie nur den letzen Eintrag löscht.

Sorry, falls ich grobe "Fehler" mache. Das ist meine erste Klasse die ich ohne Lehrer im Rücken geschrieben haben, und die auch funktioniert. *ggg*


// Klasse für den Laser-Schuss
class KSchuss
{
private:
vector<float> XPunkt; // X-Koordinate
vector<float> YPunkt; // Y-Koordinate
vector<float> ZPunkt; // Z-Koordinate
vector<float> XWinkel; // X-Winkel
vector<float> YWinkel; // Y-Winkel
unsigned int Anzahl; // Anzahl der Einträge

public:
KSchuss(); // Konstruktor
~KSchuss(); // Destruktor
void NeuerSchuss(float x, float y, float z, float ywink, float xwink);
void EntferneSchuss();
void ZeichneLaser();
void ErhoeheWerte();
unsigned int LeseAnzahl();
};

KSchuss::KSchuss()
{
KSchuss::Anzahl = 0;
}

KSchuss::~KSchuss()
{
KSchuss::XPunkt.clear();
KSchuss::YPunkt.clear();
KSchuss::ZPunkt.clear();
KSchuss::YWinkel.clear();
KSchuss::XWinkel.clear();
}

void KSchuss::NeuerSchuss(float x, float y, float z, float ywink, float xwink)
{
KSchuss::XPunkt.push_back(x);
KSchuss::YPunkt.push_back(y);
KSchuss::ZPunkt.push_back(z);
KSchuss::YWinkel.push_back(ywink);
KSchuss::XWinkel.push_back(xwink);
KSchuss::Anzahl = KSchuss::Anzahl+1;
}

void KSchuss::EntferneSchuss()
{
KSchuss::XPunkt.pop_back();
KSchuss::YPunkt.pop_back();
KSchuss::ZPunkt.pop_back();
KSchuss::YWinkel.pop_back();
KSchuss::XWinkel.pop_back();
KSchuss::Anzahl = KSchuss::Anzahl-1;
}

void KSchuss::ZeichneLaser()
{
if (KSchuss::Anzahl > 0)
{
glDisable(GL_TEXTURE_2D);
glPushMatrix();
for(unsigned int i=0;i<KSchuss::Anzahl;i++)
{
glPushMatrix();
glTranslatef(-KSchuss::XPunkt[i],-KSchuss::YPunkt[i],-KSchuss::ZPunkt[i]);
glCallList(Laser);
glPopMatrix();
};

if ((KSchuss::XPunkt[0] >= Raumgroesse*2) || (KSchuss::XPunkt[0] <= -Raumgroesse*2))
{
KSchuss::EntferneSchuss(); // Nicht perfekt und völlig falsch hier.
};

glPopMatrix();
glEnable(GL_TEXTURE_2D);
};
}

void KSchuss::ErhoeheWerte()
{
if (KSchuss::Anzahl > 0)
{
for(unsigned int i=0;i<KSchuss::Anzahl;i++)
{
KSchuss::XPunkt[i] -= sin(KSchuss::YWinkel[i]*bog)*AnimaBremse*100.0f;
KSchuss::ZPunkt[i] += cos(KSchuss::YWinkel[i]*bog)*AnimaBremse*100.0f;
};
};
}

unsigned int KSchuss::LeseAnzahl()
{
return KSchuss::Anzahl;
}

//Schussobjekt
KSchuss *Schuss= new KSchuss();

[Ganon]

Hi.

Ich Depp. Hätte ich mir auch eher denken können. War gestern woh doch etwas spät. *ggg*
Naja. Es ist nämlich so das der erste Eintrag im Array immer zuerst den Abbruchswert erreich. Dazu gibt´s ja schon fertiges Zeug. vector.begin().

Jetzt brauche ich nur noch eine Möglichkeit bestimmt Objekte zu löschen. Aber dazu brauche ich erst mal ne Möglichkeit, herrauszufinden wie man Objektkollision feststellen kann. Aber das kommt erst später.

Das Ganze sieht jetzt so aus:


// Klasse für den Laser-Schuss
class KSchuss
{
private:
vector<float> XPunkt; // X-Koordinate
vector<float> YPunkt; // Y-Koordinate
vector<float> ZPunkt; // Z-Koordinate
vector<float> XWinkel; // X-Winkel
vector<float> YWinkel; // Y-Winkel
vector<float> Abbruch; // Abbruch-Variable
unsigned int Anzahl; // Anzahl der Einträge

public:
KSchuss(); // Konstruktor
~KSchuss(); // Destruktor
void NeuerSchuss(float x, float y, float z, float ywink, float xwink);
void EntferneSchuss();
void ZeichneLaser();
void ErhoeheWerte();
unsigned int LeseAnzahl();
};

KSchuss::KSchuss()
{
KSchuss::Anzahl = 0;
}

KSchuss::~KSchuss()
{
KSchuss::XPunkt.clear();
KSchuss::YPunkt.clear();
KSchuss::ZPunkt.clear();
KSchuss::YWinkel.clear();
KSchuss::XWinkel.clear();
KSchuss::Abbruch.clear();
}

void KSchuss::NeuerSchuss(float x, float y, float z, float ywink, float xwink)
{
KSchuss::XPunkt.push_back(x);
KSchuss::YPunkt.push_back(y);
KSchuss::ZPunkt.push_back(z);
KSchuss::YWinkel.push_back(ywink);
KSchuss::XWinkel.push_back(xwink);
KSchuss::Abbruch.push_back(0.0f);
KSchuss::Anzahl = KSchuss::Anzahl+1;
}

void KSchuss::EntferneSchuss()
{
}

void KSchuss::ZeichneLaser()
{
if (KSchuss::Anzahl > 0)
{
glDisable(GL_TEXTURE_2D);
glPushMatrix();
for(unsigned int i=0;i<KSchuss::Anzahl;i++)
{
glPushMatrix();
glTranslatef(-KSchuss::XPunkt[i],-KSchuss::YPunkt[i],-KSchuss::ZPunkt[i]);
glCallList(Laser);
glPopMatrix();
};

if (KSchuss::Abbruch[0] > (Raumgroesse*4))
{
KSchuss::XPunkt.erase(XPunkt.begin());
KSchuss::YPunkt.erase(YPunkt.begin());
KSchuss::ZPunkt.erase(ZPunkt.begin());
KSchuss::YWinkel.erase(YWinkel.begin());
KSchuss::XWinkel.erase(XWinkel.begin());
KSchuss::Abbruch.erase(Abbruch.begin());
KSchuss::Anzahl = KSchuss::Anzahl-1;
};
glPopMatrix();
glEnable(GL_TEXTURE_2D);
};
}

void KSchuss::ErhoeheWerte()
{
if (KSchuss::Anzahl > 0)
{
for(unsigned int i=0;i<KSchuss::Anzahl;i++)
{
KSchuss::XPunkt[i] -= sin(KSchuss::YWinkel[i]*bog)*AnimaBremse*100.0f;
KSchuss::ZPunkt[i] += cos(KSchuss::YWinkel[i]*bog)*AnimaBremse*100.0f;
KSchuss::Abbruch[i] += AnimaBremse*10.0f;
};
};
}

unsigned int KSchuss::LeseAnzahl()
{
return KSchuss::Anzahl;
}

//Schussobjekt
KSchuss *Schuss= new KSchuss();