Add nullability to large parts of the codebase

src/Battling/Library/BattleLibrary.cpp

@@ -2,9 +2,10 @@
 
 using namespace CreatureLib::Battling;
 
-BattleLibrary::BattleLibrary(const CreatureLib::Library::DataLibrary* staticLib, BattleStatCalculator* statCalculator,
-                             DamageLibrary* damageLibrary, ExperienceLibrary* experienceLibrary,
-                             ScriptResolver* scriptResolver, MiscLibrary* miscLibrary)
+BattleLibrary::BattleLibrary(const CreatureLib::Library::DataLibrary* non_null staticLib,
+                             BattleStatCalculator* non_null statCalculator, DamageLibrary* non_null damageLibrary,
+                             ExperienceLibrary* non_null experienceLibrary, ScriptResolver* non_null scriptResolver,
+                             MiscLibrary* non_null miscLibrary)
     : _staticLib(staticLib), _statCalculator(statCalculator), _damageLibrary(damageLibrary),
       _experienceLibrary(experienceLibrary), _scriptResolver(scriptResolver), _miscLibrary(miscLibrary) {
     EnsureNotNull(_staticLib);
@@ -43,7 +44,7 @@ const std::unique_ptr<const DamageLibrary>& BattleLibrary::GetDamageLibrary() co
 
 const std::unique_ptr<const MiscLibrary>& BattleLibrary::GetMiscLibrary() const noexcept { return _miscLibrary; }
 
-BattleScript* BattleLibrary::LoadScript(const ArbUt::OptionalBorrowedPtr<void>& owner, ScriptCategory category,
-                                        const ArbUt::StringView& scriptName) const {
+BattleScript* nullable BattleLibrary::LoadScript(const ArbUt::OptionalBorrowedPtr<void>& owner, ScriptCategory category,
+                                                 const ArbUt::StringView& scriptName) const {
     return _scriptResolver->LoadScript(owner, category, scriptName);
 }

src/Battling/Library/BattleLibrary.hpp

@@ -19,9 +19,9 @@ namespace CreatureLib::Battling {
         std::unique_ptr<const MiscLibrary> _miscLibrary = nullptr;
 
     public:
-        BattleLibrary(const Library::DataLibrary* staticLib, BattleStatCalculator* statCalculator,
-                      DamageLibrary* damageLibrary, ExperienceLibrary* experienceLibrary,
-                      ScriptResolver* scriptResolver, MiscLibrary* miscLibrary);
+        BattleLibrary(const Library::DataLibrary* non_null staticLib, BattleStatCalculator* non_null statCalculator,
+                      DamageLibrary* non_null damageLibrary, ExperienceLibrary* non_null experienceLibrary,
+                      ScriptResolver* non_null scriptResolver, MiscLibrary* non_null miscLibrary);
         ~BattleLibrary() = default;
         inline const std::unique_ptr<const Library::DataLibrary>& GetStaticLib() const noexcept { return _staticLib; }
 
@@ -44,8 +44,9 @@ namespace CreatureLib::Battling {
             return _scriptResolver;
         }
 
-        [[nodiscard]] BattleScript* LoadScript(const ArbUt::OptionalBorrowedPtr<void>& owner, ScriptCategory category,
-                                               const ArbUt::StringView& scriptName) const;
+        [[nodiscard]] BattleScript* nullable LoadScript(const ArbUt::OptionalBorrowedPtr<void>& owner,
+                                                        ScriptCategory category,
+                                                        const ArbUt::StringView& scriptName) const;
     };
 }
 

src/Battling/Library/BattleStatCalculator.cpp

@@ -3,7 +3,8 @@
 
 using namespace CreatureLib;
 
-Library::StatisticSet<u32> Battling::BattleStatCalculator::CalculateFlatStats(Battling::Creature* creature) const {
+Library::StatisticSet<u32>
+Battling::BattleStatCalculator::CalculateFlatStats(Battling::Creature* non_null creature) const {
     return Library::StatisticSet<u32>(CalculateFlatStat(creature, Library::Statistic::Health),
                                       CalculateFlatStat(creature, Library::Statistic::PhysicalAttack),
                                       CalculateFlatStat(creature, Library::Statistic::PhysicalDefense),
@@ -12,7 +13,8 @@ Library::StatisticSet<u32> Battling::BattleStatCalculator::CalculateFlatStats(Ba
                                       CalculateFlatStat(creature, Library::Statistic::Speed));
 }
 
-Library::StatisticSet<u32> Battling::BattleStatCalculator::CalculateBoostedStats(Battling::Creature* creature) const {
+Library::StatisticSet<u32>
+Battling::BattleStatCalculator::CalculateBoostedStats(Battling::Creature* non_null creature) const {
     return Library::StatisticSet<u32>(CalculateBoostedStat(creature, Library::Statistic::Health),
                                       CalculateBoostedStat(creature, Library::Statistic::PhysicalAttack),
                                       CalculateBoostedStat(creature, Library::Statistic::PhysicalDefense),
@@ -21,26 +23,29 @@ Library::StatisticSet<u32> Battling::BattleStatCalculator::CalculateBoostedStats
                                       CalculateBoostedStat(creature, Library::Statistic::Speed));
 }
 
-u32 CalculateHealthStat(Battling::Creature* creature) {
+u32 CalculateHealthStat(Battling::Creature* non_null creature) {
     EnsureNotNull(creature)
     auto level = creature->GetLevel();
     float a = (creature->GetBaseStat(Library::Statistic::Health)) * 2.0 * level;
     return static_cast<u32>(floor(a / 100.0) + level + 10);
 }
 
-u32 CalculateOtherStat(Battling::Creature* creature, Library::Statistic stat) {
+u32 CalculateOtherStat(Battling::Creature* non_null creature, Library::Statistic stat) {
     EnsureNotNull(creature)
     auto level = creature->GetLevel();
     float a = (creature->GetBaseStat(stat)) * 2.0 * level;
     return static_cast<u32>(floor(a / 100.0) + 5);
 }
 
-u32 Battling::BattleStatCalculator::CalculateFlatStat(Battling::Creature* creature, Library::Statistic stat) const {
+u32 Battling::BattleStatCalculator::CalculateFlatStat(Battling::Creature* non_null creature,
+                                                      Library::Statistic stat) const {
+    EnsureNotNull(creature);
     if (stat == Library::Statistic::Health)
         return CalculateHealthStat(creature);
     return CalculateOtherStat(creature, stat);
 }
 
-u32 Battling::BattleStatCalculator::CalculateBoostedStat(Battling::Creature* creature, Library::Statistic stat) const {
+u32 Battling::BattleStatCalculator::CalculateBoostedStat(Battling::Creature* non_null creature,
+                                                         Library::Statistic stat) const {
     return creature->GetFlatStat(stat) + (creature->GetBoostedStat(stat));
 }

src/Battling/Library/BattleStatCalculator.hpp

@@ -11,10 +11,10 @@ namespace CreatureLib::Battling {
     public:
         virtual ~BattleStatCalculator() = default;
 
-        virtual Library::StatisticSet<u32> CalculateFlatStats(Creature* creature) const;
-        virtual Library::StatisticSet<u32> CalculateBoostedStats(Creature* creature) const;
-        virtual u32 CalculateFlatStat(Creature* creature, Library::Statistic stat) const;
-        virtual u32 CalculateBoostedStat(Creature* creature, Library::Statistic stat) const;
+        virtual Library::StatisticSet<u32> CalculateFlatStats(Creature* non_null creature) const;
+        virtual Library::StatisticSet<u32> CalculateBoostedStats(Creature* non_null creature) const;
+        virtual u32 CalculateFlatStat(Creature* non_null creature, Library::Statistic stat) const;
+        virtual u32 CalculateBoostedStat(Creature* non_null creature, Library::Statistic stat) const;
     };
 }
 

src/Battling/Library/DamageLibrary.cpp

@@ -2,7 +2,7 @@
 #include "../ScriptHandling/ScriptMacros.hpp"
 
 using namespace CreatureLib::Battling;
-u32 DamageLibrary::GetDamage(ExecutingAttack* attack, Creature* target, u8 hitIndex,
+u32 DamageLibrary::GetDamage(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                              const ExecutingAttack::HitData& hitData) const {
     EnsureNotNull(attack)
     EnsureNotNull(target)
@@ -17,7 +17,7 @@ u32 DamageLibrary::GetDamage(ExecutingAttack* attack, Creature* target, u8 hitIn
     return damage;
 }
 
-u8 DamageLibrary::GetBasePower(ExecutingAttack* attack, Creature* target, u8 hitIndex,
+u8 DamageLibrary::GetBasePower(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                [[maybe_unused]] const ExecutingAttack::HitData& hitData) const {
     EnsureNotNull(attack)
     EnsureNotNull(target)
@@ -26,7 +26,7 @@ u8 DamageLibrary::GetBasePower(ExecutingAttack* attack, Creature* target, u8 hit
     return bp;
 }
 
-float DamageLibrary::GetStatModifier(ExecutingAttack* attack, Creature* target, u8 hitIndex,
+float DamageLibrary::GetStatModifier(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                      const ExecutingAttack::HitData& hitData) const {
     EnsureNotNull(attack)
     EnsureNotNull(target)
@@ -65,7 +65,7 @@ float DamageLibrary::GetStatModifier(ExecutingAttack* attack, Creature* target,
     return offensiveValue / defensiveValue;
 }
 
-float DamageLibrary::GetDamageModifier(ExecutingAttack* attack, Creature* target, u8 hitIndex,
+float DamageLibrary::GetDamageModifier(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                        const ExecutingAttack::HitData& hitData) const {
     EnsureNotNull(attack)
     EnsureNotNull(target)

src/Battling/Library/DamageLibrary.hpp

@@ -8,14 +8,14 @@ namespace CreatureLib::Battling {
     class DamageLibrary {
     public:
         virtual ~DamageLibrary() = default;
-        virtual u32 GetDamage(ExecutingAttack* attack, Creature* target, u8 hitIndex,
+        virtual u32 GetDamage(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                               const ExecutingAttack::HitData& hitData) const;
 
-        virtual u8 GetBasePower(ExecutingAttack* attack, Creature* target, u8 hitIndex,
+        virtual u8 GetBasePower(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                 const ExecutingAttack::HitData& hitData) const;
-        virtual float GetStatModifier(ExecutingAttack* attack, Creature* target, u8 hitIndex,
+        virtual float GetStatModifier(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                       const ExecutingAttack::HitData& hitData) const;
-        virtual float GetDamageModifier(ExecutingAttack* attack, Creature* target, u8 hitIndex,
+        virtual float GetDamageModifier(ExecutingAttack* non_null attack, Creature* non_null target, u8 hitIndex,
                                         const ExecutingAttack::HitData& hitData) const;
     };
 }

src/Battling/Library/ExperienceLibrary.cpp

@@ -2,7 +2,7 @@
 #include "../Models/Creature.hpp"
 
 void CreatureLib::Battling::ExperienceLibrary::HandleExperienceGain(
-    CreatureLib::Battling::Creature* faintedMon,
+    CreatureLib::Battling::Creature* non_null faintedMon,
     const std::unordered_set<ArbUt::BorrowedPtr<Creature>>& opponents) const {
     for (const auto& opponent : opponents) {
         if (opponent->IsFainted())

src/Battling/Library/ExperienceLibrary.hpp

@@ -11,7 +11,7 @@ namespace CreatureLib::Battling {
     public:
         virtual ~ExperienceLibrary() = default;
 
-        virtual void HandleExperienceGain(Creature* faintedMon,
+        virtual void HandleExperienceGain(Creature* non_null faintedMon,
                                           const std::unordered_set<ArbUt::BorrowedPtr<Creature>>& opponents) const;
     };
 }

src/Battling/Library/MiscLibrary.cpp

@@ -2,16 +2,16 @@
 #include "../Models/Battle.hpp"
 #include "../TurnChoices/AttackTurnChoice.hpp"
 
-bool CreatureLib::Battling::MiscLibrary::IsCritical([[maybe_unused]] CreatureLib::Battling::ExecutingAttack* attack,
-                                                    CreatureLib::Battling::Creature* target,
-                                                    [[maybe_unused]] u8 hit) const {
+bool CreatureLib::Battling::MiscLibrary::IsCritical(
+    [[maybe_unused]] CreatureLib::Battling::ExecutingAttack* non_null attack,
+    CreatureLib::Battling::Creature* non_null target, [[maybe_unused]] u8 hit) const {
     EnsureNotNull(target)
     Ensure(target->GetBattle().HasValue())
     auto rand = target->GetBattle().GetValue()->GetRandom();
     return rand->Get(10) <= 0;
 }
 
-static CreatureLib::Battling::LearnedAttack* _replacementAttack = nullptr;
+static CreatureLib::Battling::LearnedAttack* nullable _replacementAttack = nullptr;
 static std::unique_ptr<const CreatureLib::Library::AttackData> _replacementAttackData = nullptr;
 
 static ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData> GetReplacementAttackData() {
@@ -24,7 +24,7 @@ static ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData> GetReplacement
     return _replacementAttackData;
 }
 
-static CreatureLib::Battling::LearnedAttack* GetReplacementAttack() {
+static CreatureLib::Battling::LearnedAttack* non_null GetReplacementAttack() {
     if (_replacementAttack == nullptr) {
         _replacementAttack = new CreatureLib::Battling::LearnedAttack(
             GetReplacementAttackData(), CreatureLib::Battling::AttackLearnMethod::Unknown);
@@ -32,9 +32,12 @@ static CreatureLib::Battling::LearnedAttack* GetReplacementAttack() {
     return _replacementAttack;
 }
 
-bool CreatureLib::Battling::MiscLibrary::CanFlee([[maybe_unused]] FleeTurnChoice* switchChoice) const { return true; }
+bool CreatureLib::Battling::MiscLibrary::CanFlee([[maybe_unused]] FleeTurnChoice* non_null switchChoice) const {
+    return true;
+}
 CreatureLib::Battling::BaseTurnChoice*
-CreatureLib::Battling::MiscLibrary::ReplacementAttack(Creature* user, [[maybe_unused]] CreatureIndex target) const {
+CreatureLib::Battling::MiscLibrary::ReplacementAttack(Creature* non_null user,
+                                                      [[maybe_unused]] CreatureIndex target) const {
     EnsureNotNull(user)
     Ensure(user->GetBattleSide().HasValue())
     auto sideTarget = 0;

src/Battling/Library/MiscLibrary.hpp

@@ -9,9 +9,9 @@ namespace CreatureLib::Battling {
     class MiscLibrary {
     public:
         virtual ~MiscLibrary() = default;
-        virtual bool IsCritical(ExecutingAttack* attack, Creature* target, u8 hit) const;
-        virtual bool CanFlee(FleeTurnChoice* switchChoice) const;
-        virtual BaseTurnChoice* ReplacementAttack(Creature* user, CreatureIndex target) const;
+        virtual bool IsCritical(ExecutingAttack* non_null attack, Creature* non_null target, u8 hit) const;
+        virtual bool CanFlee(FleeTurnChoice* non_null switchChoice) const;
+        virtual BaseTurnChoice* non_null ReplacementAttack(Creature* non_null user, CreatureIndex target) const;
     };
 }