[Anfänger] Fragen zur Programmierung mit Klassen

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

[Wurst]

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

[thuering]

ich habe erstmal angefangen, meinen bisherigen Code an meinen neuen Wissenstand anzupassen. Ich bin aber gleich über einen Fehler gestolpert, weil ich wohl Variablen einer vererbten Klasse mit einem Konstruktor setzen will...
Was kann ich tun? Wer den Kontext hier verfolgt hat, wird nachvollziehen können, dass eine Initialisierung direkt in der Klasse Enemy keine Option ist!

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

[314159265358979]

Kleiner Tipp: Die ungarische Notation ist hier nicht gerne gesehen, weil sie keine Vorteile bringt

[cooky451]

@thuering
Ich habe mal Google bemüht: http://www.dandwiki.com/wiki/SRD:Initiative
Hier steht, dass so lange neu gewürfelt wird, bis eine klare Reihenfolge da ist. Oder habe ich das falsch verstanden?

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

[DocShoe]

In einer Initialisierungsliste kannst du nur Elemente initialisieren, die unmittelbar zur Klasse des zu konstruierenden Objekts gehören. In deinem Beispiel versuchst du in Initialisierungsliste der Klasse Enemy Elemente der Klasse Charakter zu initialisieren, was nicht erlaubt ist.

[cooky451]

DocShoe schrieb:

In einer Initialisierungsliste kannst du nur Elemente initialisieren, die unmittelbar zur Klasse des zu konstruierenden Objekts gehören. In deinem Beispiel versuchst du in Initialisierungsliste der Klasse Enemy Elemente der Klasse Charakter zu initialisieren, was nicht erlaubt ist.

Echt? Dann habe ich mich vom Compiler reinlegen lassen.
http://ideone.com/t1AHr

[DocShoe]

Mein Posting bezieht sich auf das Problem von theuring, Zeile 36. Da versucht er Elemente der Basisklasse per Initialisierungsliste zu intialisieren.

@cooky451
Du rufst den Charakter Konstruktor auf, was völlig ok ist.

[cooky451]

Ach so und ich dachte schon ich müsste gefühlte 50k Zeilen Code umschreiben.