Support changing species for a creature.

Signed-off-by: Deukhoofd <Deukhoofd@gmail.com>

CInterface/Battling/Creature.cpp

@@ -22,6 +22,10 @@ BORROWED_GET_FUNC(Creature, GetLibrary, const CreatureLib::Battling::BattleLibra
 BORROWED_GET_FUNC(Creature, GetSpecies, const CreatureLib::Library::CreatureSpecies*);
 BORROWED_GET_FUNC(Creature, GetVariant, const CreatureLib::Library::SpeciesVariant*);
 
+export uint8_t CreatureLib_Creature_ChangeSpecies(Creature* p, const CreatureLib::Library::CreatureSpecies* species,
+                                                  const CreatureLib::Library::SpeciesVariant* variant) {
+    Try(p->ChangeSpecies(species, variant);)
+}
 export uint8_t CreatureLib_Creature_ChangeVariant(Creature* p, const CreatureLib::Library::SpeciesVariant* variant) {
     Try(p->ChangeVariant(variant);)
 }

src/Battling/Models/Creature.cpp

@@ -6,7 +6,8 @@
 
 using namespace CreatureLib;
 
-Battling::Creature::Creature(ArbUt::BorrowedPtr<const BattleLibrary> library,
+namespace CreatureLib::Battling {
+    Creature::Creature(ArbUt::BorrowedPtr<const BattleLibrary> library,
                        const ArbUt::BorrowedPtr<const Library::CreatureSpecies>& species,
                        const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant, uint8_t level,
                        uint32_t experience, uint32_t uid, Library::Gender gender, uint8_t coloring,
@@ -14,8 +15,8 @@ Battling::Creature::Creature(ArbUt::BorrowedPtr<const BattleLibrary> library,
                        const Library::TalentIndex& talent, const std::vector<LearnedAttack*>& attacks,
                        bool allowedExperienceGain)
         : _library(library), _species(species), _variant(variant), _level(level), _experience(experience),
-      _uniqueIdentifier(uid), _gender(gender), _coloring(coloring), _heldItem(heldItem), _nickname(std::move(nickname)),
+          _uniqueIdentifier(uid), _gender(gender), _coloring(coloring), _heldItem(heldItem),
-      _talentIndex(talent), _hasOverridenTalent(false), _attacks(attacks),
+          _nickname(std::move(nickname)), _talentIndex(talent), _hasOverridenTalent(false), _attacks(attacks),
           _allowedExperienceGain(allowedExperienceGain) {
         AssertNotNull(library)
         AssertNotNull(species)
@@ -28,9 +29,17 @@ Battling::Creature::Creature(ArbUt::BorrowedPtr<const BattleLibrary> library,
         for (auto t : _variant->GetTypes()) {
             _types.insert(t);
         }
-}
+    }
 
-void Battling::Creature::ChangeVariant(ArbUt::BorrowedPtr<const Library::SpeciesVariant> variant) {
+    void Creature::ChangeSpecies(const ArbUt::BorrowedPtr<const Library::CreatureSpecies>& species,
+                                 const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant) {
+        AssertNotNull(species);
+        AssertNotNull(variant);
+        _species = species;
+        ChangeVariant(variant);
+    }
+
+    void Creature::ChangeVariant(const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant) {
         AssertNotNull(variant)
         _variant = variant;
 
@@ -41,8 +50,7 @@ void Battling::Creature::ChangeVariant(ArbUt::BorrowedPtr<const Library::Species
         }
 
         // Grab the new active talent.
-    _activeTalent =
+        _activeTalent = std::unique_ptr<Script>(_library->LoadScript(ScriptCategory::Talent, GetActiveTalent()));
-        std::unique_ptr<CreatureLib::Battling::Script>(_library->LoadScript(ScriptCategory::Talent, GetActiveTalent()));
 
         // We modify the health of the creature by the change in its max health.
         auto prevHealth = GetBoostedStat(CreatureLib::Library::Statistic::Health);
@@ -55,9 +63,9 @@ void Battling::Creature::ChangeVariant(ArbUt::BorrowedPtr<const Library::Species
         }
 
         // TODO: consider variant specific attacks?
-}
+    }
 
-void Battling::Creature::ChangeLevelBy(int8_t amount) {
+    void Creature::ChangeLevelBy(int8_t amount) {
         auto level = _level + amount;
         if (level > _library->GetSettings()->GetMaximalLevel())
             level = _library->GetSettings()->GetMaximalLevel();
@@ -66,24 +74,24 @@ void Battling::Creature::ChangeLevelBy(int8_t amount) {
         _level = level;
         _experience = _library->GetGrowthRateLibrary()->CalculateExperience(_species->GetGrowthRate(), _level);
         RecalculateFlatStats();
-}
+    }
 
-const ArbUt::StringView& Battling::Creature::GetActiveTalent() const {
+    const ArbUt::StringView& Creature::GetActiveTalent() const {
         if (_hasOverridenTalent) {
             return _overridenTalentName;
         }
         return _variant->GetTalent(_talentIndex);
-}
+    }
 
-void Battling::Creature::SetBattleData(ArbUt::BorrowedPtr<Battle> battle, ArbUt::BorrowedPtr<BattleSide> side) {
+    void Creature::SetBattleData(ArbUt::BorrowedPtr<Battle> battle, ArbUt::BorrowedPtr<BattleSide> side) {
         _battle = battle;
         _side = side;
         this->ResetActiveScripts();
-}
+    }
 
-// region Stat APIs
+    // region Stat APIs
 
-bool Battling::Creature::ChangeStatBoost(Library::Statistic stat, int8_t diffAmount) {
+    bool Creature::ChangeStatBoost(Library::Statistic stat, int8_t diffAmount) {
         bool changed = false;
         if (diffAmount > 0)
             changed = this->_statBoost.IncreaseStatBy(stat, diffAmount);
@@ -91,37 +99,37 @@ bool Battling::Creature::ChangeStatBoost(Library::Statistic stat, int8_t diffAmo
             changed = this->_statBoost.DecreaseStatBy(stat, -diffAmount);
         this->RecalculateBoostedStat(stat);
         return changed;
-}
+    }
 
-void Battling::Creature::RecalculateFlatStats() {
+    void Creature::RecalculateFlatStats() {
         auto& statCalc = this->_library->GetStatCalculator();
         this->_flatStats = statCalc->CalculateFlatStats(this);
         RecalculateBoostedStats();
-}
+    }
-void Battling::Creature::RecalculateBoostedStats() {
+    void Creature::RecalculateBoostedStats() {
         this->_boostedStats = this->_library->GetStatCalculator()->CalculateFlatStats(this);
-}
+    }
 
-void Battling::Creature::RecalculateFlatStat(Library::Statistic stat) {
+    void Creature::RecalculateFlatStat(Library::Statistic stat) {
         auto s = this->_library->GetStatCalculator()->CalculateFlatStat(this, stat);
         this->_flatStats.SetStat(stat, s);
         RecalculateBoostedStat(stat);
-}
+    }
 
-void Battling::Creature::RecalculateBoostedStat(Library::Statistic stat) {
+    void Creature::RecalculateBoostedStat(Library::Statistic stat) {
         auto s = this->_library->GetStatCalculator()->CalculateBoostedStat(this, stat);
         this->_boostedStats.SetStat(stat, s);
-}
+    }
 
-// endregion
+    // endregion
 
-const ArbUt::BorrowedPtr<CreatureLib::Battling::Battle>& Battling::Creature::GetBattle() const { return _battle; }
+    const ArbUt::BorrowedPtr<Battle>& Creature::GetBattle() const { return _battle; }
 
-const ArbUt::BorrowedPtr<CreatureLib::Battling::BattleSide>& Battling::Creature::GetBattleSide() const { return _side; }
+    const ArbUt::BorrowedPtr<BattleSide>& Creature::GetBattleSide() const { return _side; }
 
-bool Battling::Creature::IsFainted() const noexcept { return this->_currentHealth == 0; }
+    bool Creature::IsFainted() const noexcept { return this->_currentHealth == 0; }
 
-void Battling::Creature::OnFaint() {
+    void Creature::OnFaint() {
         AssertNotNull(_battle)
         AssertNotNull(_side)
         // HOOK: On Faint
@@ -134,9 +142,9 @@ void Battling::Creature::OnFaint() {
             _side->MarkSlotAsUnfillable(this);
         }
         _battle->ValidateBattleState();
-}
+    }
 
-void Battling::Creature::Damage(uint32_t damage, Battling::DamageSource source) {
+    void Creature::Damage(uint32_t damage, DamageSource source) {
         if (damage > _currentHealth) {
             damage = _currentHealth;
         }
@@ -153,9 +161,9 @@ void Battling::Creature::Damage(uint32_t damage, Battling::DamageSource source)
         if (IsFainted() && damage > 0 && battle != nullptr) {
             OnFaint();
         }
-}
+    }
 
-void Battling::Creature::Heal(uint32_t amount, bool canRevive) {
+    void Creature::Heal(uint32_t amount, bool canRevive) {
         if (_currentHealth == 0 && !canRevive) {
             return;
         }
@@ -169,49 +177,49 @@ void Battling::Creature::Heal(uint32_t amount, bool canRevive) {
             battle->TriggerEventListener<HealEvent>(this, _currentHealth, newHealth);
         }
         _currentHealth = newHealth;
-}
+    }
 
-void Battling::Creature::RestoreAllAttackUses() noexcept {
+    void Creature::RestoreAllAttackUses() noexcept {
         for (auto& a : _attacks) {
             if (a != nullptr) {
                 a->RestoreAllUses();
             }
         }
-}
+    }
 
-void Battling::Creature::OverrideActiveTalent(const ArbUt::StringView& talent) {
+    void Creature::OverrideActiveTalent(const ArbUt::StringView& talent) {
         _hasOverridenTalent = true;
         if (_activeTalent != nullptr) {
             _activeTalent->OnRemove();
             _activeTalent.reset(this->_library->LoadScript(ScriptCategory::Talent, talent));
         }
         _overridenTalentName = talent;
-}
+    }
 
-const std::unordered_set<uint8_t>& Battling::Creature::GetTypes() const noexcept { return _types; }
+    const std::unordered_set<uint8_t>& Creature::GetTypes() const noexcept { return _types; }
 
-bool Battling::Creature::HasType(uint8_t type) const noexcept {
+    bool Creature::HasType(uint8_t type) const noexcept {
         return std::find(_types.begin(), _types.end(), type) != _types.end();
-}
+    }
 
-size_t Battling::Creature::ScriptCount() const {
+    size_t Creature::ScriptCount() const {
         auto c = 3;
         if (_side != nullptr) {
             c += _side->ScriptCount();
         }
         return c;
-}
+    }
 
-void Battling::Creature::GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) {
+    void Creature::GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) {
         scripts.Append(ScriptWrapper::FromScript(&_activeTalent));
         scripts.Append(ScriptWrapper::FromScript(&_status));
         scripts.Append(ScriptWrapper::FromSet(&_volatile));
         if (_side != nullptr) {
             _side->GetActiveScripts(scripts);
         }
-}
+    }
-void Battling::Creature::ClearVolatileScripts() { _volatile.Clear(); }
+    void Creature::ClearVolatileScripts() { _volatile.Clear(); }
-void Battling::Creature::AddExperience(uint32_t amount) {
+    void Creature::AddExperience(uint32_t amount) {
         auto maxLevel = _library->GetSettings()->GetMaximalLevel();
         if (_level >= maxLevel) {
             return;
@@ -226,35 +234,35 @@ void Battling::Creature::AddExperience(uint32_t amount) {
         }
         _experience = exp;
         _level = level;
-}
+    }
-ArbUt::BorrowedPtr<const Library::CreatureSpecies> Battling::Creature::GetDisplaySpecies() const noexcept {
+    ArbUt::BorrowedPtr<const Library::CreatureSpecies> Creature::GetDisplaySpecies() const noexcept {
         auto species = _displaySpecies;
         if (species == nullptr)
             species = _species;
         return species;
-}
+    }
-ArbUt::BorrowedPtr<const Library::SpeciesVariant> Battling::Creature::GetDisplayVariant() const noexcept {
+    ArbUt::BorrowedPtr<const Library::SpeciesVariant> Creature::GetDisplayVariant() const noexcept {
         auto variant = _displayVariant;
         if (variant == nullptr)
             variant = _variant;
         return variant;
-}
+    }
-void Battling::Creature::SetHeldItem(const ArbUt::BasicStringView& itemName) {
+    void Creature::SetHeldItem(const ArbUt::BasicStringView& itemName) {
         ArbUt::BorrowedPtr<const Library::Item> item;
         if (!_library->GetItemLibrary()->TryGet(itemName.GetHash(), item)) {
             THROW_CREATURE("Item not found '" << itemName.c_str() << "'.");
         }
         _heldItem = item;
-}
+    }
-void Battling::Creature::SetHeldItem(uint32_t itemNameHash) {
+    void Creature::SetHeldItem(uint32_t itemNameHash) {
         ArbUt::BorrowedPtr<const Library::Item> item;
         if (!_library->GetItemLibrary()->TryGet(itemNameHash, item)) {
             THROW_CREATURE("Item not found.");
         }
         _heldItem = item;
-}
+    }
 
-void Battling::Creature::AddVolatileScript(const ArbUt::StringView& name) {
+    void Creature::AddVolatileScript(const ArbUt::StringView& name) {
         auto script = _volatile.Get(name);
         if (script != nullptr) {
             script->Stack();
@@ -265,13 +273,13 @@ void Battling::Creature::AddVolatileScript(const ArbUt::StringView& name) {
             THROW_CREATURE("Invalid volatile script requested for creature: '" << name.c_str() << "'.");
         }
         _volatile.Add(script.GetRaw());
-}
+    }
 
-void Battling::Creature::AddVolatileScript(Script* script) { _volatile.Add(script); }
+    void Creature::AddVolatileScript(Script* script) { _volatile.Add(script); }
-void Battling::Creature::RemoveVolatileScript(const ArbUt::BasicStringView& name) { _volatile.Remove(name); }
+    void Creature::RemoveVolatileScript(const ArbUt::BasicStringView& name) { _volatile.Remove(name); }
-void Battling::Creature::RemoveVolatileScript(Battling::Script* script) { _volatile.Remove(script->GetName()); }
+    void Creature::RemoveVolatileScript(Script* script) { _volatile.Remove(script->GetName()); }
-bool Battling::Creature::HasVolatileScript(const ArbUt::BasicStringView& name) const { return _volatile.Has(name); }
+    bool Creature::HasVolatileScript(const ArbUt::BasicStringView& name) const { return _volatile.Has(name); }
-void Battling::Creature::AddAttack(Battling::LearnedAttack* attack) {
+    void Creature::AddAttack(LearnedAttack* attack) {
         for (size_t i = 0; i < _attacks.Count(); i++) {
             if (_attacks[i] == nullptr) {
                 _attacks.Set(i, attack);
@@ -282,8 +290,8 @@ void Battling::Creature::AddAttack(Battling::LearnedAttack* attack) {
             _attacks.Append(attack);
         }
         THROW_CREATURE("Can't add attack. The creature already has the maximum amount of attacks.");
-}
+    }
-uint8_t Battling::Creature::GetAvailableAttackSlot() const noexcept {
+    uint8_t Creature::GetAvailableAttackSlot() const noexcept {
         for (uint8_t i = 0; i < (uint8_t)_attacks.Count(); i++) {
             if (_attacks[i] == nullptr) {
                 return i;
@@ -293,8 +301,8 @@ uint8_t Battling::Creature::GetAvailableAttackSlot() const noexcept {
             return _attacks.Count();
         }
         return -1;
-}
+    }
-void Battling::Creature::ReplaceAttack(size_t index, Battling::LearnedAttack* attack) {
+    void Creature::ReplaceAttack(size_t index, LearnedAttack* attack) {
         if (_attacks.Count() <= index) {
             if (_attacks.Count() < _library->GetStaticLib()->GetSettings()->GetMaximalAttacks()) {
                 _attacks.Append(attack);
@@ -303,4 +311,6 @@ void Battling::Creature::ReplaceAttack(size_t index, Battling::LearnedAttack* at
                                                             << ".");
         }
         _attacks.Set(index, attack);
+    }
+
 }

src/Battling/Models/Creature.hpp

@@ -85,7 +85,9 @@ namespace CreatureLib::Battling {
             return _species;
         }
         inline const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& GetVariant() const noexcept { return _variant; }
-        virtual void ChangeVariant(ArbUt::BorrowedPtr<const Library::SpeciesVariant> variant);
+        virtual void ChangeSpecies(const ArbUt::BorrowedPtr<const Library::CreatureSpecies>& species,
+                                   const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant);
+        virtual void ChangeVariant(const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant);
         inline uint8_t GetLevel() const noexcept { return _level; }
         inline uint32_t GetExperience() const noexcept { return _experience; }
         inline uint32_t GetUniqueIdentifier() const noexcept { return _uniqueIdentifier; }