1 files changed, 22 insertions, 418 deletions

diff --git a/sigencore/TeamMember.cpp b/sigencore/TeamMember.cpp
index 4f3937db..414809af 100644
--- a/sigencore/TeamMember.cpp
+++ b/sigencore/TeamMember.cpp
@@ -51,8 +51,6 @@
 // C includes
 #include <cmath>
 
-QMap<Sigencore::TeamMember::StyleLevel, long long> Sigencore::TeamMember::m_expCache;
-
 int Sigencore::actionPriority(TeamMember* teamMember, const TeamMember::Action& action)
 {
     int priority = INT_MAX;
@@ -95,26 +93,14 @@ int Sigencore::actionPriority(TeamMember* teamMember, const TeamMember::Action&
     return priority;
 }
 
-Sigencore::TeamMember::TeamMember(Sigscript::SpeciesWrapper* species, const int level, Containment* containment, const bool isWild, const bool suppressInitialization) :
-        Sigscript::Config(containment),
-        m_sigmod(containment->sigmod()),
-        m_containment(containment),
+Sigencore::TeamMember::TeamMember(Sigscript::SpeciesWrapper* species, const int level, Team* team, const bool isWild, const bool suppressInitialization) :
+        Creature(species, level, team, suppressInitialization),
+        m_team(team),
         m_arena(NULL),
-        m_species(species),
-        m_gender(Undecided),
-        m_level(level),
-        m_levelExp(calcLevelExperience(species->growth(), level)),
-        m_id(QUuid::createUuid())
+        m_isWild(isWild)
 {
-    for (int i = 0; i < (Sigmod::ST_SpecialDefense - Sigmod::ST_HP + 1); ++i)
-    {
-        m_dv[i] = -1;
-        m_statExp[i] = -1;
-    }
     for (int i = 0; i < (Sigmod::ST_SpecialDefense - Sigmod::ST_Attack + 1); ++i)
         m_stages[i] = 0;
-    if (!suppressInitialization)
-        completeData(isWild);
 }
 
 Sigencore::TeamMember::~TeamMember()
@@ -124,260 +110,29 @@ Sigencore::TeamMember::~TeamMember()
     // TODO: Clean up scripts
 }
 
-QUuid Sigencore::TeamMember::id() const
-{
-    return m_id;
-}
-
-Sigscript::SigmodWrapper* Sigencore::TeamMember::sigmod() const
-{
-    return m_sigmod;
-}
-
-void Sigencore::TeamMember::setContainment(Containment* containment)
+bool Sigencore::TeamMember::setContainment(Containment* containment)
 {
+    Team* team = qobject_cast<Team*>(containment);
+    if (team)
+        setTeam(team);
     m_containment->removeMember(this);
     m_containment = containment;
 }
 
-Sigencore::Containment* Sigencore::TeamMember::containment() const
-{
-    return m_containment;
-}
-
-Sigscript::SpeciesWrapper* Sigencore::TeamMember::species() const
-{
-    return m_species;
-}
-
-void Sigencore::TeamMember::setName(const QString& name)
-{
-    m_name = name;
-    emit(nameChanged(m_name));
-}
-
-QString Sigencore::TeamMember::name() const
-{
-    return m_name;
-}
-
-bool Sigencore::TeamMember::setGender(const Gender gender)
+bool Sigencore::TeamMember::setTeam(Team* team)
 {
-    if (!m_sigmod->rules()->genderAllowed())
-        return false;
-    const Sigcore::Fraction genderFactor = m_species->genderFactor();
-    switch (gender)
+    if (m_team && m_team->removeTeamMember(this))
     {
-        case Male:
-            if (1 <= genderFactor)
-                return false;
-            break;
-        case Female:
-            if (genderFactor <= 0)
-                return false;
-            break;
-        case Genderless:
-            if (0 <= genderFactor)
-                return false;
-            break;
-        default:
-            return false;
-    }
-    m_gender = gender;
-    emit(genderChanged(m_gender));
-    return true;
-}
-
-Sigencore::TeamMember::Gender Sigencore::TeamMember::gender() const
-{
-    return m_gender;
-}
-
-bool Sigencore::TeamMember::setLevel(const int level)
-{
-    if ((level <= 0) || (m_sigmod->rules()->maxLevel() < level))
-        return false;
-    m_level = level;
-    m_levelExp = calcLevelExperience(m_species->growth(), m_level);
-    emit(levelChanged(level));
-    emit(levelExperienceChanged(m_levelExp));
-    return true;
-}
-
-bool Sigencore::TeamMember::giveLevels(const int levels)
-{
-    return setLevel(m_level + levels);
-}
-
-int Sigencore::TeamMember::level() const
-{
-    return m_level;
-}
-
-int Sigencore::TeamMember::calcLevel(const Sigmod::Species::Style growth, const long long levelExp)
-{
-    int level = -1;
-    while (calcLevelExperience(growth, level + 1) < levelExp)
-        ++level;
-    return level;
-}
-
-bool Sigencore::TeamMember::setLevelExperience(const long long levelExp)
-{
-    if (levelExp < 0)
-        return false;
-    const int level = calcLevel(m_species->growth(), levelExp);
-    if ((level <= 0) || (m_sigmod->rules()->maxLevel() < level))
-        return false;
-    m_levelExp = levelExp;
-    if (level != m_level)
-    {
-        m_level = level;
-        emit(levelChanged(level));
-    }
-    emit(levelExperienceChanged(m_levelExp));
-    return true;
-}
-
-bool Sigencore::TeamMember::giveLevelExperience(const long long levelExp)
-{
-    return setLevelExperience(m_levelExp + levelExp);
-}
-
-long long Sigencore::TeamMember::levelExperience() const
-{
-    return m_levelExp;
-}
-
-long long Sigencore::TeamMember::calcLevelExperience(const Sigmod::Species::Style growth, const int level)
-{
-    if (m_expCache.contains(StyleLevel(growth, level)))
-        return m_expCache[StyleLevel(growth, level)];
-    const long long square = level * level;
-    const long long cube = square * level;
-    long long exp = -1;
-    switch (growth)
-    {
-        case Sigmod::Species::Fluctuating:
-            if (level <= 15)
-                exp = cube * ((24 + (level + 1) / 3) / 50.);
-            else if (level <= 35)
-                exp = cube * ((14 + level) / 50.);
-            else if (level <= 100)
-                exp = cube * ((32 + (level / 2)) / 50.);
-            // TODO: better way for further growth?
-            else if (level <= 102)
-                exp = cube * (23 + level) / 75;
-            else
-                exp = 5 * cube / 3;
-            break;
-        case Sigmod::Species::Fading:
-            exp = 6 * cube / 5 - 15 * square + 100 * level - 140;
-            break;
-        case Sigmod::Species::Slow:
-            exp = 5 * cube / 4;
-            break;
-        case Sigmod::Species::Normal:
-            exp = cube;
-            break;
-        case Sigmod::Species::Fast:
-            exp = 4 * cube / 5;
-            break;
-        case Sigmod::Species::Erratic:
-        {
-            const double p[] = {0.000, 0.008, 0.014};
-            if (level <= 50)
-                exp = cube * ((100 - level) / 50.);
-            else if (level <= 68)
-                exp = cube * ((150 - level) / 100.);
-            else if (level <= 98)
-                exp = cube * (1.274 - (level / 3) / 50. - p[level % 3]);
-            else if (level <= 100)
-                exp = cube * ((160 - level) / 100.);
-            // TODO: better way for further growth?
-            else
-                exp = 3 * cube / 5;
-            break;
-        }
-        default:
-            break;
-    }
-    if (0 <= exp)
-        m_expCache[StyleLevel(growth, level)] = exp;
-    return exp;
-}
-
-bool Sigencore::TeamMember::setCurrentHp(const int hp)
-{
-    if ((hp < 0) || (statValue(Sigmod::ST_HP) < hp))
-        return false;
-    m_currentHp = hp;
-    emit(currentHpChanged(m_currentHp));
-    if (!m_currentHp)
-        emit(knockedOut());
-    return true;
-}
-
-bool Sigencore::TeamMember::changeCurrentHp(const int hp)
-{
-    return setCurrentHp(m_currentHp + hp);
-}
-
-int Sigencore::TeamMember::currentHp() const
-{
-    return m_currentHp;
-}
-
-bool Sigencore::TeamMember::setDv(const Sigmod::Stat stat, const int dv)
-{
-    if ((stat == Sigmod::ST_SpecialDefense) && !(m_sigmod->rules()->specialSplit() && m_sigmod->rules()->specialDVSplit()))
-        return false;
-    m_dv[stat] = dv;
-    emit(dvChanged(stat, dv));
-    return true;
-}
-
-int Sigencore::TeamMember::dv(const Sigmod::Stat stat) const
-{
-    if ((stat == Sigmod::ST_Accuracy) || (stat == Sigmod::ST_Evasion))
-        return false;
-    Sigmod::Stat actualStat = stat;
-    if (stat == Sigmod::ST_SpecialDefense)
-    {
-        if (m_sigmod->rules()->specialSplit() && m_sigmod->rules()->specialDVSplit())
-            actualStat = Sigmod::ST_Special;
-        else
-            return false;
-    }
-    int dv;
-    if (valueOfType(QString("stat-dv-%1").arg((m_sigmod->rules()->specialSplit() ? Sigmod::StatGSCStr : Sigmod::StatRBYStr)[actualStat]), &dv) && (dv < (m_sigmod->rules()->specialDVSplit() ? 32 : 16)))
-        return dv;
-    return m_dv[actualStat];
-}
-
-bool Sigencore::TeamMember::setStatExperience(const Sigmod::Stat stat, const long long statExp)
-{
-    if ((stat == Sigmod::ST_Accuracy) || (stat == Sigmod::ST_Evasion) || ((stat == Sigmod::ST_SpecialDefense) && !m_sigmod->rules()->specialSplit()))
-        return false;
-    if (m_sigmod->rules()->effortValuesAllowed())
-    {
-        int evSum = statExp;
-        for (int i = Sigmod::ST_HP; i <= (m_sigmod->rules()->specialSplit() ? Sigmod::ST_Special : Sigmod::ST_SpecialDefense); ++i)
-        {
-            if (i != stat)
-                evSum += m_statExp[i];
-        }
-        if ((m_sigmod->rules()->maxEVPerStat() < statExp) || (m_sigmod->rules()->maxTotalEV() < evSum))
-            return false;
+        m_team = team;
+        m_containment = team;
+        return true;
     }
-    m_statExp[stat] = statExp;
-    emit(statExperienceChanged(stat, m_statExp[stat]));
-    return true;
+    return false;
 }
 
-bool Sigencore::TeamMember::giveStatExperience(const Sigmod::Stat stat, const long long statExp)
+Sigencore::Team* Sigencore::TeamMember::team() const
 {
-    return setStatExperience(stat, m_statExp[stat] + statExp);
+    return m_team;
 }
 
 bool Sigencore::TeamMember::setStatStage(const Sigmod::Stat stat, const int stage)
@@ -398,13 +153,6 @@ bool Sigencore::TeamMember::giveStatStages(const Sigmod::Stat stat, const int st
     return setStatStage(stat, m_stages[stat - Sigmod::ST_Attack] + stages);
 }
 
-long long Sigencore::TeamMember::statExperience(const Sigmod::Stat stat) const
-{
-    long long exp = m_statExp[stat];
-    valueOfType(QString("stat-experience-%1").arg((m_sigmod->rules()->specialSplit() ? Sigmod::StatGSCStr : Sigmod::StatRBYStr)[stat]), &exp);
-    return exp;
-}
-
 int Sigencore::TeamMember::statStage(const Sigmod::Stat stat) const
 {
     int stages;
@@ -418,58 +166,12 @@ int Sigencore::TeamMember::statStage(const Sigmod::Stat stat) const
 int Sigencore::TeamMember::statValue(const Sigmod::Stat stat) const
 {
     Sigcore::Fraction multiplier;
-    if (stat != Sigmod::ST_HP)
-    {
-        foreach (Sigscript::NatureWrapper* nature, m_natures)
-            multiplier *= nature->stat(stat);
-    }
     const int stage = statStage(stat);
     if (0 < stage)
         multiplier *= Sigcore::Fraction(stage + 2, 2);
     else if (stage < 0)
         multiplier *= Sigcore::Fraction(2, stage + 2);
-    return calcStat(m_sigmod, stat, m_level, m_species->baseStat(stat), dv(stat), statExperience(stat), multiplier);
-}
-
-int Sigencore::TeamMember::calcStat(Sigscript::SigmodWrapper* sigmod, const Sigmod::Stat stat, const int level, const int baseStat, const int dv, const int statExp, const Sigcore::Fraction& multiplier)
-{
-    int statValue = statExp;
-    if (!sigmod->rules()->effortValuesAllowed() && statValue)
-        statValue = sqrt(statValue - 1) + 1;
-    statValue >>= 2;
-    statValue += baseStat << 1;
-    if (sigmod->rules()->specialDVSplit())
-        statValue += dv << 1;
-    else
-        statValue += dv;
-    statValue *= double(level) / sigmod->rules()->maxLevel();
-    if (stat == Sigmod::ST_HP)
-        statValue += 10 + level;
-    else
-        statValue += 5;
-    return statValue * multiplier;
-}
-
-void Sigencore::TeamMember::recalcStats()
-{
-    // FIXME?
-    recalcStat(Sigmod::ST_HP);
-    recalcStat(Sigmod::ST_Attack);
-    recalcStat(Sigmod::ST_Defense);
-    recalcStat(Sigmod::ST_Speed);
-    if (m_sigmod->rules()->specialSplit())
-    {
-        recalcStat(Sigmod::ST_SpecialAttack);
-        recalcStat(Sigmod::ST_SpecialDefense);
-    }
-    else
-        recalcStat(Sigmod::ST_Special);
-}
-
-void Sigencore::TeamMember::recalcStat(const Sigmod::Stat stat)
-{
-    // FIXME?
-    emit(statValueChanged(stat, statValue(stat)));
+    return multiplier * Creature::statValue(stat);
 }
 
 bool Sigencore::TeamMember::addAbility(Sigscript::AbilityWrapper* ability)
@@ -523,29 +225,9 @@ bool Sigencore::TeamMember::removeAbility(Sigscript::AbilityWrapper* ability)
     return false;
 }
 
-QList<Sigscript::AbilityWrapper*> Sigencore::TeamMember::abilities() const
-{
-    return m_abilities;
-}
-
-bool Sigencore::TeamMember::hasAbility(Sigscript::AbilityWrapper* ability) const
-{
-    return m_abilities.contains(ability);
-}
-
 bool Sigencore::TeamMember::addItems(Sigscript::ItemWrapper* item, const int count, const bool allOrNothing)
 {
-    // TODO
-}
-
-QList<Sigscript::ItemWrapper*> Sigencore::TeamMember::items() const
-{
-    return m_items;
-}
-
-int Sigencore::TeamMember::hasItem(Sigscript::ItemWrapper* item) const
-{
-    return m_items.count(item);
+    // TODO: Handle scripts
 }
 
 bool Sigencore::TeamMember::addMove(Sigscript::MoveWrapper* move)
@@ -593,16 +275,6 @@ bool Sigencore::TeamMember::removeMove(Sigscript::MoveWrapper* move)
     return false;
 }
 
-QList<Sigscript::MoveWrapper*> Sigencore::TeamMember::moves() const
-{
-    return m_moves;
-}
-
-bool Sigencore::TeamMember::hasMove(Sigscript::MoveWrapper* move) const
-{
-    return m_moves.contains(move);
-}
-
 bool Sigencore::TeamMember::addNature(Sigscript::NatureWrapper* nature)
 {
     if ((m_natures.size() < m_sigmod->rules()->maxNatures()) && !m_natures.contains(nature))
@@ -625,16 +297,6 @@ bool Sigencore::TeamMember::removeNature(Sigscript::NatureWrapper* nature)
     return false;
 }
 
-QList<Sigscript::NatureWrapper*> Sigencore::TeamMember::natures() const
-{
-    return m_natures;
-}
-
-bool Sigencore::TeamMember::hasNature(Sigscript::NatureWrapper* nature) const
-{
-    return m_natures.contains(nature);
-}
-
 bool Sigencore::TeamMember::addStatus(Sigscript::StatusWrapper* status)
 {
     if (!m_status.contains(status))
@@ -686,16 +348,6 @@ bool Sigencore::TeamMember::removeStatus(Sigscript::StatusWrapper* status)
     return false;
 }
 
-QList<Sigscript::StatusWrapper*> Sigencore::TeamMember::status() const
-{
-    return m_status;
-}
-
-bool Sigencore::TeamMember::hasStatus(Sigscript::StatusWrapper* status) const
-{
-    return m_status.contains(status);
-}
-
 void Sigencore::TeamMember::makeActive(Arena* arena)
 {
     // TODO
@@ -750,69 +402,21 @@ void Sigencore::TeamMember::exitArena()
     m_arena = NULL;
 }
 
-void Sigencore::TeamMember::completeData(const bool useWild)
+void Sigencore::TeamMember::completeMoves()
 {
-    // TODO
-    if (!m_name.isEmpty())
-        m_name = m_species->name();
-    if (m_gender == Undecided)
-    {
-        if (!m_sigmod->rules()->genderAllowed() || (m_species->genderFactor() < 0))
-            m_gender = Genderless;
-        else
-            m_gender = (m_species->genderFactor().poll() ? Female : Male);
-    }
-    if (m_sigmod->rules()->specialSplit() && m_sigmod->rules()->specialDVSplit())
-    {
-        for (int i = Sigmod::ST_HP; i <= Sigmod::ST_SpecialDefense; ++i)
-            m_dv[i] = qrand() & 31;
-    }
-    else
-    {
-        for (int i = Sigmod::ST_Attack; i <= Sigmod::ST_Special; ++i)
-            m_dv[i] = qrand() & 15;
-        m_dv[Sigmod::ST_HP] = ((m_dv[Sigmod::ST_Attack] & 1) << 3) + ((m_dv[Sigmod::ST_Defense] & 1) << 2) + ((m_dv[Sigmod::ST_Speed] & 1) << 1) + (m_dv[Sigmod::ST_Special] & 1);
-    }
-    Sigcore::Hat<Sigscript::AbilityWrapper*> abilityHat = m_species->abilityHat();
-    while ((m_abilities.size() < sigmod()->rules()->maxAbilities()) && abilityHat.count())
-        addAbility(abilityHat.takeAndClear());
-    Sigcore::Hat<Sigscript::ItemWrapper*> itemHat = m_species->itemHat();
-    int i = 0;
-    while ((i < m_sigmod->rules()->maxHeldItems()) && itemHat.count())
-    {
-        if (m_species->itemChance().poll())
-        {
-            Sigscript::ItemWrapper* item = itemHat.pick();
-            if (addItems(item, 1))
-                ++i;
-            else
-                itemHat.setCount(item, 0);
-        }
-        else
-            ++i;
-    }
     QMap<int, Sigscript::MoveWrapper*> moves;
-    for (i = 0; i < m_species->moveCount(); ++i)
+    for (int i = 0; i < m_species->moveCount(); ++i)
     {
         Sigscript::SpeciesMoveWrapper* move = m_species->move(i);
-        const int level = useWild ? move->wild() : move->level();
+        const int level = m_isWild ? move->wild() : move->level();
         if ((0 <= level) && (level <= m_level))
             moves[level] = move->move();
     }
     // TODO: give the moves to the creature
-    Sigcore::Hat<Sigscript::NatureWrapper*> natureHat = sigmod()->natureHat();
-    while ((m_natures.size() < m_sigmod->rules()->maxNatures()) && natureHat.count())
-        addNature(natureHat.takeAndClear());
-    makeConnections();
-    emit(initialized());
 }
 
 void Sigencore::TeamMember::makeConnections()
 {
-    connect(this, SIGNAL(levelChanged(int)), SLOT(recalcStats()));
-    connect(this, SIGNAL(natureAdded(Sigscript::NatureWrapper*)), SLOT(recalcStats()));
-    connect(this, SIGNAL(natureRemoved(Sigscript::NatureWrapper*)), SLOT(recalcStats()));
-    connect(this, SIGNAL(dvChanged(Sigmod::Stat, int)), SLOT(recalcStat(Sigmod::Stat)));
-    connect(this, SIGNAL(statExperienceChanged(Sigmod::Stat, long long)), SLOT(recalcStat(Sigmod::Stat)));
     connect(this, SIGNAL(statStageChanged(Sigmod::Stat, int)), SLOT(recalcStat(Sigmod::Stat)));
+    Creature::makeConnections();
 }