CSCI 235 Projekt 3 – Die Taverne: Rekursive Abenteuer in C++ mit Operator-Overloading und Vererbung

Einleitung: Die Taverne als Herzstück deines C++-Abenteuers

Stell dir vor, du entwickelst ein Rollenspiel – ähnlich den aktuellen Blockbuster-Titeln wie „Baldur's Gate 3“ oder „World of Warcraft“. In deiner virtuellen Welt treffen Helden und Schurken in einer Taverne aufeinander. Genau das ist die Aufgabe in CSCI 235: Du implementierst die Klasse Tavern, die als Unterklasse von ArrayBag fungiert und Character-Objekte verwaltet. Dieses Tutorial führt dich durch die zentralen Konzepte: Operator-Overloading, Vererbung und dynamische Datenstrukturen – alles angereichert mit Beispielen aus Gaming, KI und dem Uni-Alltag.

Warum Operator-Overloading? Ein Vergleich mit dem Gaming-Universum

In Spielen wie „League of Legends“ vergleichst du ständig Champion-Werte: „Ist mein Level höher als das des Gegners?“ In C++ erlaubt dir Operator-Overloading, eigene Vergleichsregeln für deine Klassen zu definieren. Genau das machst du bei der Character-Klasse: Du überschreibst den ==-Operator, um zu prüfen, ob zwei Charaktere denselben Namen, dieselbe Rasse, dasselbe Level und denselben Feindstatus haben. Stell dir vor, du möchtest in deinem Spiel prüfen, ob zwei Orks identisch sind – ohne Overloading müsstest du jedes Attribut einzeln vergleichen. Mit Overloading schreibst du einfach if (character1 == character2) – das spart Zeit und macht den Code lesbarer.

Die Character-Klasse erweitern: Schritt für Schritt

1. Der operator== und operator!=

Laut Aufgabenstellung müssen zwei Charaktere als gleich gelten, wenn sie in Name, Rasse, Level und Feindstatus übereinstimmen. Implementiere den operator== wie folgt:

bool Character::operator==(const Character& rhs) const {
    return (name_ == rhs.name_ &&
            race_ == rhs.race_ &&
            level_ == rhs.level_ &&
            isEnemy_ == rhs.isEnemy_);
}

Der operator!= ist dann das logische Gegenteil. Denk daran: Die genauen Funktionssignaturen müssen exakt der Vorgabe entsprechen – sonst gibt's Punktabzug.

2. Die display-Methode

Diese Methode gibt die Charakterdaten formatiert aus – ähnlich wie ein Spielerprofil in einem Online-Spiel. Ein Beispiel:

void Character::display() const {
    std::cout << name_ << " ist ein Level " << level_ << " " << race_ << ". ";
    std::cout << "Vitalität: " << vitality_ << " Max Rüstung: " << armor_ << ". ";
    std::cout << (isEnemy_ ? "Sie sind ein Feind." : "Sie sind kein Feind.") << std::endl;
}

ArrayBag erweitern: Duplikate vermeiden mit operator/=

Die ArrayBag-Klasse ist eine dynamische Liste. Deine Aufgabe: Implementiere operator/=, das zwei Beutel kombiniert, aber Duplikate ausschließt. Stell dir vor, du sammelst in „Pokémon Go“ Items – wenn du zwei Beutel zusammenlegst, sollen doppelte Items nur einmal vorkommen. Der Code könnte so aussehen:

template<typename T>
ArrayBag<T>& ArrayBag<T>::operator/=(const ArrayBag<T>& rhs) {
    for (size_t i = 0; i < rhs.item_count_; ++i) {
        if (!contains(rhs.items_[i])) {
            add(rhs.items_[i]);
        }
    }
    return *this;
}

Der operator+= hingegen fügt alle Elemente hinzu, solange Platz ist – inklusive Duplikate. Das ist nützlich, wenn du in deinem Spiel mehrere identische Tränke stapeln möchtest.

Die Tavern-Klasse: Vererbung in Aktion

Die Tavern erbt von ArrayBag<Character> und erweitert sie um spezifische Funktionen. Private Member sind level_sum_ und enemy_count_. Diese Werte werden bei jedem enterTavern und exitTavern aktualisiert – ähnlich wie ein Live-Scoreboard bei einem E-Sports-Turnier.

1. enterTavern und exitTavern

Wenn ein Charakter die Taverne betritt, wird er zur internen Liste hinzugefügt, und die Summe der Level sowie die Feindanzahl werden aktualisiert. Beispiel:

bool Tavern::enterTavern(const Character& a_character) {
    if (add(a_character)) {
        level_sum_ += a_character.getLevel();
        if (a_character.isEnemy()) {
            ++enemy_count_;
        }
        return true;
    }
    return false;
}

Beim Verlassen wird entsprechend subtrahiert. Achte darauf, dass exitTavern den Charakter genau dann entfernt, wenn er vorhanden ist – und dann die Summen korrigiert.

2. Berechnungen: Durchschnittslevel und Feindprozentsatz

Die Methode calculateAvgLevel rundet zur nächsten ganzen Zahl. Das ist wichtig für die Anzeige – wie in vielen Spielen, wo Stufen auf ganze Zahlen gerundet werden. Verwende std::round aus <cmath>.

int Tavern::calculateAvgLevel() const {
    if (getCurrentSize() == 0) return 0;
    return static_cast<int>(std::round(static_cast<double>(level_sum_) / getCurrentSize()));
}

Der Feindprozentsatz wird auf zwei Dezimalstellen gerundet – ideal für einen Report, der wie ein Statistiken-Dashboard in einem Mobile Game aussieht.

3. tallyRace und tavernReport

tallyRace zählt, wie viele Charaktere einer bestimmten Rasse angehören. Denk an die Rassenvielfalt in „The Elder Scrolls“ – dort gibt es Menschen, Elfen, Zwerge etc. Deine Implementierung muss auch den Fall abdecken, dass ein ungültiger String übergeben wird – dann ist die Zählung null.

Der tavernReport gibt eine formatierte Übersicht aus, die wie ein Logbuch aussieht. Das ist besonders nützlich für Debugging oder um den Spielstand zu präsentieren.

Praktische Tipps: Testen wie ein Profi

Teste jede Methode einzeln. Schreibe eine main()-Funktion, die verschiedene Szenarien durchspielt: füge Charaktere hinzu, entferne sie, prüfe die Zählungen. Nutze den Befehl make rebuild, um dein Projekt zu kompilieren. Ein typischer Fehler: Du vergisst, die level_sum_ zu aktualisieren, wenn ein Charakter entfernt wird. Ein Test mit zwei Charakteren, bei dem du einen entfernst und dann das Durchschnittslevel prüfst, deckt das auf.

Verbindung zu aktuellen Trends: KI und Gaming

Stell dir vor, deine Taverne ist die Basis für einen KI-gesteuerten NPC-Generator – ähnlich wie die dynamischen Charaktere in „No Man's Sky“ oder die KI-Gegner in „The Last of Us Part II“. Mit Operator-Overloading kannst du schnell Ähnlichkeiten zwischen KI-Agenten erkennen. Oder denk an die Beliebtheit von „Wordle“ – dort vergleichst du Buchstaben; in deinem Projekt vergleichst du Charakterattribute. Das Prinzip ist universell.

Häufige Fehler und wie du sie vermeidest

• Falsche Funktionssignaturen: Die Parameter und Rückgabetypen müssen exakt der Vorgabe entsprechen. Ein fehlendes const oder ein falscher Referenztyp führt zu Kompilierfehlern.
• Vergessen, level_sum_ und enemy_count_ zu aktualisieren: Besonders beim Entfernen eines Charakters musst du darauf achten, dass du die Werte korrigierst.
• Rundungsfehler: Verwende std::round für das Durchschnittslevel und std::ceil oder std::floor nicht – die Aufgabenstellung verlangt Runden zur nächsten ganzen Zahl.
• Umgang mit leeren Tavernen: Wenn die Taverne leer ist, sollte calculateAvgLevel 0 zurückgeben und calculateEnemyPercentage 0.0.

Fazit: Dein Einstieg in die Welt der rekursiven Algorithmen

Mit diesem Projekt lernst du nicht nur C++-Grundlagen, sondern auch, wie man komplexe Systeme strukturiert – eine Fähigkeit, die in der Softwareentwicklung unerlässlich ist. Ob du später an KI-Systemen, Spiele-Engines oder Finanz-Apps arbeitest – die Konzepte der Vererbung, des Operator-Overloadings und der dynamischen Datenverwaltung begleiten dich. Also, ran an die Tastatur und bau deine Taverne – das Abenteuer wartet!