Update to latest Arbutils.

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

src/Battling/Library/BattleLibrary.cpp

@@ -7,12 +7,12 @@ BattleLibrary::BattleLibrary(const CreatureLib::Library::DataLibrary* staticLib,
                              ScriptResolver* scriptResolver, MiscLibrary* miscLibrary)
     : _staticLib(staticLib), _statCalculator(statCalculator), _damageLibrary(damageLibrary),
       _experienceLibrary(experienceLibrary), _scriptResolver(scriptResolver), _miscLibrary(miscLibrary) {
-    AssertNotNull(_staticLib);
-    AssertNotNull(_statCalculator);
-    AssertNotNull(_damageLibrary);
-    AssertNotNull(_experienceLibrary);
-    AssertNotNull(_scriptResolver);
-    AssertNotNull(_miscLibrary);
+    EnsureNotNull(_staticLib);
+    EnsureNotNull(_statCalculator);
+    EnsureNotNull(_damageLibrary);
+    EnsureNotNull(_experienceLibrary);
+    EnsureNotNull(_scriptResolver);
+    EnsureNotNull(_miscLibrary);
 }
 
 const std::unique_ptr<const CreatureLib::Library::LibrarySettings>& BattleLibrary::GetSettings() const noexcept {

src/Battling/Library/BattleStatCalculator.cpp

@@ -23,14 +23,14 @@ Battling::BattleStatCalculator::CalculateBoostedStats(Battling::Creature* creatu
 }
 
 uint32_t CalculateHealthStat(Battling::Creature* creature) {
-    AssertNotNull(creature)
+    EnsureNotNull(creature)
     auto level = creature->GetLevel();
     float a = (creature->GetBaseStat(Library::Statistic::Health)) * 2.0 * level;
     return static_cast<uint32_t>(floor(a / 100.0) + level + 10);
 }
 
 uint32_t CalculateOtherStat(Battling::Creature* creature, Library::Statistic stat) {
-    AssertNotNull(creature)
+    EnsureNotNull(creature)
     auto level = creature->GetLevel();
     float a = (creature->GetBaseStat(stat)) * 2.0 * level;
     return static_cast<uint32_t>(floor(a / 100.0) + 5);

src/Battling/Library/DamageLibrary.cpp

@@ -4,8 +4,8 @@
 using namespace CreatureLib::Battling;
 uint32_t DamageLibrary::GetDamage(ExecutingAttack* attack, Creature* target, uint8_t hitIndex,
                                   const ExecutingAttack::HitData& hitData) const {
-    AssertNotNull(attack)
-    AssertNotNull(target)
+    EnsureNotNull(attack)
+    EnsureNotNull(target)
     auto levelMod = static_cast<float>(2 * attack->GetUser()->GetLevel()) / 5 + 2;
     auto bp = hitData.GetBasePower();
     auto statMod = GetStatModifier(attack, target, hitIndex, hitData);
@@ -18,8 +18,8 @@ uint32_t DamageLibrary::GetDamage(ExecutingAttack* attack, Creature* target, uin
 
 uint8_t DamageLibrary::GetBasePower(ExecutingAttack* attack, Creature* target, uint8_t hitIndex,
                                     [[maybe_unused]] const ExecutingAttack::HitData& hitData) const {
-    AssertNotNull(attack)
-    AssertNotNull(target)
+    EnsureNotNull(attack)
+    EnsureNotNull(target)
     auto bp = attack->GetAttack()->GetAttack()->GetBasePower();
     HOOK(OverrideBasePower, attack, attack, target, hitIndex, &bp);
     return bp;
@@ -27,10 +27,10 @@ uint8_t DamageLibrary::GetBasePower(ExecutingAttack* attack, Creature* target, u
 
 float DamageLibrary::GetStatModifier(ExecutingAttack* attack, Creature* target, uint8_t hitIndex,
                                      const ExecutingAttack::HitData& hitData) const {
-    AssertNotNull(attack)
-    AssertNotNull(target)
+    EnsureNotNull(attack)
+    EnsureNotNull(target)
     auto user = attack->GetUser().GetRaw();
-    AssertNotNull(user)
+    EnsureNotNull(user)
     HOOK(ChangeDamageStatsUser, attack, attack, target, hitIndex, &user);
     Library::Statistic offensiveStat;
     Library::Statistic defensiveStat;
@@ -66,8 +66,8 @@ float DamageLibrary::GetStatModifier(ExecutingAttack* attack, Creature* target,
 
 float DamageLibrary::GetDamageModifier(ExecutingAttack* attack, Creature* target, uint8_t hitIndex,
                                        const ExecutingAttack::HitData& hitData) const {
-    AssertNotNull(attack)
-    AssertNotNull(target)
+    EnsureNotNull(attack)
+    EnsureNotNull(target)
     float mod = 1;
     mod *= hitData.GetEffectiveness();
     HOOK(ModifyDamageModifier, attack, attack, target, hitIndex, &mod);

src/Battling/Library/ExperienceLibrary.cpp

@@ -5,8 +5,6 @@ void CreatureLib::Battling::ExperienceLibrary::HandleExperienceGain(
     CreatureLib::Battling::Creature* faintedMon,
     const std::unordered_set<ArbUt::BorrowedPtr<Creature>>& opponents) const {
     for (auto opponent : opponents) {
-        if (opponent == nullptr)
-            continue;
         if (opponent->IsFainted())
             continue;
         if (!opponent->AllowedExperienceGain())

src/Battling/Library/MiscLibrary.cpp

@@ -5,8 +5,8 @@
 bool CreatureLib::Battling::MiscLibrary::IsCritical([[maybe_unused]] CreatureLib::Battling::ExecutingAttack* attack,
                                                     CreatureLib::Battling::Creature* target,
                                                     [[maybe_unused]] uint8_t hit) const {
-    AssertNotNull(target)
-    Assert(target->GetBattle().HasValue())
+    EnsureNotNull(target)
+    Ensure(target->GetBattle().HasValue())
     auto rand = target->GetBattle().GetValue()->GetRandom();
     return rand->Get(10) <= 0;
 }
@@ -35,8 +35,8 @@ static CreatureLib::Battling::LearnedAttack* GetReplacementAttack() {
 bool CreatureLib::Battling::MiscLibrary::CanFlee([[maybe_unused]] FleeTurnChoice* switchChoice) const { return true; }
 CreatureLib::Battling::BaseTurnChoice*
 CreatureLib::Battling::MiscLibrary::ReplacementAttack(Creature* user, [[maybe_unused]] CreatureIndex target) const {
-    AssertNotNull(user)
-    Assert(user->GetBattleSide().HasValue())
+    EnsureNotNull(user)
+    Ensure(user->GetBattleSide().HasValue())
     auto sideTarget = 0;
     if (user->GetBattleSide().GetValue()->GetSideIndex() == 0)
         sideTarget = 1;