Menu
▾
▴
darkeyetool-cvs
Update of /cvsroot/darkeyetool/det/src/dsa In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv4082/src/dsa Modified Files: Tag: gnaddelwarz-steigern Person.cpp Person.h PersonHandlerSteigern.h Regeln.cpp Regeln.h Texte.h Added Files: Tag: gnaddelwarz-steigern PersonHandlerSteigern.cpp Log Message: Man kann jetzt Charaktere steigern (noch unvollständig) (Implementierung zunächst in Extra-Branch) Index: Person.h =================================================================== RCS file: /cvsroot/darkeyetool/det/src/dsa/Person.h,v retrieving revision 1.14 retrieving revision 1.14.2.1 diff -u -d -r1.14 -r1.14.2.1 --- Person.h 9 Apr 2004 22:25:50 -0000 1.14 +++ Person.h 26 Apr 2005 22:59:35 -0000 1.14.2.1 @@ -18,167 +18,311 @@ //@@c #ifdef MSVC -#pragma warning(disable:4786 4503) +# pragma warning(disable:4786 4503) #endif //@-node:<< header >> //@nl #if !defined(PERSON_H) -#define PERSON_H +# define PERSON_H //@<< includes >> //@+node:<< includes >> -#include "Eigenschaft.h" -#include "AbgeleiteterWert.h" -#include "Rasse.h" -#include "Kultur.h" -#include "Profession.h" -#include "Talent.h" -#include "Charakteristikum.h" -#include "Sonderfertigkeit.h" -#include "Zauber.h" +# include "Eigenschaft.h" +# include "AbgeleiteterWert.h" +# include "Rasse.h" +# include "Kultur.h" +# include "Profession.h" +# include "Talent.h" +# include "Charakteristikum.h" +# include "Sonderfertigkeit.h" +# include "Zauber.h" //@nonl //@-node:<< includes >> //@nl -namespace DSA { - //@ << class Person >> - //@+node:<< class Person >> - class Person { - public: - //@ << Administrativa >> - //@+node:<< Administrativa >> - Person(); - Person(const Person& other); - ~Person(); - - bool operator==(const Person& other) const; - bool operator!=(const Person& other) const { return !operator==(other); } - - static std::string Klasse() { return _t("Person"); } - static std::string Klassen() { return _t("Personen"); } - - void ID(const std::string& id) { id_ = id; } - std::string ID() const { return id_; } - void Name(const std::string& name) { name_ = name; } - std::string Name() const { return name_; } - //@nonl - //@-node:<< Administrativa >> - //@nl - - std::string ErsetzeTag(const std::string& tag) const; - - void Beschreibung(const std::string& beschreibung) { beschreibung_ = beschreibung; } - std::string Beschreibung() const { return beschreibung_; } - int GP() const { return gp_; } - void GP(int g) { gp_ = g; } - - void Rasse_(Rasse rasse) { rasse_ = rasse; } - Rasse Rasse_() const { return rasse_; } - void Kultur_(Kultur kultur) { kultur_ = kultur; } - Kultur Kultur_() const { return kultur_; } - void Profession_(Profession profession) { profession_ = profession; } - Profession Profession_() const { return profession_; } - - //@ << Aussehen >> - //@+node:<< Aussehen >> - void Augenfarbe(const std::string& augenfarbe) { augenfarbe_ = augenfarbe; } - std::string Augenfarbe() const { return augenfarbe_; } - void Hauptfarbe(const std::string& hauptfarbe) { hauptfarbe_ = hauptfarbe; } - std::string Hauptfarbe() const { return hauptfarbe_; } - void Groesse(int groesse) { groesse_ = groesse; } - int Groesse() const { return groesse_; } - void Gewicht(int gewicht) { gewicht_ = gewicht; } - int Gewicht() const { return gewicht_; } - void Alter(int alter) { alter_ = alter; } - int Alter() const { return alter_; } - - void Maennlich(bool m) { weiblich_ = !m; } - bool Maennlich() const { return !weiblich_; } - void Weiblich(bool w) { weiblich_ = w; } - bool Weiblich() const { return weiblich_; } - std::string Geschlecht() { return weiblich_ ? _t("weiblich") : _t("männlich"); } - //@nonl - //@-node:<< Aussehen >> - //@nl - - //@ << Lese/Schreibe >> - //@+node:<< Lese/Schreibe >> - int Lese(PersistenzManager* pm, const std::string& id = ""); - int Schreibe(PersistenzManager* pm) const; - int Pruefe() const; - static int IDListe(PersistenzManager* pm, StringListe* liste); - //@nonl - //@-node:<< Lese/Schreibe >> - //@nl - - int Wert(Eigenschaftsart e) const - { return eigenschaft_[static_cast<int>(e)].Wert(); } - int Basiswert(Eigenschaftsart e) const - { return eigenschaft_[static_cast<int>(e)].Basiswert(); } - int Wert(AbgeleiteterWertArt a) const - { return abgeleiteterWert_[static_cast<int>(a)].Wert(); } - int Basiswert(AbgeleiteterWertArt a) const - { return abgeleiteterWert_[static_cast<int>(a)].Basiswert(); } - - // unbekannte Eigenschaft wenn undefiniert - Eigenschaftsart Leiteigenschaft() const; - // 0 wenn undefiniert - int Leiteigenschaftswert() const; - - //@ << Berechnete Info >> - //@+node:<< Berechnete Info >> - Charakteristika Vorteile() const; - Charakteristika Nachteile() const; - - Talente Talente_(Talentgruppe gruppe) const; - //@-node:<< Berechnete Info >> - //@nl - - //@ << Listen (sollten ob Demeter raus)>> - //@+node:<< Listen (sollten ob Demeter raus)>> - Eigenschaft eigenschaft_[AnzahlEigenschaften]; - AbgeleiteterWert abgeleiteterWert_[AnzahlAbgeleiteterWerte]; - Talente talente_; - Sprachen sprachen_; - Schriften schriften_; - Kampftechniken kampftechniken_; - Charakteristika charakteristika_; - Sonderfertigkeiten sonderfertigkeiten_; - StringListe verbilligteSonderfertigkeiten_; - Zauberfertigkeiten zauberfertigkeiten_; - //@nonl - //@-node:<< Listen (sollten ob Demeter raus)>> - //@nl - +namespace DSA +{ + //@ << class Person >> + //@+node:<< class Person >> + class Person + { + public: + //@ << Administrativa >> + //@+node:<< Administrativa >> + Person(); + Person(const Person & other); + ~Person(); + + bool operator==(const Person & other) const; + bool operator!=(const Person & other) const + { + return !operator==(other); + } + + static std::string Klasse() + { + return _t("Person"); + } + static std::string Klassen() + { + return _t("Personen"); + } + + void ID(const std::string & id) + { + id_ = id; + } + std::string ID()const + { + return id_; + } + void Name(const std::string & name) + { + name_ = name; + } + std::string Name()const + { + return name_; + } + //@nonl + //@-node:<< Administrativa >> + //@nl + + std::string ErsetzeTag(const std::string & tag) const; + + void Beschreibung(const std::string & beschreibung) + { + beschreibung_ = beschreibung; + } + std::string Beschreibung()const + { + return beschreibung_; + } + int GP() const + { + return gp_; + } + void GP(int g) + { + gp_ = g; + } + int AP() const + { + return apg_ + apv_; + } + int APV() const + { + return apv_; + } + int APG() const + { + return apg_; + } + void HinzuAPG(int a) + { + apg_ += a; + } + void VerbraucheAPG(int a) + { + apg_ -= a; + apv_ += a; + } + int Stufe() const + { + return regeln()->AP2Stufe(APV()); + } + + void Rasse_(Rasse rasse) + { + rasse_ = rasse; + } + Rasse Rasse_() const + { + return rasse_; + } + void Kultur_(Kultur kultur) + { + kultur_ = kultur; + } + Kultur Kultur_() const + { + return kultur_; + } + void Profession_(Profession profession) + { + profession_ = profession; + } + Profession Profession_() const + { + return profession_; + } + + //@ << Aussehen >> + //@+node:<< Aussehen >> + void Augenfarbe(const std::string & augenfarbe) + { + augenfarbe_ = augenfarbe; + } + std::string Augenfarbe()const + { + return augenfarbe_; + } + void Hauptfarbe(const std::string & hauptfarbe) + { + hauptfarbe_ = hauptfarbe; + } + std::string Hauptfarbe()const + { + return hauptfarbe_; + } + void Groesse(int groesse) + { + groesse_ = groesse; + } + int Groesse() const + { + return groesse_; + } + void Gewicht(int gewicht) + { + gewicht_ = gewicht; + } + int Gewicht() const + { + return gewicht_; + } + void Alter(int alter) + { + alter_ = alter; + } + int Alter() const + { + return alter_; + } + + void Maennlich(bool m) + { + weiblich_ = !m; + } + bool Maennlich() const + { + return !weiblich_; + } + void Weiblich(bool w) + { + weiblich_ = w; + } + bool Weiblich() const + { + return weiblich_; + } + std::string Geschlecht() + { + return weiblich_ ? _t("weiblich") : _t("männlich"); + } + //@nonl + //@-node:<< Aussehen >> + //@nl + + //@ << Lese/Schreibe >> + //@+node:<< Lese/Schreibe >> + int Lese(PersistenzManager * pm, const std::string & id = ""); + int Schreibe(PersistenzManager * pm) const; + int Pruefe() const; + static int IDListe(PersistenzManager * pm, StringListe * liste); + + //@nonl + //@-node:<< Lese/Schreibe >> + //@nl + + int Wert(Eigenschaftsart e) const + { + return eigenschaft_[static_cast < int >(e)].Wert(); + } + int Basiswert(Eigenschaftsart e) const + { + return eigenschaft_[static_cast < int >(e)].Basiswert(); + } + int Maximalwert(Eigenschaftsart e) const + { + return eigenschaft_[static_cast < int >(e)].Maximalwert(); + } + int Wert(AbgeleiteterWertArt a) const + { + return abgeleiteterWert_[static_cast < int >(a)].Wert(); + } + int Basiswert(AbgeleiteterWertArt a) const + { + return abgeleiteterWert_[static_cast < int >(a)].Basiswert(); + } + + // unbekannte Eigenschaft wenn undefiniert + Eigenschaftsart Leiteigenschaft() const; + + // 0 wenn undefiniert + int Leiteigenschaftswert() const; + + //@ << Berechnete Info >> + //@+node:<< Berechnete Info >> + Charakteristika Vorteile() const; + Charakteristika Nachteile() const; + + Talente Talente_(Talentgruppe gruppe) const; + + //@-node:<< Berechnete Info >> + //@nl + + //@ << Listen (sollten ob Demeter raus)>> + //@+node:<< Listen (sollten ob Demeter raus)>> + Eigenschaft eigenschaft_[AnzahlEigenschaften]; + AbgeleiteterWert abgeleiteterWert_[AnzahlAbgeleiteterWerte]; + Talente talente_; + Sprachen sprachen_; + Schriften schriften_; + Kampftechniken kampftechniken_; + Charakteristika charakteristika_; + Sonderfertigkeiten sonderfertigkeiten_; + StringListe verbilligteSonderfertigkeiten_; + Zauberfertigkeiten zauberfertigkeiten_; + + //@nonl + //@-node:<< Listen (sollten ob Demeter raus)>> + //@nl + //@<< private >> //@+node:<< private >> - private: - std::string id_; - std::string name_; - std::string beschreibung_; - int gp_; - Rasse rasse_; - Kultur kultur_; - Profession profession_; - std::string augenfarbe_; - std::string hauptfarbe_; - int groesse_; - int gewicht_; - int alter_; - bool weiblich_; + private: + std::string id_; + std::string name_; + std::string beschreibung_; + int gp_; + int apv_; + int apg_; + Rasse rasse_; + Kultur kultur_; + Profession profession_; + + std::string augenfarbe_; + std::string hauptfarbe_; + int groesse_; + int gewicht_; + int alter_; + bool weiblich_; + //@nonl //@-node:<< private >> //@nl - - }; // Person - //@-node:<< class Person >> - //@nl - class Personen : public Menge<Person> { - }; // Personen + }; // Person + //@-node:<< class Person >> + //@nl - Personen* personen(); + class Personen:public Menge < Person > + { + }; // Personen + + Personen *personen(); } #endif // !defined(PERSON_H) @@ -186,6 +330,10 @@ //@<< Version History >> //@+node:<< Version History >> // $Log$ +// Revision 1.14.2.1 2005/04/26 22:59:35 gnaddelwarz +// Man kann jetzt Charaktere steigern (noch unvollständig) +// (Implementierung zunächst in Extra-Branch) +// // Revision 1.14 2004/04/09 22:25:50 vrandezo // Zauberfertigkeiten fuer Personen eintragbar // Index: Regeln.cpp =================================================================== RCS file: /cvsroot/darkeyetool/det/src/dsa/Regeln.cpp,v retrieving revision 1.9 retrieving revision 1.9.2.1 diff -u -d -r1.9 -r1.9.2.1 --- Regeln.cpp 13 Apr 2004 21:45:45 -0000 1.9 +++ Regeln.cpp 26 Apr 2005 22:59:35 -0000 1.9.2.1 @@ -18,7 +18,7 @@ //@@c #ifdef MSVC -#pragma warning(disable:4786 4503) +# pragma warning(disable:4786 4503) #endif //@-node:<< header >> //@nl @@ -39,214 +39,274 @@ //@<< filename >> //@+node:<< filename >> #ifdef _DEBUG -#undef THIS_FILE -static char THIS_FILE[]=__FILE__; +# undef THIS_FILE +static char THIS_FILE[] = __FILE__; + //#define new DEBUG_NEW #endif //@-node:<< filename >> //@nl -namespace DSA { +namespace DSA +{ - //@ @+others - //@+node:Default - void Regeln::Default() { - regel_.clear(); - Regel("Anzahl bei Generierung aktivierbarer Talente", 5); - Regel("Durchschnittswert einer Eigenschaft", 10); - Regel("Maximaler Startwert einer Eigenschaft", 14); - Regel("Minimaler Startwert einer Eigenschaft", 8); - Regel("Üblicher Maximalwert einer Eigenschaft", 21); - Regel("In Eigenschaften investierbare GP", 100); - Regel("Aus Nachteilen gewinnbare GP", 50); - Regel("Aus Schlechten Eigenschaften gewinnbare GP", 30); - Regel("Durchschnittsstartwert SO", 7); - Regel("Maximaler Startwert SO", 12); - Regel("Minimaler Startwert SO", 1); - Regel("Start-GP", 110); - Regel("Startdifferenz Klugheit zur Muttersprache", -2); - Regel("Startdifferenz Klugheit zur Zweitsprache", -4); - Regel("Maximale Differenz AT/PA", 5); - Regel("Maximaler Startwert einer Schlechten Eigenschaft", 12); - Regel("Minimaler Startwert einer Schlechten Eigenschaft", 5); - - Regeloption("Begabungen und Unfähigkeiten nach Errata", true); - - //@ << SKT >> - //@+node:<< SKT >> - // SKT A B C D E F G H (nach MFF 46) - int buf[AnzahlSKTZeilen][AnzahlSKTSpalten] - = {{ 1, 2, 2, 3, 4, 6, 8, 16 }, // 1 - { 2, 4, 6, 7, 9, 14, 18, 35 }, // 2 - { 3, 6, 9, 12, 15, 22, 30, 60 }, // 3 - { 4, 8, 13, 17, 21, 32, 42, 85 }, // 4 - { 6, 11, 17, 22, 28, 41, 55, 110 }, // 5 - { 7, 14, 21, 27, 34, 50, 70, 140 }, // 6 - { 8, 17, 25, 33, 41, 60, 85, 165 }, // 7 - { 10, 19, 29, 39, 48, 75, 95, 195 }, // 8 - { 11, 22, 34, 45, 55, 85, 110, 220 }, // 9 - { 13, 25, 38, 50, 65, 95, 125, 250 }, // 10 - { 14, 28, 43, 55, 70, 105, 140, 280 }, // 11 - { 16, 32, 47, 65, 80, 120, 160, 320 }, // 12 - { 17, 35, 51, 70, 85, 130, 175, 350 }, // 13 - { 19, 38, 55, 75, 95, 140, 190, 380 }, // 14 - { 21, 41, 60, 85, 105, 155, 210, 410 }, // 15 - { 22, 45, 65, 90, 110, 165, 220, 450 }, // 16 - { 24, 48, 70, 95, 120, 180, 240, 480 }, // 17 - { 26, 51, 75, 105, 130, 195, 260, 510 }, // 18 - { 27, 55, 80, 110, 135, 215, 270, 550 }, // 19 - { 29, 58, 85, 115, 145, 220, 290, 580 }, // 20 - { 31, 62, 95, 125, 155, 230, 310, 620 }, // 21 - { 33, 65, 100, 130, 165, 250, 330, 650 }, // 22 - { 34, 69, 105, 140, 170, 260, 340, 690 }, // 23 - { 36, 73, 110, 145, 180, 270, 360, 720 }, // 24 - { 38, 76, 115, 150, 190, 290, 380, 760 }, // 25 - { 40, 80, 120, 160, 200, 300, 400, 800 }, // 26 - { 42, 84, 125, 165, 210, 310, 420, 830 }, // 27 - { 44, 87, 130, 170, 220, 330, 440, 870 }, // 28 - { 45, 91, 135, 180, 230, 340, 460, 910 }, // 29 - { 47, 95, 140, 190, 240, 350, 480, 950 }, // 30 - { 50, 100, 150, 200, 250, 375, 500,1000 }};// 31+ - double dbuf[AnzahlSKTSpalten] - = { 1.f, 2.f, 3.f, 4.f, 5.f,7.5f,10.f,20.f }; - - int i = 0; - for (i=0; i<AnzahlSKTZeilen; ++i) - for (int j=0; j<AnzahlSKTSpalten; ++j) - skt_[i][j] = buf[i][j]; - - for (i=0; i<AnzahlSKTSpalten; ++i) - aktivierungsfaktor_[i] = dbuf[i]; - //@nonl - //@-node:<< SKT >> - //@nl - - SKTKampf = D; - SKTKoerperlich = D; - SKTGesellschaftlich = B; - SKTNatur = B; - SKTWissen = B; - SKTSprachenUndSchriften = A; - SKTHandwerk = B; - SKTGaben = G; - - } // Default - //@-node:Default - //@+node:Regel - int Regeln::Regel(const std::string& id) const { - std::map<std::string, int>::const_iterator r = regel_.find(id); - if (r != regel_.end()) return r->second; - Log::Error(_t("Unbekannte Regeloption") + " " + id); - return 0; - } // Regel - - std::string Regeln::Regel(const int i) const { - int it = 1; - for (std::map<std::string, int>::const_iterator ci = regel_.begin(); ci != regel_.end(); ++ci, ++it) - if (it>i) return ci->first; - return 0; - } // Regel + //@ @+others + //@+node:Default + void Regeln::Default() + { + regel_.clear(); + Regel("Anzahl bei Generierung aktivierbarer Talente", 5); + Regel("Durchschnittswert einer Eigenschaft", 10); + Regel("Maximaler Startwert einer Eigenschaft", 14); + Regel("Minimaler Startwert einer Eigenschaft", 8); + Regel("Üblicher Maximalwert einer Eigenschaft", 21); + Regel("In Eigenschaften investierbare GP", 100); + Regel("Aus Nachteilen gewinnbare GP", 50); + Regel("Aus Schlechten Eigenschaften gewinnbare GP", 30); + Regel("Durchschnittsstartwert SO", 7); + Regel("Maximaler Startwert SO", 12); + Regel("Minimaler Startwert SO", 1); + Regel("Start-GP", 110); + Regel("Startdifferenz Klugheit zur Muttersprache", -2); + Regel("Startdifferenz Klugheit zur Zweitsprache", -4); + Regel("Maximale Differenz AT/PA", 5); + Regel("Maximaler Startwert einer Schlechten Eigenschaft", 12); + Regel("Minimaler Startwert einer Schlechten Eigenschaft", 5); + + Regeloption("Begabungen und Unfähigkeiten nach Errata", true); + + //@ << SKT >> + //@+node:<< SKT >> + // SKT A B C D E F G H (nach MFF 46) + int buf[AnzahlSKTZeilen][AnzahlSKTSpalten] + = { {1, 2, 2, 3, 4, 6, 8, 16}, // 1 + {2, 4, 6, 7, 9, 14, 18, 35}, // 2 + {3, 6, 9, 12, 15, 22, 30, 60}, // 3 + {4, 8, 13, 17, 21, 32, 42, 85}, // 4 + {6, 11, 17, 22, 28, 41, 55, 110}, // 5 + {7, 14, 21, 27, 34, 50, 70, 140}, // 6 + {8, 17, 25, 33, 41, 60, 85, 165}, // 7 + {10, 19, 29, 39, 48, 75, 95, 195}, // 8 + {11, 22, 34, 45, 55, 85, 110, 220}, // 9 + {13, 25, 38, 50, 65, 95, 125, 250}, // 10 + {14, 28, 43, 55, 70, 105, 140, 280}, // 11 + {16, 32, 47, 65, 80, 120, 160, 320}, // 12 + {17, 35, 51, 70, 85, 130, 175, 350}, // 13 + {19, 38, 55, 75, 95, 140, 190, 380}, // 14 + {21, 41, 60, 85, 105, 155, 210, 410}, // 15 + {22, 45, 65, 90, 110, 165, 220, 450}, // 16 + {24, 48, 70, 95, 120, 180, 240, 480}, // 17 + {26, 51, 75, 105, 130, 195, 260, 510}, // 18 + {27, 55, 80, 110, 135, 215, 270, 550}, // 19 + {29, 58, 85, 115, 145, 220, 290, 580}, // 20 + {31, 62, 95, 125, 155, 230, 310, 620}, // 21 + {33, 65, 100, 130, 165, 250, 330, 650}, // 22 + {34, 69, 105, 140, 170, 260, 340, 690}, // 23 + {36, 73, 110, 145, 180, 270, 360, 720}, // 24 + {38, 76, 115, 150, 190, 290, 380, 760}, // 25 + {40, 80, 120, 160, 200, 300, 400, 800}, // 26 + {42, 84, 125, 165, 210, 310, 420, 830}, // 27 + {44, 87, 130, 170, 220, 330, 440, 870}, // 28 + {45, 91, 135, 180, 230, 340, 460, 910}, // 29 + {47, 95, 140, 190, 240, 350, 480, 950}, // 30 + {50, 100, 150, 200, 250, 375, 500, 1000} + }; // 31+ + double dbuf[AnzahlSKTSpalten] + = { 1.f, 2.f, 3.f, 4.f, 5.f, 7.5f, 10.f, 20.f }; + + int i = 0; + + for (i = 0; i < AnzahlSKTZeilen; ++i) + for (int j = 0; j < AnzahlSKTSpalten; ++j) + skt_[i][j] = buf[i][j]; + + for (i = 0; i < AnzahlSKTSpalten; ++i) + aktivierungsfaktor_[i] = dbuf[i]; //@nonl - //@-node:Regel - //@+node:Regeloption - bool Regeln::Regeloption(const std::string& id) const { - std::map<std::string, bool>::const_iterator r = regeloption_.find(id); - if (r != regeloption_.end()) return r->second; - Log::Error(_t("Unbekannte Regeloption") + " " + id); - return 0; - } // Regel - - std::string Regeln::Regeloption(const int i) const { - int it = 1; - for (std::map<std::string, bool>::const_iterator ci = regeloption_.begin(); ci != regeloption_.end(); ++ci, ++it) - if (it>i) return ci->first; + //@-node:<< SKT >> + //@nl + + SKTKampf = D; + SKTKoerperlich = D; + SKTGesellschaftlich = B; + SKTNatur = B; + SKTWissen = B; + SKTSprachenUndSchriften = A; + SKTHandwerk = B; + SKTGaben = G; + + } // Default + //@-node:Default + //@+node:Regel + int Regeln::Regel(const std::string & id) const + { + std::map < std::string, int >::const_iterator r = regel_.find(id); + if (r != regel_.end()) + return r->second; + Log::Error(_t("Unbekannte Regeloption") + " " + id); return 0; - } // Regel - //@nonl - //@-node:Regeloption - //@+node:SKT - int Regeln::SKT(SKTSpalte s, int i) const { - if (s==TransA) return max(SKT(A, i)-2, 1); - if (i<1) return (int) Aktivierungsfaktor(s); - if (i>AnzahlSKTZeilen) return skt_[31][static_cast<int>(s)-1]; - return skt_[i-1][static_cast<int>(s)-1]; - } // SKT - - double Regeln::Aktivierungsfaktor(SKTSpalte s) const { - if (s==TransA) return aktivierungsfaktor_[0]; - return aktivierungsfaktor_[static_cast<int>(s)-1]; - } // Aktivierungsfaktor - - SKTSpalte Regeln::TalentgruppenSKT(Talentgruppe g) const { - switch (g) { - case Kampf : return SKTKampf; - case Koerperlich : return SKTKoerperlich; - case Gabe : return SKTGaben; - case Gesellschaftlich : return SKTGesellschaftlich; - case Handwerk : return SKTHandwerk; - case Natur : return SKTNatur; - case SprachenUndSchriften : return SKTSprachenUndSchriften; - case Wissen : return SKTWissen; - default : return D; - } - } // TalentgruppenSKT - //@nonl - //@-node:SKT - //@+node:Lese - int Regeln::Lese(PersistenzManager* pm, const std::string& id) { - Default(); - std::string geleseneID = id; - int rv = pm->OeffneZumLesen(Klassen(), geleseneID); - StringListe s; - rv += pm->IDListe(Klasse(), s); - for (StringListe::iterator i = s.begin(); i != s.end(); ++i) { - int wert = 0; - int rv0 = pm->Lese(Klasse(), *i, wert); - if (rv0==0) Regel(*i, wert); - rv += rv0; - } - rv += pm->SchliesseNachLesen(); - return rv; // TODO - } // Lese - //@-node:Lese - //@+node:Schreibe - int Regeln::Schreibe(PersistenzManager* pm) const { - int rv = pm->OeffneZumSchreiben(Klassen()); - - for (std::map<std::string, int>::const_iterator i = regel_.begin(); i != regel_.end(); ++i) - rv += pm->Schreibe(Klasse(), i->first, i->second); - - rv += pm->SchliesseNachSchreiben(); - - return rv; // TODO - } // Schreibe - //@nonl - //@-node:Schreibe - //@+node:Prüfe - int Regeln::Pruefe() const { - Log::Info("Regeln::Pruefe " + _t("nicht implementiert")); - return 1; // TODO - } // Pruefe - //@nonl - //@-node:Prüfe - //@+node:IDListe - int Regeln::IDListe(PersistenzManager* pm, StringListe* liste) { - return pm->IDListe(_t("Regeln"), liste); // TODO Prüfen - } // IDListe - //@nonl - //@-node:IDListe - //@-others - - Regeln* regeln() { static Regeln* regeln_ = new Regeln(); return regeln_; } + } // Regel - int regeln(const std::string& id) { return regeln()->Regel(id); } + std::string Regeln::Regel(const int i) const + { + int it = 1; + for (std::map < std::string, int >::const_iterator ci = + regel_.begin(); ci != regel_.end(); ++ci, ++it) + if (it > i) + return ci->first; + return 0; + } // Regel + //@nonl + //@-node:Regel + //@+node:Regeloption + bool Regeln::Regeloption(const std::string & id) const + { + std::map < std::string, bool >::const_iterator r = + regeloption_.find(id); + if (r != regeloption_.end()) + return r->second; + Log::Error(_t("Unbekannte Regeloption") + " " + id); + return 0; + } // Regel + std::string Regeln::Regeloption(const int i) const + { + int it = 1; + for (std::map < std::string, bool >::const_iterator ci = + regeloption_.begin(); ci != regeloption_.end(); ++ci, ++it) + if (it > i) + return ci->first; + return 0; + } // Regel + //@nonl + //@-node:Regeloption + //@+node:SKT + int Regeln::SKT(SKTSpalte s, int i) const + { + if (s == TransA) + return max(SKT(A, i) - 2, 1); + if (i < 1) + return (int) Aktivierungsfaktor(s); + if (i > AnzahlSKTZeilen) + return skt_[31][static_cast < int >(s) - 1]; + return skt_[i - 1][static_cast < int >(s) - 1]; + } // SKT + + double Regeln::Aktivierungsfaktor(SKTSpalte s) const + { + if (s == TransA) + return aktivierungsfaktor_[0]; + return aktivierungsfaktor_[static_cast < int >(s) - 1]; + } // Aktivierungsfaktor + + SKTSpalte Regeln::TalentgruppenSKT(Talentgruppe g) const + { + switch (g) { + case Kampf: + return SKTKampf; + case Koerperlich:return SKTKoerperlich; + case Gabe:return SKTGaben; + case Gesellschaftlich:return SKTGesellschaftlich; + case Handwerk:return SKTHandwerk; + case Natur:return SKTNatur; + case SprachenUndSchriften:return SKTSprachenUndSchriften; + case Wissen:return SKTWissen; + default:return D; + } + } // TalentgruppenSKT + //@nonl + //@-node:SKT + //@+node:Lese + int Regeln::Lese(PersistenzManager * pm, const std::string & id) + { + Default(); + std::string geleseneID = id; + int rv = pm->OeffneZumLesen(Klassen(), geleseneID); + StringListe s; + + rv += pm->IDListe(Klasse(), s); + for (StringListe::iterator i = s.begin(); i != s.end(); ++i) { + int wert = 0; + int rv0 = pm->Lese(Klasse(), *i, wert); + + if (rv0 == 0) + Regel(*i, wert); + rv += rv0; + } + rv += pm->SchliesseNachLesen(); + return rv; // TODO + } // Lese + //@-node:Lese + //@+node:Schreibe + int Regeln::Schreibe(PersistenzManager * pm) const + { + int rv = pm->OeffneZumSchreiben(Klassen()); + + for (std::map < std::string, int >::const_iterator i = regel_.begin(); + i != regel_.end(); ++i) + rv += pm->Schreibe(Klasse(), i->first, i->second); + + rv += pm->SchliesseNachSchreiben(); + + return rv; // TODO + } // Schreibe + //@nonl + //@-node:Schreibe + //@+node:Prüfe + int Regeln::Pruefe() const + { + Log::Info("Regeln::Pruefe " + _t("nicht implementiert")); + return 1; // TODO + } // Pruefe + //@nonl + //@-node:Prüfe + //@+node:IDListe + int Regeln::IDListe(PersistenzManager * pm, StringListe * liste) + { + return pm->IDListe(_t("Regeln"), liste); // TODO Prüfen + } // IDListe + //@nonl + //@-node:IDListe + //@-others + + Regeln *regeln() + { + static Regeln *regeln_ = new Regeln(); + + return regeln_; + } + + int regeln(const std::string & id) + { + return regeln()->Regel(id); + } + + int Regeln::Stufe2AP(int stufe) + { + if (stufe > 1) + return (stufe * (stufe - 1) * 50); + else + return 0; + } + + int Regeln::AP2Stufe(int ap) + { + int s = 1; + + while (Stufe2AP(s) <= ap) + ++s; + return s - 1; + } } //@<< Version History >> //@+node:<< Version History >> // $Log$ +// Revision 1.9.2.1 2005/04/26 22:59:35 gnaddelwarz +// Man kann jetzt Charaktere steigern (noch unvollständig) +// (Implementierung zunächst in Extra-Branch) +// // Revision 1.9 2004/04/13 21:45:45 vrandezo // Akademische Ausbildung (Magier) implementiert // Aufräumarbeiten (besser in Leo integriert) Index: PersonHandlerSteigern.h =================================================================== RCS file: /cvsroot/darkeyetool/det/src/dsa/PersonHandlerSteigern.h,v retrieving revision 1.4 retrieving revision 1.4.2.1 diff -u -d -r1.4 -r1.4.2.1 --- PersonHandlerSteigern.h 13 Apr 2004 21:45:45 -0000 1.4 +++ PersonHandlerSteigern.h 26 Apr 2005 22:59:35 -0000 1.4.2.1 @@ -19,43 +19,94 @@ //@@c #ifdef MSVC -#pragma warning(disable:4786 4503) +# pragma warning(disable:4786 4503) #endif //@-node:<< header >> //@nl #if !defined(PERSONHANDLERSTEIGERN_H) -#define PERSONHANDLERSTEIGERN_H +# define PERSONHANDLERSTEIGERN_H //@<< includes >> //@+node:<< includes >> -#include "PersonHandler.h" +# include "PersonHandler.h" //@nonl //@-node:<< includes >> //@nl -namespace DSA { +namespace DSA +{ + + //@ << class PersonHandlerSteigern >> + //@+node:<< class PersonHandlerSteigern >> + class PersonHandlerSteigern:public PersonHandler + { + public: + PersonHandlerSteigern() + { + } + // { Log::Error("PersonHandler::PersonHandlerSteigern " + _t("nicht implementiert")); } + virtual ~ PersonHandlerSteigern() + { + } + virtual Person *P() + { + return person_.get(); + } + virtual void P(std::auto_ptr < Person > person); + virtual std::auto_ptr < Person > HolePerson() + { + return person_; + } + + virtual std::string HandlerArt() const + { + return "Steigern"; + } + + virtual bool Steigerbar(Eigenschaftsart); + virtual bool Senkbar(Eigenschaftsart); + virtual void Steiger(Eigenschaftsart); + virtual void Senke(Eigenschaftsart); + +// virtual bool TalentAktivierbar(const Talentgruppe gruppe = sonstige); +// virtual void AktivierbareTalente(StringListe&, const Talentgruppe gruppe = sonstige); +// virtual void Aktiviere(const std::string& talent); + virtual bool TalentSteigerbar(const std::string & talent); + virtual bool TalentSenkbar(const std::string & talent); + virtual void TalentSteigern(const std::string & talent); + virtual void TalentSenken(const std::string & talent); + + virtual int AP(); + virtual int APV(); + virtual int AktivierteTalente(); + virtual int AktivierteTalenteMax(); + virtual int AktivierteZauber(); + virtual int AktivierteZauberMax(); + + std::string aptext_; + int Hinzu(const std::string & text, int ap); + + virtual std::string SteigernText(); + + private: + std::auto_ptr < Person > person_; + + int min_werte_eigenschaft[AnzahlEigenschaften]; + Talente backup_talente; + Sprachen backup_sprachen; + Schriften backup_schriften; + Kampftechniken backup_kampftechniken; + Zauberfertigkeiten backup_zauber; + + std::pair < bool, + bool > SpracheOderSchrift(std::string & spracheOderSchrift); + + }; + //@nonl + //@-node:<< class PersonHandlerSteigern >> + //@nl - //@ << class PersonHandlerSteigern >> - //@+node:<< class PersonHandlerSteigern >> - class PersonHandlerSteigern : public PersonHandler { - public: - PersonHandlerSteigern() { Log::Error("PersonHandler::PersonHandlerSteigern " + _t("nicht implementiert")); } - virtual ~PersonHandlerSteigern() {} - virtual Person* P() { return person_.get(); } - virtual void P(std::auto_ptr<Person> person) { person_ = person; } - virtual std::auto_ptr<Person> HolePerson() { return person_; } - - virtual std::string HandlerArt() const { return "Steigern"; } - - private: - std::auto_ptr<Person> person_; - - }; - //@nonl - //@-node:<< class PersonHandlerSteigern >> - //@nl - } #endif // !defined(PERSONHANDLERSTEIGERN_H) @@ -63,6 +114,10 @@ //@<< Version History >> //@+node:<< Version History >> // $Log$ +// Revision 1.4.2.1 2005/04/26 22:59:35 gnaddelwarz +// Man kann jetzt Charaktere steigern (noch unvollständig) +// (Implementierung zunächst in Extra-Branch) +// // Revision 1.4 2004/04/13 21:45:45 vrandezo // Akademische Ausbildung (Magier) implementiert // Aufräumarbeiten (besser in Leo integriert) Index: Texte.h =================================================================== RCS file: /cvsroot/darkeyetool/det/src/dsa/Texte.h,v retrieving revision 1.4 retrieving revision 1.4.2.1 diff -u -d -r1.4 -r1.4.2.1 --- Texte.h 13 Apr 2004 21:45:45 -0000 1.4 +++ Texte.h 26 Apr 2005 22:59:35 -0000 1.4.2.1 @@ -18,51 +18,54 @@ //@@c #ifdef MSVC -#pragma warning(disable:4786 4503) +# pragma warning(disable:4786 4503) #endif //@-node:<< header >> //@nl #if !defined(TEXTE_H) -#define TEXTE_H +# define TEXTE_H //@<< includes >> //@+node:<< includes >> -#include <string> -#include <memory> -#include <map> +# include <string> +# include <memory> +# include <map> //@nonl //@-node:<< includes >> //@nl // irgendwo wurde IN definiert, dass stört hier -#undef IN +# undef IN class wxTextFile; //@<< struct Texte >> //@+node:<< struct Texte >> //! hält alle String-Literale des Programms + /*! Dadurch ist später eine einfache Übersetzung in andere Sprachen möglich. /*/ -struct Texte - { - static void Initialisiere(const std::string& datei = "dettexte.txt"); - static void Deinitialisiere(); +class Texte +{ + public: + static void Initialisiere(const std::string & datei = "dettexte.txt"); + static void Deinitialisiere(); - static std::string Text(const std::string&); + static std::string Text(const std::string &); - private: - //! Versteckter Konstruktor - Texte(const std::string& datei); - //! Destruktor - virtual ~Texte(); + private: + //! Versteckter Konstruktor + Texte(const std::string & datei); + //! Destruktor + virtual ~ Texte(); - std::auto_ptr<wxTextFile> datei_; - std::map<std::string, std::string> lexikon_; + std::auto_ptr < wxTextFile > datei_; + std::map < std::string, std::string > lexikon_; + + static Texte *instanz_; +}; // Texte - static Texte* instanz_; - }; // Texte //@nonl //@-node:<< struct Texte >> //@nl @@ -71,18 +74,25 @@ // Texte-Klasse durchgeführt, was teilweise das Programm recht verlangsamen kann. // Wählte man die zweite Zeile, dann wird stets der Default-Wert verwendet - in // diesem Fall also Deutsch - dafür aber ist das Programm schnell wie eh und jeh. -#ifdef _DEBUG -inline std::string _t(const std::string& t) { return Texte::Text(t); } -#endif -#ifndef _DEBUG -#define _t(T) std::string(T) -#endif +# ifdef _DEBUG +inline std::string _t(const std::string & t) +{ + return Texte::Text(t); +} +# endif +# ifndef _DEBUG +# define _t(T) std::string(T) +# endif #endif // !defined(TEXTE_H) //@<< Version History >> //@+node:<< Version History >> // $Log$ +// Revision 1.4.2.1 2005/04/26 22:59:35 gnaddelwarz +// Man kann jetzt Charaktere steigern (noch unvollständig) +// (Implementierung zunächst in Extra-Branch) +// // Revision 1.4 2004/04/13 21:45:45 vrandezo // Akademische Ausbildung (Magier) implementiert // Aufräumarbeiten (besser in Leo integriert) Index: Person.cpp =================================================================== RCS file: /cvsroot/darkeyetool/det/src/dsa/Person.cpp,v retrieving revision 1.23 retrieving revision 1.23.2.1 diff -u -d -r1.23 -r1.23.2.1 --- Person.cpp 12 Apr 2004 21:08:09 -0000 1.23 +++ Person.cpp 26 Apr 2005 22:59:34 -0000 1.23.2.1 @@ -18,7 +18,7 @@ //@@c #ifdef MSVC -#pragma warning(disable:4786 4503) +# pragma warning(disable:4786 4503) #endif //@-node:<< header >> //@nl @@ -38,444 +38,628 @@ //@<< filename >> //@+node:<< filename >> [...1025 lines suppressed...] + //@nl + + Personen *personen() + { + static Personen *personen_ = new Personen(); + + return personen_; + } } //@<< Version History >> //@+node:<< Version History >> // $Log$ +// Revision 1.23.2.1 2005/04/26 22:59:34 gnaddelwarz +// Man kann jetzt Charaktere steigern (noch unvollständig) +// (Implementierung zunächst in Extra-Branch) +// // Revision 1.23 2004/04/12 21:08:09 vrandezo // Lehrsprachen implementiert // Mutter-/Zweitsprachensystem umgebaut Index: Regeln.h =================================================================== RCS file: /cvsroot/darkeyetool/det/src/dsa/Regeln.h,v retrieving revision 1.8 retrieving revision 1.8.2.1 diff -u -d -r1.8 -r1.8.2.1 --- Regeln.h 13 Apr 2004 21:45:45 -0000 1.8 +++ Regeln.h 26 Apr 2005 22:59:35 -0000 1.8.2.1 @@ -18,81 +18,113 @@ //@@c #ifdef MSVC -#pragma warning(disable:4786 4503) +# pragma warning(disable:4786 4503) #endif //@-node:<< header >> //@nl #if !defined(REGELN_H) -#define REGELN_H +# define REGELN_H //@<< includes >> //@+node:<< includes >> -#include "NDSABasis.h" -#include "Texte.h" -#include <map> +# include "NDSABasis.h" +# include "Texte.h" +# include <map> //@nonl //@-node:<< includes >> //@nl -namespace DSA { - class PersistenzManager; - - //@ << class Regeln >> - //@+node:<< class Regeln >> - class Regeln { - public: - Regeln() { Default(); } - - static std::string Klassen() { return _t("Regeloptionen"); } - static std::string Klasse() { return _t("Regeloption"); } - - void Regel(const std::string& id, int wert) { regel_[id] = wert; } - int Regel(const std::string& id) const; - int operator[](const std::string& id) const { return Regel(id); } - std::string Regel(const int i) const; - std::string operator[](const int i) const { return Regel(i); } - int AnzahlRegeln() const { return regel_.size(); } - - void Regeloption(const std::string& id, bool wert) { regeloption_[id] = wert; } - bool Regeloption(const std::string& id) const; - std::string Regeloption(const int i) const; - int AnzahlRegeloptionen() const { return regeloption_.size(); } - - int SKT(SKTSpalte, int) const; - double Aktivierungsfaktor(DSA::SKTSpalte) const; - SKTSpalte TalentgruppenSKT(Talentgruppe) const; - - void Default(); - - int Lese(PersistenzManager* pm, const std::string& id = ""); - int Schreibe(PersistenzManager* pm) const; - int Pruefe() const; - static int IDListe(PersistenzManager* pm, StringListe* liste); - - private: - std::map<std::string, int> regel_; - std::map<std::string, bool> regeloption_; - double aktivierungsfaktor_[AnzahlSKTSpalten]; - int skt_[AnzahlSKTZeilen][AnzahlSKTSpalten]; // TODO - - // TODO - DSA::SKTSpalte SKTKampf; - DSA::SKTSpalte SKTKoerperlich; - DSA::SKTSpalte SKTGesellschaftlich; - DSA::SKTSpalte SKTNatur; - DSA::SKTSpalte SKTWissen; - DSA::SKTSpalte SKTSprachenUndSchriften; - DSA::SKTSpalte SKTHandwerk; - DSA::SKTSpalte SKTGaben; - - }; // Regeln - //@nonl - //@-node:<< class Regeln >> - //@nl - - Regeln* regeln(); - int regeln(const std::string& id); +namespace DSA +{ + class PersistenzManager; + + //@ << class Regeln >> + //@+node:<< class Regeln >> + class Regeln + { + public: + Regeln() + { + Default(); + } + + static std::string Klassen() + { + return _t("Regeloptionen"); + } + static std::string Klasse() + { + return _t("Regeloption"); + } + + void Regel(const std::string & id, int wert) + { + regel_[id] = wert; + } + int Regel(const std::string & id) const; + int operator[] (const std::string & id) const + { + return Regel(id); + } + std::string Regel(const int i) const; + std::string operator[](const int i) const + { + return Regel(i); + } + int AnzahlRegeln() const + { + return regel_.size(); + } + + void Regeloption(const std::string & id, bool wert) + { + regeloption_[id] = wert; + } + bool Regeloption(const std::string & id) const; + std::string Regeloption(const int i) const; + int AnzahlRegeloptionen() const + { + return regeloption_.size(); + } + + int SKT(SKTSpalte, int) const; + double Aktivierungsfaktor(DSA::SKTSpalte) const; + SKTSpalte TalentgruppenSKT(Talentgruppe) const; + + void Default(); + + int Lese(PersistenzManager * pm, const std::string & id = ""); + int Schreibe(PersistenzManager * pm) const; + int Pruefe() const; + static int IDListe(PersistenzManager * pm, StringListe * liste); + int AP2Stufe(int AP); + int Stufe2AP(int stufe); + + private: + std::map < std::string, int >regel_; + + std::map < std::string, bool > regeloption_; + double aktivierungsfaktor_[AnzahlSKTSpalten]; + int skt_[AnzahlSKTZeilen][AnzahlSKTSpalten]; // TODO + + // TODO + DSA::SKTSpalte SKTKampf; + DSA::SKTSpalte SKTKoerperlich; + DSA::SKTSpalte SKTGesellschaftlich; + DSA::SKTSpalte SKTNatur; + DSA::SKTSpalte SKTWissen; + DSA::SKTSpalte SKTSprachenUndSchriften; + DSA::SKTSpalte SKTHandwerk; + DSA::SKTSpalte SKTGaben; + + }; // Regeln + //@nonl + //@-node:<< class Regeln >> + //@nl + + Regeln *regeln(); + int regeln(const std::string & id); } @@ -101,6 +133,10 @@ //@<< Version History >> //@+node:<< Version History >> // $Log$ +// Revision 1.8.2.1 2005/04/26 22:59:35 gnaddelwarz +// Man kann jetzt Charaktere steigern (noch unvollständig) +// (Implementierung zunächst in Extra-Branch) +// // Revision 1.8 2004/04/13 21:45:45 vrandezo // Akademische Ausbildung (Magier) implementiert // Aufräumarbeiten (besser in Leo integriert) --- NEW FILE: PersonHandlerSteigern.cpp --- // PersonHandlerGenerator.cpp: Implementierung der // Heldenerschaffung // // $Revision: 1.1.2.1 $ // $Date: 2005/04/26 22:59:35 $ // The content of this file is subject to the license // given in license.txt // #include "PersonHandlerSteigern.h" #ifdef _DEBUG # undef THIS_FILE static char THIS_FILE[] = __FILE__; //#define new DEBUG_NEW #endif namespace DSA { void PersonHandlerSteigern::P(std::auto_ptr < Person > person) { person_ = person; for (int i = 0; i != AnzahlEigenschaften; ++i) min_werte_eigenschaft[i] = P()->Wert(static_cast < Eigenschaftsart > (i)); backup_talente = P()->talente_; backup_sprachen = P()->sprachen_; backup_schriften = P()->schriften_; backup_kampftechniken = P()->kampftechniken_; backup_zauber = P()->zauberfertigkeiten_; } bool PersonHandlerSteigern::Steigerbar(Eigenschaftsart e) { int kosten = regeln()->SKT(H, P()->Basiswert(e) + 1); std::string s = _t("Miserable Eigenschaft") + " " + EigenschaftString(e); if (P()->charakteristika_.Existiert(s)) // doppelte Kosten kosten *= 2; return ((P()->Wert(e) < P()->Maximalwert(e)) && (person_.get()->APG() >= kosten)); } // Steigerbar bool PersonHandlerSteigern::Senkbar(Eigenschaftsart e) { return (P()->Wert(e) > min_werte_eigenschaft[static_cast < int >(e)]); } // Senkbar void PersonHandlerSteigern::Steiger(Eigenschaftsart e) { if (!Steigerbar(e)) return; PersonHandler::Steiger(e); std::string s = _t("Miserable Eigenschaft") + " " + EigenschaftString(e); P()->VerbraucheAPG(regeln()->SKT(H, P()->Basiswert(e))); if (P()->charakteristika_.Existiert(s)) // doppelte Kosten P()->VerbraucheAPG(regeln()->SKT(H, P()->Basiswert(e))); // else { // s = _t("Herausragende Eigenschaft") + " " + EigenschaftString(e); // if (!P()->charakteristika_.Existiert(s)) // FuegeHinzu(s); // else // CharakteristikumSteigern(s); // } } // Steiger void PersonHandlerSteigern::Senke(Eigenschaftsart e) { // std::string s = _t("Herausragende Eigenschaft") + " " + EigenschaftString(e); // if (P()->charakteristika_.Existiert(s)) // CharakteristikumSenken(s); // else if (regeln("Minimaler Startwert einer Eigenschaft")<P()->Basiswert(e)) if (!Senkbar(e)) return; std::string s = _t("Miserable Eigenschaft") + " " + EigenschaftString(e); P()->VerbraucheAPG(-regeln()->SKT(H, P()->Basiswert(e))); if (P()->charakteristika_.Existiert(s)) // doppelte Kosten P()->VerbraucheAPG(-regeln()->SKT(H, P()->Basiswert(e))); PersonHandler::Senke(e); } // Senke bool PersonHandlerSteigern::TalentSteigerbar(const std::string & talent) { SKTSpalte spalte; // Talente if (P()->talente_.Existiert(talent)) { Talent *t = P()->talente_.Zeige(talent); spalte = P()->talente_.Hole(talent).SKTSpalte_(); // genug TGP? int aktbis = 1; if (t->Art() == Basis) aktbis = 0; if (t->Wert() < aktbis) { if (regeln()->Aktivierungsfaktor(spalte) * P()->Stufe() * P()->Stufe() > (P()->APG())) return false; } else { if (regeln()->SKT(spalte, t->Wert() + 1) > (P()->APG())) return false; } return (t->Wert() < t->Maximalwert()); } // Kampftechniken if (P()->kampftechniken_.Existiert(talent)) { Kampftechnik *k = P()->kampftechniken_.Zeige(talent); spalte = P()->kampftechniken_.Hole(talent).SKTSpalte_(); // genug TGP? int aktbis = 1; if (k->Art() == Basis) aktbis = 0; if (k->Wert() < aktbis) { if (regeln()->Aktivierungsfaktor(spalte) * P()->Stufe() * P()->Stufe() > (P()->APG())) return false; } else { if (regeln()->SKT(spalte, k->Wert() + 1) > (P()->APG())) return false; } return (k->Wert() < k->Maximalwert()); } // Sprachen und Schriften std::string temptal = talent; std::pair < bool, bool > rv = SpracheOderSchrift(temptal); if (rv.first) { if (rv.second) { // ist eine Sprache if (P()->sprachen_.Existiert(temptal)) { spalte = sprachen()->Hole(temptal).SKTSpalte_(); Sprache *s = P()->sprachen_.Zeige(temptal); if (P()->charakteristika_. Existiert(_t("Unfähigkeit für") + " " + _t("Sprachen"))) spalte = SpalteSchwerer(spalte); if (s->Wert() < 1) { if (regeln()->Aktivierungsfaktor(spalte) * P()->Stufe() * P()->Stufe() > (P()->APG())) return false; } else { if (regeln()->SKT(spalte, s->Wert() + 1) > (P()->APG())) return false; } int talwert = s->Wert(); // Komplexität if (sprachen()->Hole(temptal).Komplexitaet() <= talwert) return false; int maxeigwert = max(P()->Wert(Klugheit), P()->Wert(Intuition), P()->Wert(Charisma)); // TODO Magische Eigenschaften return (talwert < maxeigwert + 3); // TODO Magische Zahl } } else { // ist eine Schrift if (P()->schriften_.Existiert(temptal)) { spalte = schriften()->Hole(temptal).SKTSpalte_(); Schrift *s = P()->schriften_.Zeige(temptal); if (s->Wert() < 1) { if (regeln()->Aktivierungsfaktor(spalte) * P()->Stufe() * P()->Stufe() > (P()->APG())) return false; } else { if (regeln()->SKT(spalte, s->Wert() + 1) > (P()->APG())) return false; } int talwert = s->Wert(); // Komplexität if (schriften()->Hole(temptal).Komplexitaet() <= talwert) return false; if (talente()->Zeige(_t("Lesen / Schreiben")) == 0) return true; // Wenn das Talent fehlt int maxeigwert = max(P()->Wert(talente()-> Zeige(_t("Lesen / Schreiben"))-> Eigenschaft(0)), P()->Wert(talente()-> Zeige(_t("Lesen / Schreiben"))-> Eigenschaft(1)), P()->Wert(talente()-> Zeige(_t("Lesen / Schreiben"))-> Eigenschaft(2))); return (talwert < maxeigwert + 3); // TODO Magische Zahl } } } // Zauber if (P()->zauberfertigkeiten_.Existiert(talent)) { // hindernde Unfaehigkeiten? TODO //if ((P()->charakteristika_.Existiert(_t("Unfähigkeit für") + " " + talent)) // ||(P()->charakteristika_.Existiert(_t("Unfähigkeit für") + " " + TalentgruppeString(P()->talente_.Zeige(talent)->Gruppe(), false)))) // return false; Zauberfertigkeit *z = P()->zauberfertigkeiten_.Zeige(talent); spalte = z->Lernschwierigkeit(); // genug TGP? if (z->Wert() < 1) { if (regeln()->Aktivierungsfaktor(spalte) * 5 * P()->Stufe() > (P()->APG())) return false; } else { if (regeln()->SKT(spalte, z->Wert() + 1) > (P()->APG())) return false; } return (z->Wert() < z->Maximalwert()); } // wenn nicht bisher abgehandelt: return false; } // TalentSteigerbar void PersonHandlerSteigern::TalentSteigern(const std::string & talent) { SKTSpalte spalte; int kosten; if (!TalentSteigerbar(talent)) { Log::Debug("PersonHandlerGenerator::TalentSteigern: " + _t("Konnte Talent nicht steigern.")); return; } if (talente()->Existiert(talent)) { Talent *t = P()->talente_.Zeige(talent); spalte = t->SKTSpalte_(); t->Wert(t->Wert() + 1); int aktbis = 1; if (t->Art() == Basis) aktbis = 0; if (t->Wert() <= aktbis) { kosten = regeln()->Aktivierungsfaktor(spalte) * P()->Stufe() * P()->Stufe(); } else { kosten = regeln()->SKT(spalte, t->Wert()); } P()->VerbraucheAPG(kosten); return; } if (kampftechniken()->Existiert(talent)) { Kampftechnik *k = P()->kampftechniken_.Zeige(talent); spalte = k->SKTSpalte_(); k->Wert(k->Wert() + 1); int aktbis = 1; if (k->Art() == Basis) aktbis = 0; if (k->Wert() <= aktbis) { kosten = regeln()->Aktivierungsfaktor(spalte) * P()->Stufe() * P()->Stufe(); } else { kosten = regeln()->SKT(spalte, k->Wert()); } P()->VerbraucheAPG(kosten); return; } std::string temptal = talent; std::pair < bool, bool > rv = SpracheOderSchrift(temptal); if (rv.first) { if (rv.second) { if (sprachen()->Existiert(temptal)) { Sprache *s = P()->sprachen_.Zeige(temptal); spalte = s->SKTSpalte_(); if (P()->charakteristika_. Existiert(_t("Unfähigkeit für") + " " + _t("Sprachen"))) spalte = SpalteSchwerer(spalte); s->Wert(s->Wert() + 1); if (s->Wert() <= 1) { kosten = regeln()->Aktivierungsfaktor(spalte) * P()->Stufe() * P()->Stufe(); } else { kosten = regeln()->SKT(spalte, s->Wert()); } P()->VerbraucheAPG(kosten); return; } } else { if (schriften()->Existiert(temptal)) { Schrift *s = P()->schriften_.Zeige(temptal); spalte = s->SKTSpalte_(); s->Wert(s->Wert() + 1); if (s->Wert() <= 1) { kosten = regeln()->Aktivierungsfaktor(spalte) * P()->Stufe() * P()->Stufe(); } else { kosten = regeln()->SKT(spalte, s->Wert()); } P()->VerbraucheAPG(kosten); return; } } } if (P()->zauberfertigkeiten_.Existiert(talent)) { Zauberfertigkeit *z = P()->zauberfertigkeiten_.Zeige(talent); spalte = z->Lernschwierigkeit(); z->Wert(z->Wert() + 1); if (z->Wert() <= 1) { kosten = regeln()->Aktivierungsfaktor(spalte) * 5 * P()->Stufe(); } else { kosten = regeln()->SKT(spalte, z->Wert()); } P()->VerbraucheAPG(kosten); return; } } // TalentSteigern std::pair < bool, bool > PersonHandlerSteigern::SpracheOderSchrift(std:: string & spracheOderSchrift) { std::pair < bool, bool > rv; rv.first = true; if (spracheOderSchrift.find(":") >= spracheOderSchrift.size()) { rv.first = false; return rv; } rv.second = !(spracheOderSchrift.substr(0, spracheOderSchrift.find(":")) == _t("Lesen / Schreiben")); spracheOderSchrift = spracheOderSchrift.substr(spracheOderSchrift.find(":") + 2, spracheOderSchrift.size() - (spracheOderSchrift.find(":") + 2)); return rv; } // SpracheOderSchrift bool PersonHandlerSteigern::TalentSenkbar(const std::string & talent) { if (P()->kampftechniken_.Existiert(talent)) { if (!backup_kampftechniken.Existiert(talent)) return false; return (P()->kampftechniken_.Zeige(talent)->Wert() > backup_kampftechniken.Zeige(talent)->Wert()); } if (P()->talente_.Existiert(talent)) { if (!backup_talente.Existiert(talent)) return false; return (P()->talente_.Zeige(talent)->Wert() > backup_talente.Zeige(talent)->Wert()); } std::string temptal = talent; std::pair < bool, bool > rv = SpracheOderSchrift(temptal); if (rv.first) { if (rv.second) { if (P()->sprachen_.Existiert(temptal)) { if (!backup_sprachen.Existiert(temptal)) return false; return (P()->sprachen_.Zeige(temptal)->Wert() > backup_sprachen.Zeige(temptal)->Wert()); } } else { if (P()->schriften_.Existiert(temptal)) { if (!backup_schriften.Existiert(temptal)) return false; return (P()->schriften_.Zeige(temptal)->Wert() > backup_schriften.Zeige(temptal)->Wert()); } } } if (P()->zauberfertigkeiten_.Existiert(talent)) { if (!backup_zauber.Existiert(talent)) return false; return (P()->zauberfertigkeiten_.Zeige(talent)->Wert() > backup_zauber.Zeige(talent)->Wert()); } return false; } // TalentSenkbar void PersonHandlerSteigern::TalentSenken(const std::string & talent) { SKTSpalte spalte; int kosten; if (!TalentSenkbar(talent)) { Log::Debug("PersonHandlerGenerator::TalentSenken: " + _t("Konnte Talent nicht senken.")); return; } if (talente()->Existiert(talent)) { Talent *t = P()->talente_.Zeige(talent); spalte = t->SKTSpalte_(); int aktbis = 1; if (t->Art() == Basis) aktbis = 0; if (t->Wert() <= aktbis) { kosten = regeln()->Aktivierungsfaktor(spalte) * P()->Stufe() * P()->Stufe(); } else { kosten = regeln()->SKT(spalte, t->Wert()); } P()->VerbraucheAPG(-kosten); t->Wert(t->Wert() - 1); return; } if (kampftechniken()->Existiert(talent)) { Kampftechnik *k = P()->kampftechniken_.Zeige(talent); spalte = k->SKTSpalte_(); int aktbis = 1; if (k->Art() == Basis) aktbis = 0; if (k->Wert() <= aktbis) { kosten = regeln()->Aktivierungsfaktor(spalte) * P()->Stufe() * P()->Stufe(); } else { kosten = regeln()->SKT(spalte, k->Wert()); } P()->VerbraucheAPG(-kosten); k->Wert(k->Wert() - 1); return; } std::string temptal = talent; std::pair < bool, bool > rv = SpracheOderSchrift(temptal); if (rv.first) { if (rv.second) { if (sprachen()->Existiert(temptal)) { Sprache *s = P()->sprachen_.Zeige(temptal); spalte = s->SKTSpalte_(); if (s->Wert() <= 1) { kosten = regeln()->Aktivierungsfaktor(spalte) * P()->Stufe() * P()->Stufe(); } else { kosten = regeln()->SKT(spalte, s->Wert()); } P()->VerbraucheAPG(-kosten); s->Wert(s->Wert() - 1); return; } } else { if (schriften()->Existiert(temptal)) { Schrift *s = P()->schriften_.Zeige(temptal); spalte = s->SKTSpalte_(); if (s->Wert() <= 1) { kosten = regeln()->Aktivierungsfaktor(spalte) * P()->Stufe() * P()->Stufe(); } else { kosten = regeln()->SKT(spalte, s->Wert()); } P()->VerbraucheAPG(-kosten); s->Wert(s->Wert() - 1); return; } } } if (P()->zauberfertigkeiten_.Existiert(talent)) { Zauberfertigkeit *z = P()->zauberfertigkeiten_.Zeige(talent); spalte = z->Lernschwierigkeit(); if (z->Wert() <= 1) { kosten = regeln()->Aktivierungsfaktor(spalte) * P()->Stufe() * P()->Stufe(); } else { kosten = regeln()->SKT(spalte, z->Wert()); } P()->VerbraucheAPG(-kosten); z->Wert(z->Wert() - 1); return; } } // TalentSenken int PersonHandlerSteigern::APV() { if (P()) return P()->APV(); else return 0; } int PersonHandlerSteigern::AP() { if (P()) return P()->AP(); else return 0; } int PersonHandlerSteigern::AktivierteTalente() { return 0; } int PersonHandlerSteigern::AktivierteTalenteMax() { return 0; } int PersonHandlerSteigern::AktivierteZauber() { return 0; } int PersonHandlerSteigern::AktivierteZauberMax() { return 0; } int PersonHandlerSteigern::Hinzu(const std::string & text, int ap) { aptext_ += text; return 0; } std::string PersonHandlerSteigern::SteigernText() { if (AP() == APV()) return (_t("Alle Abenteuerpunkte verteilt")); else return (_t("Es sind noch Abenteuerpunkte übrig")); } } // $Log: PersonHandlerSteigern.cpp,v $ // Revision 1.1.2.1 2005/04/26 22:59:35 gnaddelwarz // Man kann jetzt Charaktere steigern (noch unvollständig) // (Implementierung zunächst in Extra-Branch) // |
Thanks for helping keep SourceForge clean.
X