[Anfänger] Fragen zur Programmierung mit Klassen

volkard

Vielleicht das hier?

vector<cCharakter*> dieGegner;//Sorry, Speicherloch vorprogrammiert. Läßt sich aber besser suchen. 
//Speicherloch dann wegmachen mit ptr-Container. Erstmal hinkriegen, schlage ich vor. 

//je nach Gusto
dieGewgner.push_back(new cCharakter("Rudi Rüssel",70,5));
dieGewgner.push_back(new cCharakter("Klaus & Klaus",375,600));
dieGewgner.push_back(new cCharakter("Vlad der Pfähler",1720,315));
for(int i=0;i<20;++i)
   dieGewgner.push_back(new cCharakter("ein streunender Hund",120+rand()%50,30+rand()%10));
if(rand()%100==1)//Zu nur 1% Wahrscheinlichkeit
   dieGewgner.push_back(new cCharakter("Esmeralda Wetterwachs",10000,10000));//Die alte hat nen guten Tag. Und Du bist tot. 
else
   dieGewgner.push_back(new cCharakter("Esmeralda Wetterwachs",1200,1000));//Nicht so schlimm wie Vlad, aber schon kernig.

//
Gegner[2].InitiativeWuerfeln();

cooky451

thuering schrieb:

Klasse cCharakter.

Solche Namen sind recht unbeliebt, nenne deine Klassen ruhig Charakter.

Zu deinem Problem:
Es gibt verschiedenen Möglichkeiten so "dynamische" Objekte zu erstellen. (Viele Standardcontainer, new).
Die Einfachste dürfte sein std::vector.

Ich denke mal die für dich richtige Methode dürfte so etwas in der Art sein.

class Character
{
  // Eigenschaften die jeder Charakter hat
  // Methoden (u.U. virtual) die jeder Charakter hat
};

class Player : public Character
{
};

class Enemy : public Character
{
};

class EnemieManager
{
  std::vector<Enemy> enemies;
public:
  void addEnemie(Enemy enemy)
  {
    enemies.push_back(enemy);
  }
  void handleEvent(IrgendEineEventKlasse event)
  {
    for (std::vector<Enemy>::iterator i = enemies.begin();
      i != enemies.end(); ++i)
    {
      i->handleEvent(event);
    }
  }
};

Eventuell noch mit pure virtual + Zeigern auf Basisklasse im Vektor.

Edit:
Ich wusste doch, dass irgendetwas nicht stimmt.

Edit2:
Als Rechtschreibefreak würde ich mich aber ganz und gar nicht bezeichnen.

wxSkip

@cooky451: Dir (als Rechtschreibfreak, wenn ich mich richtig erinnere ) ist hoffentlich bewusst, dass es im Singular "Enemy" und nicht "Enemie" heißt.

thuering

Vielen Dank für die sehr schnellen Antworten, ich werde mich dann mal ausgiebig mit Containern & Vektoren beschäftigen.

Ich habe hier Heiko Kalistas Buch "C++ für Spieleprogrammierer", Videokurs Video2Brain "Visual C++ 2008" und den Galileo Computing Videokurs "C++ programmieren". Empfiehlt ihr davon etwas ausdrücklich?

Ist "boost" eine Standard-Library?

cooky451

thuering schrieb:

Vielen Dank für die sehr schnellen Antworten, ich werde mich dann mal ausgiebig mit Containern & Vektoren beschäftigen.

Das ist eine gute Idee, da das zentrale Konzepte sind. Iteratoren kannst du dir dann gleich mit angucken.
(Und Vererbung auch, ist im Endeffekt alles nicht so kompliziert, wie es anfangs aussieht.)

thuering schrieb:

Ich habe hier Heiko Kalistas Buch "C++ für Spieleprogrammierer", Videokurs Video2Brain "Visual C++ 2008" und den Galileo Computing Videokurs "C++ programmieren". Empfiehlt ihr davon etwas ausdrücklich?

Ne. Aber ich würde auch sonst nicht viel ausdrücklich empfehlen.

thuering schrieb:

Ist "boost" eine Standard-Library?

Nein. boost ist eine sehr umfangreiche und gute externe Bibliothek, hat aber mit der Standardbibliothek nicht viel zu tun. boost kann später hilfreich sein, aber ich würde mich erst mal mit den Standardkonzepten vertraut machen.

wxSkip

cooky451 schrieb:

thuering schrieb:

Ist "boost" eine Standard-Library?

Nein. boost ist eine sehr umfangreiche und gute externe Bibliothek, hat aber mit der Standardbibliothek nicht viel zu tun. boost kann später hilfreich sein, aber ich würde mich erst mal mit den Standardkonzepten vertraut machen.

Viele Leute hier benutzen Boost, als hätte es jeder einigermaßen gute Programmierer installiert und auch das C++-Kommitee scheint die Library nicht schlecht zu finden und hat Teile davon in die neue Standardlibrary von C++11 übernommen.

volkard

thuering schrieb:

Ich habe hier Heiko Kalistas Buch "C++ für Spieleprogrammierer", Videokurs Video2Brain "Visual C++ 2008" und den Galileo Computing Videokurs "C++ programmieren". Empfiehlt ihr davon etwas ausdrücklich?

Ich kenne alle drei nicht. Würde aus der Entfernung aber alle drei ablehnen.

TyRoXx

cooky451 schrieb:

thuering schrieb:

Ist "boost" eine Standard-Library?

Nein. boost ist eine sehr umfangreiche und gute externe Bibliothek, hat aber mit der Standardbibliothek nicht viel zu tun. boost kann später hilfreich sein, aber ich würde mich erst mal mit den Standardkonzepten vertraut machen.

In der Tat hat Boost sogar viel mit der Standardbibliothek zu tun. Ursprünglich war das die Spielwiese für Erweiterungen von std und in den aktuellen Standard wurden viele nützliche Dinge aus Boost übernommen. Für Netzwerk- oder Dateisystemkram gilt Boost in Ermangelung von Alternativen für viele als Standard. Ohne Boost könnte ich mit C++ nicht arbeiten, weil erst Konstrukte wie shared_ptr und ptr_vector die manuelle Speicherverwaltung benutzbar machen. Ähnliches gilt für bind + function .

volkard

TyRoXx schrieb:

Ohne Boost könnte ich mit C++ nicht arbeiten, weil erst Konstrukte wie shared_ptr und ptr_vector die manuelle Speicherverwaltung benutzbar machen. Ähnliches gilt für bind + function .

Ich kann ohne boost arbeiten.

wxSkip

volkard schrieb:

TyRoXx schrieb:

Ohne Boost könnte ich mit C++ nicht arbeiten, weil erst Konstrukte wie shared_ptr und ptr_vector die manuelle Speicherverwaltung benutzbar machen. Ähnliches gilt für bind + function .

Ich kann ohne boost arbeiten.

Ich kann auch (noch) ohne boost arbeiten, aber ich hab ja einen Großteil von C++11.

thuering schrieb:

Vielen Dank für die sehr schnellen Antworten, ich werde mich dann mal ausgiebig mit Containern & Vektoren beschäftigen.

Ich habe hier Heiko Kalistas Buch "C++ für Spieleprogrammierer", Videokurs Video2Brain "Visual C++ 2008" und den Galileo Computing Videokurs "C++ programmieren". Empfiehlt ihr davon etwas ausdrücklich?

Das Buch von Kalista ist nicht schlecht, wenn ich es nicht verwechsle. Es ist zwar nicht so umfangreich/genau wie z.B. "C++ Primer", aber spannender, weil man ja sozusagen auf ein Spiel hinarbeitet.

thuering

Hallo,
nun habe ich schon ein bißchen über Container, Vektoren, Listen und Iteratoren gelesen. Aber vielleicht habt ihr trotzdem noch einen kleinen Hinweis für mich?

Da wäre die Klasse Charakter mit den in main() erzeugten Objekten Spieler
Gegner0001
Gegner0002
Gegner0003
Alle besitzen die Membervariablen (ist dass die richtige Bezeichnung dafür?)
*int ******.Initiative

Diese Initiative wird mittels Funktion (fInitiative()) per Zufall ermittelt. Jetzt möchte ich, dass alle Objekte der Klasse Charakter die Funktion fInitiative() aufrufen, damit bei allen Objekten die int Initiative gesetzt wird. Das bekomme ich sicherlich noch selber hin, am besten wohl mit einem for_each.

Jetzt aber, möchte ich, dass die Objekte, beginnend mit dem, dass den niedrigsten int Initiative Wert hat, alle nacheinander die Funktion fAttack() ausführen. Soll ich da was mit sort() aus der STL machen? Wenn ja, wie soll ich da vorgehen?

Vielen Dank, auch für das, was ihr hier alle schon geschrieben und geholfen habt!

wx++

Ja, du solltest std::sort() verwenden.
Dafür könntest du den Vergleichsoperator für deine Charaktere überladen, aber ich weiß nicht, ob das Sinn macht.
Vermutlich besser ist, den dritten Parameter von sort() zu nutzen, nämlich ein Funktionsobjekt, dass für zwei zu vergleichende Objekte entscheidet, welches kleiner ist.

Das sähe in etwa so aus:

struct vergleiche_initiativen : public std::binary_function<Charakter, Charakter, bool>
{
    bool operator()(const Charakter& c1, const Charakter& c2) const {return t1.initiative < t2.initiative;}
};

cooky451

Wird die Initiative jede Runde neu gesetzt?
Was möchtest du machen, falls zwei Charaktere die gleiche Initiative haben?

thuering

Ja, es gibt jede Runde einen neuen Initiative-Wurf. Ich denke dabei an eine Do-While-Schleife, bis Spieler oder alle Gegner HP <= 0 haben.

Wegen der Initiative: Ich hatte mir überlegt, das vielleicht eine Art Zähler durchläuft, der die momentane Initiative-Zahl beinhaltet. Erst wenn alle Charaktere die momentane Aktion der jeweiligen Initiative (z.B. Spieler, Gegner0001 und Gegner0002 haben alle Initiative 5) abgeschlossen haben, wird erst geprüft, ob jemand durch die Aktionen gestorben ist. Dann kommen die Charaktere dran, die Initiative 6 oder höher haben.
Spieltechnisch gesehen entspricht das zumindest am ehesten dem originalen AD&D-Regelwerk http://en.wikipedia.org/wiki/Advanced_Dungeons_%26_Dragons_2nd_edition#Advanced_Dungeons_.26_Dragons, auf welches ich mich teilweise stützen möchte.

cooky451

Erst wenn alle Charaktere die momentane Aktion der jeweiligen Initiative (z.B. Spieler, Gegner0001 und Gegner0002 haben alle Initiative 5) abgeschlossen haben, wird erst geprüft, ob jemand durch die Aktionen gestorben ist. Dann kommen die Charaktere dran, die Initiative 6 oder höher haben.

In rundenbasierten Spielen würde ich eine Gleichzeitigkeit eher vermeiden wollen, das kann sonst zu bizarren Situationen führen. (Wobei das halt dein Bier ist. :))
Meine Idee wäre so etwas:

class Character
{
  int initiative_;
public:
  Character()
    : initiative_(newRound())
  {}
  void newRound()
  {
    initiative_ = irgendwasZufaelliges();
  }
  //friend bool compareInitiative(const Character& a, const Character& b)
  //{
  //  return a.initiative_ < b.initiative_;
  //}
}; 

class Manager
{
  std::vector<Character> characters;
public:
  void addEnemie(Character character)
  {
    enemies.push_back(character);
  }
  void attack()
  {
    for (unsigned int initiative = 1; initiative < 101; ++initiative)
    {
      std::vector<std::vector<Character>::iterator> round;
      for (std::vector<Character>::iterator i = characters.begin();
        i != characters.end(); ++i)
      {
        if (i->initiative() == initiative)
          round.push_back(i);
      }
      std::random_shuffle(round.begin(), round.end());
      for (std::vector<std::vector<Character>::iterator>::const_iterator i = round.begin(); // langsam wirds ironisch..
        i != round.end(); ++i)
      {
        (*i)->attack();
      }
    }
  }
  void newRound()
  {
    for (std::vector<Enemy>::iterator i = enemies.begin();
      i != enemies.end(); ++i)
    {
      i->newRound(); // Jeder Charakter setzt seine eigene Initiative
    }
    //std::sort(enemies.begin(), enemies.end(), compareInitiative);
  }
}

Ob sort() laufzeittechnisch Sinn macht, kann ja jemand anders ausrechnen, obwohl das bei solche Anwendungen eh völlig egal ist.

Edit:
In dem "original"-Spiel gibt es Gleichzeitigkeit?
Wo genau liest du das, konnte es da nicht finden..

314159265358979

cooky451 schrieb:

Vielleicht macht ein std::vector<Character&> round; mehr Sinn.

In einen vector kann man keine Referenzen stecken

cooky451

314159265358979 schrieb:

cooky451 schrieb:

Vielleicht macht ein std::vector<Character&> round; mehr Sinn.

In einen vector kann man keine Referenzen stecken

Hmja, ein resize() dürfte dann schwer fallen.

thuering

cooky451 schrieb:

In dem "original"-Spiel gibt es Gleichzeitigkeit?
Wo genau liest du das, konnte es da nicht finden..

Du hast recht, das steht gar nicht in dem Wiki-Artikel. Aber es gibt Gleichzeitigkeit in AD&D (siehe http://www.ebay.de/itm/270813851609?ssPageName=STRK:MEWAX:IT&_trksid=p3984.m1438.l2649 ) - wir reden hier aber auch von einem Pen&Paper-Spiel. Ich meine aber sogar, dass selbst in der bekannten PC-Umsetzung "Baldurs Gate" die Gleichzeitigkeit umgesetzt wird.
Warum auch nicht: Während ich dem fiesen Ork ein Schwert in den Bauch bohre, schlägt er mir noch mit seinem Streitkolben den Schädel ein...
Das werde ich dann auch regelgetreu umsetzen.

Ich danke für die vielen Vorschläge. Ich selber habe mir natürlich auch noch weiter Gedanken gemacht. Ich glaube, ich werde es erstmal mit einer einfachen for-Schleife versuchen, die jeden Initiative-Wert durchgeht und dann jeden drankommen lässt.
Ich denke auch, ich werde meine Lösung dann hier posten.

DocShoe

Du könntest das Problem der Gleichzeitig damit lösen, dass du alle Charaktere mit gleichem Initiativwert in einen Vektor steckst. Damit hast du mehrere Vektoren, die du dann noch nach ihrem Initiativwert sortieren musst. Glücklicherweise kann man std::map genau dafür verwenden. std::map realisiert eine Zuordnung von Initiative auf einen Vektor mit Charakteren, die diesen Initiativwert besitzen. Bei dieser Zuordnung spricht man von Schlüssel/Wertepaaren, der Schlüssel ist die Initiative, der Werte ein Vektor von Charakteren. std::map hat das Standardverhalten, dass sie ihre Schlüssel/Wertepaare aufsteigend nach dem Schlüssel sortiert, d.h. beim Durchlaufen der std::map werden Schlüssel/Wertepaare mit dem kleineren Schlüssel zuerst behandelt. Da die Charakterobjekte während des Kampfes verändert werden müssen enthält die Tabelle Zeiger auf die Original Charakterobjekte. Leider verschlechtert das die Lesbarkeit des Quelltextes etwas .

Bsp:

Schlüssel (Initiative) | Werte (Vektor von Charakteren und Monstern)
-----------------------+--------------------------------------------
        1              | [Monster1, Monster4, Charakter3]
        2              | [Monster2]
        3              | [Monster5, Charakter1, Charakter2]
        4              | [Charakter4]
        5              | [Monster6]
        6              | [Monster3, Charakter5]
-----------------------+--------------------------------------------

Um eine Kampfrunde durchzuführen muss diese Tabelle nun von hinten nach vorne abgearbeitet werden, damit die Beteiligten in der Reihenfolge ihrer Initiative handeln können. Charaktere dürfen nur dann angreifen, wenn sie zum Zeitpunkt, an dem sie handeln dürfen, noch handlungsfähig sind. Ein Charakter A mit Initiative 3 könnte ja von Charakter B mit Initiative 5 getötet worden sein, bevor Charakter A an der Reihe war. Dazu wird vor dem Angriff geprüft, ob der aktuelle Charakter überhaupt handlungsfähig ist.

#include <map>
#include <vector>

using namespace std;

typedef vector<Charakter> CharVector;
typedef vector<Charakter*> CharPtrVector;
typedef map<int,CharPtrvector> InitiativeCharTabelle;

bool kann_handeln( const Charakter& Char )
{
   return Char.Lebenspunkte > 0;
}

InitiativeCharTabelle erstelle_rangfolge( CharVector& v )
{
   InitiativeCharTabelle RangFolge;

   for( CharVector::iterator i = v.begin(); i != v.end(); ++i )
   {
      // Initiativwurf für den aktuellen Charakter
      int Initiative = (rand() % 6) +1; // oder sonstwie

      // Alle Charaktere mit gleicher Initiative in einem Vektor ablegen
      // Die folgende Zeile nutzt eine Eigenheit von std::map aus:
      // Der Indexoperator[s] liefert das Wertobjekt zum Schlüssel s zurück. 
      // Wenn für den Schlüssel s kein solches Objekt existiert wird ein neues
      // konstruiert und zurückgegeben. Beim ersten Zugriff RangFolge[s] wird 
      // also ein neues CharPtrVector Objekt erzeugt und zurückgegeben. Damit
      // wird sichergestellt, dass der Zugriff über den Indexoperator immer
      // ein gültiges Objekt zurückgibt.
      // *i dereferenziert den Iterator und liefert damit das Charakterobjekt
      // zurück. &(*i) ist also die Adresse des Charakterobjekts und wird in
      // der Tabelle der Rangfolge abgelegt.
      RangFolge[Initiative].push_back( & (*i) );
   }
   return RangFolge;
}

void fuehre_kampfrunde_durch( InitiativeCharTabelle& RangFolge )
{
   // Tabelle von hinten nach vorne durchlaufen, damit Charaktere mit hoher
   // Initiative zuerst behandelt werden
   for( InitiativeCharTabelle::reverse_iterator i = RangFolge.rbegin();
        i != RangFolge.rend(); ++i )
   {
      // der Iterator einer std::map besteht aus std::pair, in diesem Fall
      // aus std::pair<const int, CharPtrVector>.
      // Zur Übersichtlichkeit eine lokale Variable benutzen
      CharPtrVector& v = i->second;

      // alle Charaktere des aktuellen Vektors behandeln
      for( CharPtrVector::iterator c = v.begin(); c != v.end(); ++c )
      {
         // Vektor aller handlungsfähigen Charaktere bilden. Das löst das 
         // Problem, wenn ein Charakter einen anderen Charakter mit gleicher
         // Initiative tötet.
         CharPtrVector hfc;
         if( kann_handeln( **c ) ) 
         {
            hfc.push_back( *c );
         }
         for( CharPtrVector::iterator hfci = hfc.begin(); hfci != hfc.end(); ++hfci )
         {
            (*hfci)->attackiere( wenAuchImmer );
         }
      }
   }
}

int main()
{
   // Vektor mit allen am Kampf beteiligten (Spieler + Monster)
   vector<Charakter> Kombatanten;

   // Tabelle mit Vektoren der Charaktere, nach Initiative AUFSTEIGEND sortiert
   InitiativeCharTabelle RangFolge = erstelle_rangfolge( Kombatanten );

   // Kampfrunden durchführen, bis alle die Schnauze voll haben
   do
   {
      fuehre_kampfrunde_durch( RangFolge );
   }
   while( !Schnauze_voll );
}

Edit: Logikfehler korrigiert