Momentan schauts so (ungefähr) aus mit den Klassen:
Charakter -> enthält alles was ein Charakter braucht. EP, Mana, Leben
Attribut -> Hat einen Namen, eine ID, ein Offset, einen Wert und Funktionen zum Inkrementieren und Dekrementieren.

Die Attribute werden einfach erstellt und der Klasse Charakter zugewiesen, die packt das ganze in eine Liste. Jedes Attribut hat ein Offset um das es beim Level-UP erhöht wird. Dazu besteht noch die Möglichkeit Leben und Mana ein Attribut zuzuweisen und aus dem Wert das Leben/Mana zu berechnen.

Hier mal ein Beispiel:

myCharacter() : rpgCharacter()
    {
        rpgCharacterAttribute m_strength(_T("Strength"), 20, 1, ID_STRENGTH);
        rpgCharacterAttribute m_intelligence(_T("Intelligence"), 50, 1, ID_INTELLIGENCE);    
        rpgCharacterAttribute m_stamina(_T("Stamina"), 30, 2, ID_STAMINA);

        this->addAttribute(m_strength);
        this->addAttribute(m_stamina);
        this->addAttribute(m_intelligence);

        this->setEXPOffset(1000);
        this->setListener(this);
        this->setManaAttribute(ID_INTELLIGENCE);
        this->setManaOffset(15);
        this->setHitpointAttribute(ID_STAMINA);
        this->setHitpointsOffset(10);
    }

Mit einem Anfangswert der Intelligenz von 50 und einem Offset von 15 hätte unser Charakter nun 750 Mana. Ich hoffe das ist nachvollziehbar. (setExpOffset(1000) heisst btw. dass unser Character von lvl 1 auf 2 1000 EP braucht, von 2 auf 3 dann 2000 etc).

Nun habe ich mir aber gedacht, dass nicht jeder so ein automatisches System mag. Es gibt ja auch genug RPGs wo man die Attribute selbst verteilen kann. Und der Code wird immer mehr, wenn ich auch noch das manuelle Verändern da reinpacke -> wird evtl. zu langsam bzw zuviel Overhead.
Deswegen dachte ich mir, mehr Interfaces zu verwenden und versch. Methoden für so etwas einzubauen.
Zum Beispiel:
IAttribute: Davon gibts dann AutoAttribute und ManualAttribute.
Verwendung sollte klar sein.
Ausserdem würde ich dann noch das ganze Gerümpel mit EP etc auslagern in extra Klassen.
Würdert Ihr das so designen oder habt Ihr andere Ideen?
Ich bitte um eure Tipps und Ratschläge :).
Danke euch vielmals im voraus.
rya.

Du solltest auf jeden Fall erst einmal mit abstrakten Interface-Klassen anfangen. Allein schon die Festlegung auf Leben, Mana, Level usw. kann evtl. schon zu konkret sein (insbesondere die Datentypen bzw. evtl. Datenbereiche).
Und du solltest statt einfacher Konstanten erwägen, Funktionen aufzurufen, um z.B. Formeln zu berechnen (meistens ist ja der EXP-Wert nicht konstant pro Levelaufstieg, sondern exponentiell: z.B. 0, 1000, 2500, 5000, 10000, 20000, ...).

Und zu jedem Attribut kann es ja wieder andere abhängige Eigenschaften geben (meistens als Tabelle hinterlegt),z.B.
Stärke: Schadensmodifikator, Traglast, ...
Geschicklichkeit: Fernwaffenbonus, Ausweichen, ...
Intelligenz: Anzahl der Zaubersprüche, ...
...

Du solltest also generell vieles ermöglichen können (in den Interface-Basisklassen).
Und am besten, du versuchst dann anhand von evtl. 2-3 verschiedenen Systemen, dir daraus dann konkrete Klassen zu entwickeln, damit du evtl. Design-Fehler schon früh berüchsichtigen (beseitigen) kannst.

Bei konkreteren Fragen könnte ich dir dann auch weiterhin helfen.
(da ich bis vor kurzem bei einer Computerspielefirma tätig war - und diese ein erfolgreiches Rollenspiel veröffentlicht haben - weiß ich, welche Komplexität erforderlich ist - selbst wenn man ein konkretes System verwendet!)

P.S. Auf meiner Homepage kannst du im Download-Bereich unter "Spiele" u.a. den AD&D-Charakter-Editor runterladen: http://www.bitel.net/dghm1164/downloads.html

Wegen den EP... bisher hab ich eben das mit den Offsets verwendet. Und dann einfach das ganze so berechnet:

void rpgLib::rpgCharacter::receiveEXP( const uint exp )
{
    m_exp += exp;
    return checkEP();
}

void rpgLib::rpgCharacter::checkEP()
{    
    float level_up = 0.0f;

    // Calculate EP needed for this level
    level_up = m_expOffset * m_level * ( m_level + 1) / 2;

    if(m_exp >= level_up)
    {
        // Increase Level.
        m_level ++;

        // Level Attributes
        rpgAttributeList::iterator it_begin = m_attribList.begin();

        while (it_begin != m_attribList.end())
        {
           it_begin->doLevelUp();
           it_begin++;
        }

        // Calculate new Mana             
        this->calcMana();

        // Calculate new HP.
        this->calcHP();

        // Notify about level up
        rpgCharEventList::iterator it_beginEvents = m_eventList.begin();                
        while (it_beginEvents != m_eventList.end())
        {
            rpgICharacterListener *listener = NULL;
            listener = *it_beginEvents;

            if (listener != NULL)
            {
                listener->onLevelUp(m_level);
            }        

            it_beginEvents++;
        }   

        return this->checkEP();     
    }
}

Hab aber noch mit dem Gedanken gespielt, einfach eine Array oder eine Liste zu erwarten, in dem alle Werte von LvL 1 bis Max. Level abgespeichert sind. So kann man die EP auch manuell steuern.
Wie machen das eigentlich prof. Spiele? Würde mich mal brennend interessieren :D.
Ich mach mich dann mal an die Interfaces .
Hast du eine EMail oder ICQ? Dann könnt ich dir hin und wieder was mailen, falls Du Dich dafür interessierst :). Bzw den SVN-Zugang.
Ich wollte das ganze jetzt eh neu beginne, das waren wie gesagt nur erste Tests, ob das so geht, wie ich mir das anfangs vorgestellt habe.
rya.

meine E-Mail-Adresse steht auf meiner Download-Seite.

Und was mir zu deinem Source auffällt:
du mußt lernen, noch mehr zu abstrahieren (und möglichst noch kleinere Funktionsblöcke zu schreiben), aber evtl. könnte ich ja direkt mit deinen Sourcen arbeiten, bzw. Teile davon dann selbst erstellen und dann dir schicken (oder direkt per SVN).

Hast du denn schon mal ein einfaches Klassendiagramm erstellt (damit du den Umfang abschätzen kannst)?

Und welchen Compiler (+OS) verwendest du?

P.S. das "this->" finde ich auch unnötig...

Und was mir zu deinem Source auffällt:
du mußt lernen, noch mehr zu abstrahieren (und möglichst noch kleinere Funktionsblöcke zu schreiben), aber evtl. könnte ich ja direkt mit deinen Sourcen arbeiten, bzw. Teile davon dann selbst erstellen und dann dir schicken (oder direkt per SVN).

Hmm, ja ich hab mir halt alles selbst beigebracht und meine Freunde haben alle ganz andere interessen :D. Hobby halt :P. Aber ich versuche mich zu verbessern.

Hast du denn schon mal ein einfaches Klassendiagramm erstellt (damit du den Umfang abschätzen kannst)?

Ja, im Kopf. Hab leider bisher kein gutes UML-Tool für Windows gefunden und für Linux hab ich momentan keinen Platz auf der Platte... alles voll. Aber die neue Festplatte ist in Arbeit :P.
Wegen den this->: Ja, ich weiss, dass es nicht nötig ist, das war nur zu Kontrollzwecken. Es macht ja keinen Unterschied ob das da jetzt steht oder nicht. Auf der anderen Seite sieht man auch gleich, dass es eben aus der Klasse kommt. Von daher egal.

und warum gibt eine void funktion einen rückgabewert zurück? ^^

Sie gibt keinen Wert zurück. Ich verlasse die Funktion in eine andere. Zumindest der g++ hat nicht gemecker mit "g++ --ansi".

Compiler verwende ich Visual C++ 2005 (war ein Geschenk nach einem Praktikum in einer Softwarefirma) von M$ und Ankh-SVN-Plugin. Werde aber schauen, dass das ganze in purem C++ geschrieben ist und evtl. gleich ein Bakefile dazu machen, dann kann man das auf jeder Plattform kompilieren.
So far.
rya.

Hast du denn schon mal ein einfaches Klassendiagramm erstellt (damit du den Umfang abschätzen kannst)?

Ja, im Kopf. Hab leider bisher kein gutes UML-Tool für Windows gefunden und für Linux hab ich momentan keinen Platz auf der Platte... alles voll. Aber die neue Festplatte ist in Arbeit :P.

Dia macht sich ganz gut für einfache Diagramme

http://live.gnome.org/Dia

Sowas wie eine Monster-Klasse gibt es dort nicht. Stattdessen ist jede Entität nur eine ID, anhand derer man die einzelnen Komponenten holen kann. Die Komponenten können miteinander über ein Message-System kommunizieren und jede Komponente entscheidet, an welchen Messages sie interessiert ist.

Der Vorteil ist, dass das ganze System data-driven ist, das heißt du kannst dir einen Editor zum zusammenklicken basteln, und damit alle NPCs usw. erzeugen, ohne an einer gratligen Vererbungshierarchie 100mal zu refactoren - es geht komplett ohne programmieren und du hast auch nicht die üblichen Designprobleme, die du mit einer Klassenhierarchie hast.

@darthdespotism:
Danke :). Kannt ich gar nicht das Prog. Verwende eigentlich KDE und da gibts kUML.

edit:
So, hier is mal ein kleines Diagramm mit dem Abschnitt für den Charakter:
http://img524.imageshack.us/my.php?image=diagramrpglibwu0.jpg
rya.

Bei deinem Diagramm ... fällt dir da nciht was auf?
IExperience, IEnergy und IHealth haben alle so ziemlich die selben Werte (IEnergie hat noch einen Max/Min-Wert ...). Was kann man dann daraus machen?

Hmm, noch ein Interface mit get/set-Methoden und dem Wert?
Ist das nicht ein wenig zuviel des guten?
rya.

Also ich hab jetzt bei vielen Klassen mit gleichen Eigenschaften und Methoden irgendwie an Templates gedacht, aber ob (D)Evil das auch gedacht hat weiß ich nicht.

Hehe, ja das ist wahrscheinlich:
http://img442.imageshack.us/my.php?image=diagramrpglibjt1.jpg
So?^^
rya.

Optimizer:
So in die Richtung hab ich schon gedacht, nur wüsste ich jetzt nicht, wie ich so ein Nachrichten-System umsetzen sollte.

Ja, das ist nicht völlig trivial. Ich habe so ein System mal vor kurzem umgesetzt und es gefällt mir wirklich ganz gut. Aber am Nachrichten-System feilsche ich auch noch. Das hängt wahrscheinlich vom Einzelfall ab, wie man das genau aufzieht, aber im Grunde gibt es immer sowas wie einen Entitätenmanager, der Nachrichten verschickt, broadcasted und über den man Komponenten getten kann. Wenn du danach suchst, findest du sicher auch ein paar Beispiele.

Aber ich stell mir das gerade iwie voll langsam vor.

Irgendeinen Tod muss man natürlich sterben. Performance-Probleme dürftest du aber eher bei den Berechnungen, die durch Nachrichten indirekt ausgelöst werden (zum Beispiel wenn es eine Wegsuche auslöst) kriegen und nicht beim Übermitteln selber.

Angenommen du hast 200 NPC's dann müsste jede Message in einer Schleife (oder wie macht man das?) 200x verschickt werden. Man könnte natürlich auch wieder dem Manager vorher mitteilen welche Nachrichten welche Klasse bzw Objekt haben will und welche nicht. Das wiederrum wäre mMn ein großer Sortier- und Verwaltungsaufwand.. oder?

Der Aufwand hält sich eigentlich in Grenzen. Ich hab sowas wie eine subscribersByType-Map, die sich den Nachrichten-Typ anschaut und die Liste der interessieren Komponenten holt. Das skaliert dann auch besser mit der Objektzahl, weil man nur die Interessenten benachrichtigt.

Ich hätte es halt so gemacht, dass es halt solche Listener gibt und die Klassen die Nachrichten dann selber versenden, bzw selbst die Listen führen...

Das Problem hierbei ist, dass du die Empfänger kennen musst, was das ganze System ad absurdum führt. Es ist besser, wenn eine Komponente möglichst wenig von allen anderen weiß.

enum eEvents
{
   ID_LEVELUP = 1,
   ID_FOOBAR,
};

class Experience
{
   receiveEP()
   {
       if (level_up)
       { 
          EventManager::notify(ID_LEVELUP);
       }
   }
};

class MyCharacter
{
    MyCharacter()
    {
      EventManager::register(ID_LEVELUP, this);
    }

    // Afaik muss man bei Boost diesen Operator implementieren um 
    // die Klasse übergeben zu können....
    void operator()()
    {
        // Handle level up
    }
};

Wäre vllt die einfachste Möglichkeit die mir so spontan einfällt. Weil wenn ich ganz ehrlich bin, reicht mein Wissen für so ein Modell wie du das genannt hast, (noch) nicht aus :). Übernehen möchte ich mich halt auch nicht. :xmas1:
Eine andere Idee wäre es, den EventManager bzw das EventSystem von wxWidgets zu benutzen. Die Lib ist XPlatform, wäre also kein Problem von der Portabilität, allerdings ist das Einbinden eher unlustig. Ich möchte, dass der Code auf Linux/Windows/MacOS läuft.
Aber an der Stelle nochmal vielen Dank für eure Ideen und Hilfe.
rya.