Seit ein paar Tagen plane ich nun, ein einfaches, textbasiertes Rollenspiel nach AD&D-inspiriertem Regelwerk zu programmieren.
Folgende Problemchen tuen sich auf, bei dessen Lösung ihr mir vielleicht Hinweise geben könnt:

Gibt es so etwas wie "dynamische Objekte"? Ich möchte mir nach Zufallsprinzip (erstmal

srand / rand

) mehrere, durchnummerierte "Gegner" erstellen. Dazu gibt es die Klasse "cCharacter", die mehrere int und string Variablen beinhaltet (diese Variablen sollen auch größtenteils mit Werten aus rand gefüllt werden). Bisher habe ich aber es noch nicht hinbekommen, solch "dynamische" Objektnamen (z.B. "Gegner0001", "Gegner0002") zu erstellen, mit denen ich dann sogar noch Funktionen aufrufen kann (z.B. "Gegner0002:InitiativeWuerfeln()" ).
Weiterhin stellt sich mir die Frage, wie ich es hinbekomme, dass alle "Gegner" erstmal die Funktion "InitiativeWuerfeln()" ausführen?

Vielleicht reicht es mir auch erstmal, wenn ihr mir sagen könnt, welche C++ Funktionalitäten ich mir mal genauer ansehen sollte. Bringen mir Container oder Listen etwas?
Ich danke schon mal im Voraus!

Edit: nochmal zum Verständnis: "Gegner000*" sind Objekte der Klasse cCharakter.

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();

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.

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?

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.

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.

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.

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 .

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.

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.

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.

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!

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;}
};

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.

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..

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

In einen vector kann man keine Referenzen stecken

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.

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.

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

Achtung, ich habe einiges aus diesem Quelltext entfernt, weil übersichtlicher!
Die Fehler:

\main02.cpp(60): error C2614: 'Enemy': Unzulässige Elementinitialisierung: 'nIniMod' ist weder Basis noch Element
\main02.cpp(60): error C2614: 'Enemy': Unzulässige Elementinitialisierung: 'nDamage' ist weder Basis noch Element
\main02.cpp(60): error C2614: 'Enemy': Unzulässige Elementinitialisierung: 'nHPnow' ist weder Basis noch Element
\main02.cpp(60): error C2614: 'Enemy': Unzulässige Elementinitialisierung: 'nHPmax' ist weder Basis noch Element
\main02.cpp(60): error C2614: 'Enemy': Unzulässige Elementinitialisierung: 'nAC' ist weder Basis noch Element
\main02.cpp(60): error C2614: 'Enemy': Unzulässige Elementinitialisierung: 'nETW0' ist weder Basis noch Element
\main02.cpp(60): error C2614: 'Enemy': Unzulässige Elementinitialisierung: 'strClass' ist weder Basis noch Element
\main02.cpp(60): error C2614: 'Enemy': Unzulässige Elementinitialisierung: 'strRace' ist weder Basis noch Element
\main02.cpp(60): error C2614: 'Enemy': Unzulässige Elementinitialisierung: 'strName' ist weder Basis noch Element

Zeile 60 entspricht in dem folgenden Listing Zeile 36/37!

class Charakter
{
public:
	string strName;
	string strRace;
	string strClass;
	int nETW0;
	int nAC;
	int nHPmax;
	int nHPnow;
	int nDamage;
	int nInitiative;
	int nIniMod;
	string strEnemyName;
	int nEnemyAC;
	void fInitiative();
	int fAttack();
};

class Player : public Charakter
{
public:
	string strPlayerName;
};

class Enemy : public Charakter
{
public:
	Enemy(string vName,	string vRace, string vClass, int vETW0,	int vAC, int vHPmax, int vHPnow, int vDamage, int vIniMod);
	int nXP;
};

Enemy::Enemy(string vName, string vRace, string vClass, int vETW0, int vAC, int vHPmax, int vHPnow, int vDamage, int vIniMod) : strName(vName), strRace(vRace), strClass(vClass), nETW0(vETW0), nAC(vAC), nHPmax(vHPmax), nHPnow(vHPnow), nDamage(vDamage), nIniMod(vIniMod)
{
}

int main()
{
	//Zufallszahlengenerator mit Zeit initialisieren
	srand((unsigned int)time(0));

	//Spielercharakter wird deklariert
	Player Spieler;
	Spieler.strName = "Arthus";
	Spieler.strRace = "Mensch";
	Spieler.strClass = "Kaempfer";
	Spieler.nETW0 = 14;
	Spieler.nAC = 4;
	Spieler.nHPmax = 35;
	Spieler.nHPnow = 35;
	Spieler.nDamage = 8;
	Spieler.nIniMod = 5;

	//Gegnercharakter wird deklariert
	Enemy Gegner("Ogercheffe","Oger","Berserker",14,5,23,23,10,5);
	return 0;
}

Zu deinem Problem:

class Character
{
public:
  enum Race
  {
    orc, elf, human,
  };
  enum Profession // class ist immer doof in C++ :)
  {
    warrior, mage, ranger,
  };
private:
  const Race race_;
  const Profession profession_;
  const unsigned int max_life_, damage_, initiative_;
  unsigned int current_life_;
public:
  Character(Race race, Profession profession, unsigned int max_life,
    unsigned int damage, unsigned int initiative)
    : race_(race), profession_(profession), max_life_(max_life),
      damage_(damage), initiative_(initiative), current_life_(max_life)
  {}
  void attack(Character& character)
  {
    if (character.current_life_ > this->damage_)
      character.current_life_ -= this->damage_;
    else
      character.current_life_ = 0;
  }
};

class Enemy : public Character
{
public:
  Enemy(Race race, Profession profession, unsigned int max_life,
    unsigned int damage, unsigned int initiative)
    : Character(race, profession, max_life, damage, initiative)
  {}
};

Damit solltest du so eine Grundidee bekommen haben. Du könntest natürlich auch attack() virtuell machen und dann wieder je nach Klasse ableiten etc., der Fantasie sind hier (fast) keine Grenzen gesetzt, versuche ein System aufzubauen, das du nachher leicht verwalten kannst. (Tipp: Wenn du die Basisklasse rein virtuell machst kannst du trotzdem einen std::vector<Character*> (man beachte den Pointer) erstellen.)