Register many battle classes in AngelScript.

src/Battling/Library/BattleLibrary.hpp

@@ -3,13 +3,14 @@
 
 #include <Battling/Library/BattleLibrary.hpp>
 #include "../../Library/PokemonLibrary.hpp"
+#include "DamageLibrary.hpp"
 #include "StatCalculator.hpp"
 
 namespace PkmnLib::Battling {
     class BattleLibrary : public CreatureLib::Battling::BattleLibrary {
     public:
         BattleLibrary(Library::PokemonLibrary* staticLib, StatCalculator* statCalculator,
-                      CreatureLib::Battling::DamageLibrary* damageLibrary,
+                      DamageLibrary* damageLibrary,
                       CreatureLib::Battling::ExperienceLibrary* experienceLibrary,
                       CreatureLib::Battling::ScriptResolver* scriptResolver,
                       CreatureLib::Battling::MiscLibrary* miscLibrary)

src/Battling/Library/DamageLibrary.cpp

@@ -0,0 +1,68 @@
+#include "DamageLibrary.hpp"
+#include "../Pokemon/Pokemon.hpp"
+int PkmnLib::Battling::DamageLibrary::GetDamage(CreatureLib::Battling::ExecutingAttack* attack,
+                                                CreatureLib::Battling::Creature* target, uint8_t hitIndex) const {
+    auto levelMod = static_cast<float>(2 * attack->GetUser()->GetLevel());
+    auto hit = attack->GetAttackDataForTarget(target).GetHit(hitIndex);
+    auto bp = hit->GetBasePower();
+    auto statMod = GetStatModifier(attack, target, hitIndex);
+    // HOOK: Modify stat modifier
+    int damage = static_cast<int>((((levelMod * static_cast<float>(bp) * statMod) / 50) + 2) *
+                                  GetDamageModifier(attack, target, hitIndex));
+    // HOOK: Override damage
+    return damage;
+}
+int PkmnLib::Battling::DamageLibrary::GetBasePower(CreatureLib::Battling::ExecutingAttack* attack,
+                                                   CreatureLib::Battling::Creature* target, uint8_t hitIndex) const {
+    auto bp = attack->GetAttack()->GetAttack()->GetBasePower();
+    // HOOK: modify base power.
+    return bp;
+}
+float PkmnLib::Battling::DamageLibrary::GetStatModifier(CreatureLib::Battling::ExecutingAttack* attack,
+                                                        CreatureLib::Battling::Creature* target,
+                                                        uint8_t hitIndex) const {
+    auto user = attack->GetUser();
+    // HOOK: allow overriding for which users stat we use.
+    auto hit = attack->GetAttackDataForTarget(target).GetHit(hitIndex);
+    CreatureLib::Core::Statistic offensiveStat;
+    CreatureLib::Core::Statistic defensiveStat;
+    auto learnedMove = dynamic_cast<LearnedMove*>(attack->GetAttack());
+    auto moveData = learnedMove->GetMoveData();
+    if (moveData->GetCategory() == Library::MoveCategory::Physical) {
+        offensiveStat = Library::Statistic::PhysicalAttack;
+        defensiveStat = Library::Statistic::PhysicalDefense;
+    } else {
+        offensiveStat = Library::Statistic::SpecialAttack;
+        defensiveStat = Library::Statistic::SpecialDefense;
+    }
+
+    auto bypassDefensive = hit->IsCritical() && target->GetStatBoost(defensiveStat) > 0;
+    // HOOK: allow bypassing defensive stat modifiers.
+    auto bypassOffensive = hit->IsCritical() && user->GetStatBoost(offensiveStat) < 0;
+    // HOOK: Allow bypassing offensive stat modifiers.
+
+    float offensiveValue;
+    float defensiveValue;
+
+    if (bypassOffensive) {
+        offensiveValue = user->GetFlatStat(offensiveStat);
+    } else {
+        offensiveValue = user->GetBoostedStat(offensiveStat);
+    }
+    if (bypassDefensive) {
+        defensiveValue = target->GetFlatStat(defensiveStat);
+    } else {
+        defensiveValue = target->GetBoostedStat(defensiveStat);
+    }
+
+    return offensiveValue / defensiveValue;
+}
+float PkmnLib::Battling::DamageLibrary::GetDamageModifier(CreatureLib::Battling::ExecutingAttack* attack,
+                                                          CreatureLib::Battling::Creature* target,
+                                                          uint8_t hitIndex) const {
+    float mod = 1;
+    auto hit = attack->GetAttackDataForTarget(target).GetHit(hitIndex);
+    mod *= hit->GetEffectiveness();
+    // HOOK: Modify damage modifier.
+    return mod;
+}

src/Battling/Library/DamageLibrary.hpp

@@ -0,0 +1,20 @@
+#ifndef PKMNLIB_DAMAGELIBRARY_HPP
+#define PKMNLIB_DAMAGELIBRARY_HPP
+
+#include <Battling/Library/DamageLibrary.hpp>
+namespace PkmnLib::Battling {
+    class DamageLibrary : public CreatureLib::Battling::DamageLibrary {
+    public:
+        int GetDamage(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
+                      uint8_t hitIndex) const override;
+
+        int GetBasePower(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
+                         uint8_t hitIndex) const override;
+        float GetStatModifier(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
+                              uint8_t hitIndex) const override;
+        float GetDamageModifier(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
+                                uint8_t hitIndex) const override;
+    };
+}
+
+#endif // PKMNLIB_DAMAGELIBRARY_HPP

src/Battling/Pokemon/LearnedMove.hpp

@@ -5,9 +5,11 @@
 #include "../../Library/Moves/MoveData.hpp"
 namespace PkmnLib::Battling {
     class LearnedMove : public CreatureLib::Battling::LearnedAttack {
-        public:
+    public:
         LearnedMove(const Library::MoveData* move, CreatureLib::Battling::AttackLearnMethod learnMethod)
-                : CreatureLib::Battling::LearnedAttack(move, learnMethod){}
+            : CreatureLib::Battling::LearnedAttack(move, learnMethod) {}
+
+        const Library::MoveData* GetMoveData() const { return dynamic_cast<const Library::MoveData*>(GetAttack()); }
     };
 }
 

src/Battling/Pokemon/Pokemon.hpp

@@ -29,10 +29,12 @@ namespace PkmnLib::Battling {
                                               heldItem, nickname, talent, std::move(moves)),
               _individualValues(individualValues), _effortValues(effortValues), _nature(nature) {}
 
-        const Library::Nature& GetNature() const;
-        uint8_t GetIndividualValue(CreatureLib::Core::Statistic stat) const {
-            return _individualValues.GetStat(stat);
+        const Library::PokemonForme* GetForme() const {
+            return dynamic_cast<const Library::PokemonForme*>(GetVariant());
         }
+
+        const Library::Nature& GetNature() const;
+        uint8_t GetIndividualValue(CreatureLib::Core::Statistic stat) const { return _individualValues.GetStat(stat); }
         uint8_t GetEffortValue(CreatureLib::Core::Statistic stat) const { return _effortValues.GetStat(stat); }
     };
 }