Deukhoofd/CreatureLib
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add nullability to large parts of the codebase
All checks were successful
continuous-integration/drone/push Build is passing
Details

Browse Source
This commit is contained in:
Deukhoofd
2022-03-23 18:30:35 +01:00
parent beb2e44a0b
commit eccf2c9121
53 changed files with 240 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/Battling/EventHooks/EventHook.hpp
View File

@@ -15,13 +15,13 @@ namespace CreatureLib::Battling {
/// for it.
class EventHook {
public:
typedef std::function<void(const CreatureLib::Battling::EventData*)> EventHookFunc;
typedef std::function<void(const CreatureLib::Battling::EventData* non_null)> EventHookFunc;
private:
std::vector<EventHookFunc> _listeners;
size_t _offset;
size_t _capacity;
u8* _memory = nullptr;
u8* nullable _memory = nullptr;
static constexpr size_t initialSize = 2048;
static constexpr size_t stepSize = 1024;

2
src/Battling/Flow/ChoiceQueue.cpp
View File

@@ -1,6 +1,6 @@
#include "ChoiceQueue.hpp"
bool CreatureLib::Battling::ChoiceQueue::MoveCreatureChoiceNext(CreatureLib::Battling::Creature* creature) {
bool CreatureLib::Battling::ChoiceQueue::MoveCreatureChoiceNext(CreatureLib::Battling::Creature* non_null creature) {
EnsureNotNull(creature)
// Find which index the creature choice is at.
size_t choiceIndex = SIZE_MAX;

2
src/Battling/Flow/ChoiceQueue.hpp
View File

@@ -21,7 +21,7 @@ namespace CreatureLib::Battling {
const std::vector<std::shared_ptr<BaseTurnChoice>>& GetInnerQueue() { return _queue; }
bool MoveCreatureChoiceNext(Creature* creature);
bool MoveCreatureChoiceNext(Creature* non_null creature);
};
}

2
src/Battling/History/HistoryHolder.cpp
View File

@@ -19,7 +19,7 @@ namespace CreatureLib::Battling {
}
ArbUt::OptionalBorrowedPtr<const HistoryElement>
HistoryHolder::GetLastUsedAttackOnTarget(Creature* target, u32 maxDepth) const noexcept {
HistoryHolder::GetLastUsedAttackOnTarget(Creature* non_null target, u32 maxDepth) const noexcept {
ArbUt::OptionalBorrowedPtr<const HistoryElement> c = _top;
auto turn = _getTurnNumber();
while (c.HasValue()) {

4
src/Battling/History/HistoryHolder.hpp
View File

@@ -11,7 +11,7 @@ concept HistoryElementType = std::is_base_of<CreatureLib::Battling::HistoryEleme
namespace CreatureLib::Battling {
class HistoryHolder {
HistoryElement* _top = nullptr;
HistoryElement* nullable _top = nullptr;
std::function<u32()> _getTurnNumber;
public:
@@ -33,7 +33,7 @@ namespace CreatureLib::Battling {
GetLastUsedAttack(u32 maxDepth = 0) const noexcept;
[[nodiscard]] ArbUt::OptionalBorrowedPtr<const HistoryElement>
GetLastUsedAttackOnTarget(Creature* target, u32 maxDepth = 0) const noexcept;
GetLastUsedAttackOnTarget(Creature* non_null target, u32 maxDepth = 0) const noexcept;
[[nodiscard]] ArbUt::OptionalBorrowedPtr<const HistoryElement>
GetLastDamageOnTarget(const ArbUt::BorrowedPtr<const Creature>& creature, u32 maxDepth = 0) const noexcept;

11
src/Battling/Library/BattleLibrary.cpp
View File

@@ -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);
}

11
src/Battling/Library/BattleLibrary.hpp
View File

@@ -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;
};
}

17
src/Battling/Library/BattleStatCalculator.cpp
View File

@@ -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));
}

8
src/Battling/Library/BattleStatCalculator.hpp
View File

@@ -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;
};
}

8
src/Battling/Library/DamageLibrary.cpp
View File

@@ -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)

8
src/Battling/Library/DamageLibrary.hpp
View File

@@ -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;
};
}

2
src/Battling/Library/ExperienceLibrary.cpp
View File

@@ -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())

2
src/Battling/Library/ExperienceLibrary.hpp
View File

@@ -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;
};
}

17
src/Battling/Library/MiscLibrary.cpp
View File

@@ -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;

6
src/Battling/Library/MiscLibrary.hpp
View File

@@ -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;
};
}

2
src/Battling/Models/AttackLearnMethod.hpp
View File

@@ -2,7 +2,7 @@
#define CREATURELIB_ATTACKLEARNMETHOD_HPP
namespace CreatureLib::Battling {
enum class AttackLearnMethod { Unknown, Level };
ENUM(AttackLearnMethod, u8, Unknown, Level);
}
#endif // CREATURELIB_ATTACKLEARNMETHOD_HPP

4
src/Battling/Models/Battle.cpp
View File

@@ -24,7 +24,7 @@ bool Battle::CanUse(const ArbUt::BorrowedPtr<BaseTurnChoice>& choice) {
return true;
}
bool Battle::TrySetChoice(BaseTurnChoice* choice) {
bool Battle::TrySetChoice(BaseTurnChoice* non_null choice) {
EnsureNotNull(choice)
if (!CanUse(choice)) {
return false;
@@ -117,7 +117,7 @@ void Battle::GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) { GetOwnScrip
void Battle::GetOwnScripts(ArbUt::List<ScriptWrapper>& scripts) { scripts.Append(ScriptWrapper::FromSet(&_volatile)); }
void Battle::SwitchCreature(u8 sideIndex, u8 index, Creature* c) {
void Battle::SwitchCreature(u8 sideIndex, u8 index, Creature* nullable c) {
auto side = this->_sides[sideIndex];
side->SetCreature(c, index);
}

18
src/Battling/Models/Battle.hpp
View File

@@ -34,7 +34,7 @@ namespace CreatureLib::Battling {
long _lastTurnTime;
public:
Battle(const BattleLibrary* library, ArbUt::List<BattleParty*> parties, bool canFlee = true,
Battle(const BattleLibrary* non_null library, ArbUt::List<BattleParty * non_null> parties, bool canFlee = true,
u8 numberOfSides = 2, u8 creaturesPerSide = 1,
uint_fast32_t randomSeed = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch())
@@ -55,14 +55,14 @@ namespace CreatureLib::Battling {
inline u8 GetCreaturesPerSide() const noexcept { return _creaturesPerSide; }
virtual bool CanUse(const ArbUt::BorrowedPtr<BaseTurnChoice>& choice);
virtual bool TrySetChoice(BaseTurnChoice* choice);
virtual bool TrySetChoice(BaseTurnChoice* non_null choice);
bool CanFlee() const noexcept { return _canFlee; }
void CheckChoicesSetAndRun();
[[nodiscard]] ArbUt::BorrowedPtr<ChoiceQueue> GetCurrentTurnQueue() const noexcept;
BattleRandom* GetRandom() noexcept;
BattleRandom* non_null GetRandom() noexcept;
bool CreatureInField(ArbUt::BorrowedPtr<Creature> creature) const;
@@ -74,7 +74,7 @@ namespace CreatureLib::Battling {
}
void ForceRecall(u8 side, u8 index);
void SwitchCreature(u8 side, u8 index, Creature* c);
void SwitchCreature(u8 side, u8 index, Creature* nullable c);
bool CanSlotBeFilled(u8 side, u8 index) const;
size_t ScriptCount() const override;
@@ -96,11 +96,11 @@ namespace CreatureLib::Battling {
ArbUt::OptionalBorrowedPtr<BattleScript> GetVolatileScript(u32 keyHash) const noexcept {
return _volatile.Get(keyHash);
}
BattleScript* AddVolatileScript(const ArbUt::StringView& key);
BattleScript* AddVolatileScript(BattleScript* script);
BattleScript* non_null AddVolatileScript(const ArbUt::StringView& key);
BattleScript* non_null AddVolatileScript(BattleScript* non_null script);
void RemoveVolatileScript(const ArbUt::BasicStringView& name) { _volatile.Remove(name); }
void RemoveVolatileScript(u32 keyHash) { _volatile.Remove(keyHash); }
void RemoveVolatileScript(BattleScript* script);
void RemoveVolatileScript(BattleScript* non_null script);
bool HasVolatileScript(const ArbUt::BasicStringView& name) const { return _volatile.Has(name); }
bool HasVolatileScript(u32 keyHash) const { return _volatile.Has(keyHash); }
@@ -117,7 +117,7 @@ namespace CreatureLib::Battling {
try_creature(this->_historyHolder->Register<T>(this->GetCurrentTurn(), args...);
, "Exception occurred during history element registration.");
}
const HistoryHolder* GetHistory() const noexcept { return _historyHolder.GetRaw(); }
const ArbUt::BorrowedPtr<HistoryHolder> GetHistory() const noexcept { return _historyHolder.GetRaw(); }
long GetLastTurnTimeMicroseconds() const noexcept { return _lastTurnTime; }
@@ -136,7 +136,7 @@ namespace CreatureLib::Battling {
}
}
virtual Battle* Clone() const;
virtual Battle* non_null Clone() const;
};
}

4
src/Battling/Models/BattleParty.hpp
View File

@@ -10,7 +10,7 @@ namespace CreatureLib::Battling {
ArbUt::List<CreatureIndex> _responsibleIndices;
public:
BattleParty(CreatureParty* party, const ArbUt::List<CreatureIndex>& responsibleIndices)
BattleParty(CreatureParty* non_null party, const ArbUt::List<CreatureIndex>& responsibleIndices)
: _party(party), _responsibleIndices(responsibleIndices) {}
virtual ~BattleParty() = default;
@@ -43,7 +43,7 @@ namespace CreatureLib::Battling {
return false;
}
virtual BattleParty* Clone() const { return new BattleParty(_party->Clone(), _responsibleIndices); }
virtual BattleParty* non_null Clone() const { return new BattleParty(_party->Clone(), _responsibleIndices); }
};
}

5
src/Battling/Models/BattleRandom.cpp
View File

@@ -3,7 +3,10 @@
#include "Creature.hpp"
#include "ExecutingAttack.hpp"
bool CreatureLib::Battling::BattleRandom::EffectChance(float chance, ExecutingAttack* attack, Creature* target) {
bool CreatureLib::Battling::BattleRandom::EffectChance(float chance, ExecutingAttack* non_null attack,
Creature* non_null target) {
EnsureNotNull(attack);
EnsureNotNull(target);
HOOK(ModifyEffectChance, attack, attack, target, &chance);
HOOK(ModifyIncomingEffectChance, target, attack, target, &chance);
chance /= 100;

2
src/Battling/Models/BattleRandom.hpp
View File

@@ -15,7 +15,7 @@ namespace CreatureLib::Battling {
BattleRandom() noexcept : _random() {}
explicit BattleRandom(uint_fast32_t seed) noexcept : _random(seed) {}
bool EffectChance(float chance, ExecutingAttack* attack, Creature* target);
bool EffectChance(float chance, ExecutingAttack* non_null attack, Creature* non_null target);
i32 Get() noexcept { return _random.Get(); }
i32 Get(i32 max) noexcept { return _random.Get(max); }
i32 Get(i32 min, i32 max) noexcept { return _random.Get(min, max); }

10
src/Battling/Models/BattleSide.hpp
View File

@@ -39,7 +39,7 @@ namespace CreatureLib::Battling {
[[nodiscard]] bool AllPossibleSlotsFilled() const;
void SetChoice(BaseTurnChoice* choice);
void SetChoice(BaseTurnChoice* non_null choice);
void ResetChoices() noexcept;
void ForceClearCreature(u8 index) { _creatures[index] = {}; }
@@ -94,7 +94,7 @@ namespace CreatureLib::Battling {
bool SwapPositions(u8 a, u8 b);
BattleSide* CloneWithoutCreatures(ArbUt::BorrowedPtr<Battle> battle) const;
BattleSide* non_null CloneWithoutCreatures(ArbUt::BorrowedPtr<Battle> battle) const;
ArbUt::OptionalBorrowedPtr<BattleScript> GetVolatileScript(const ArbUt::StringView& key) const {
return _volatile.Get(key);
@@ -102,11 +102,11 @@ namespace CreatureLib::Battling {
ArbUt::OptionalBorrowedPtr<BattleScript> GetVolatileScript(u32 keyHash) const noexcept {
return _volatile.Get(keyHash);
}
BattleScript* AddVolatileScript(const ArbUt::StringView& key);
BattleScript* AddVolatileScript(BattleScript* script);
BattleScript* non_null AddVolatileScript(const ArbUt::StringView& key);
BattleScript* non_null AddVolatileScript(BattleScript* non_null script);
void RemoveVolatileScript(const ArbUt::BasicStringView& name) { _volatile.Remove(name); }
void RemoveVolatileScript(u32 keyHash) { _volatile.Remove(keyHash); }
void RemoveVolatileScript(BattleScript* script);
void RemoveVolatileScript(BattleScript* non_null script);
bool HasVolatileScript(const ArbUt::BasicStringView& name) const { return _volatile.Has(name); }
bool HasVolatileScript(u32 keyHash) const { return _volatile.Has(keyHash); }
};

12
src/Battling/Models/Creature.hpp
View File

@@ -174,10 +174,10 @@ namespace CreatureLib::Battling {
void GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) override;
void GetOwnScripts(ArbUt::List<ScriptWrapper>& scripts) override;
void ClearVolatileScripts();
BattleScript* AddVolatileScript(const ArbUt::StringView& name);
BattleScript* AddVolatileScript(BattleScript* script);
BattleScript* non_null AddVolatileScript(const ArbUt::StringView& name);
BattleScript* non_null AddVolatileScript(BattleScript* non_null script);
void RemoveVolatileScript(const ArbUt::BasicStringView& name);
void RemoveVolatileScript(BattleScript* script);
void RemoveVolatileScript(BattleScript* non_null script);
bool HasVolatileScript(const ArbUt::BasicStringView& name) const;
const ArbUt::OptionalUniquePtrList<LearnedAttack>& GetAttacks() noexcept { return _attacks; }
@@ -205,8 +205,8 @@ namespace CreatureLib::Battling {
inline void SetAllowedExperienceGain(bool allowed) noexcept { _allowedExperienceGain = allowed; }
u8 GetAvailableAttackSlot() const noexcept;
void AddAttack(LearnedAttack* attack);
void ReplaceAttack(size_t index, LearnedAttack* attack);
void AddAttack(LearnedAttack* non_null attack);
void ReplaceAttack(size_t index, LearnedAttack* non_null attack);
void SwapAttacks(size_t a, size_t b) { _attacks.Swap(a, b); }
void SetStatus(const ArbUt::StringView& name);
@@ -231,7 +231,7 @@ namespace CreatureLib::Battling {
// endregion
virtual Creature* Clone() const;
virtual Creature* non_null Clone() const;
};
}

6
src/Battling/Models/CreatureParty.hpp
View File

@@ -13,7 +13,7 @@ namespace CreatureLib::Battling {
_party.Append(nullptr);
}
}
CreatureParty(ArbUt::List<Creature*> party) noexcept : _party(party.GetStdList()) {}
CreatureParty(ArbUt::List<Creature * nullable> party) noexcept : _party(party.GetStdList()) {}
CreatureParty(std::initializer_list<Creature*> party) noexcept : _party(party) {}
virtual ~CreatureParty() = default;
@@ -22,7 +22,7 @@ namespace CreatureLib::Battling {
void Switch(size_t a, size_t b) noexcept { _party.Swap(a, b); }
Creature* SwapInto(size_t index, Creature* creature) {
Creature* nullable SwapInto(size_t index, Creature* nullable creature) {
if (index >= _party.Count()) {
THROW("Index was out of bounds for party.")
}
@@ -67,7 +67,7 @@ namespace CreatureLib::Battling {
return _party.Contains(creature);
}
virtual CreatureParty* Clone() const {
virtual CreatureParty* non_null Clone() const {
auto party = new CreatureParty(_party.Count());
auto i = 0;
for (auto c : _party) {

2
src/Battling/Models/ExecutingAttack.hpp
View File

@@ -68,7 +68,7 @@ namespace CreatureLib::Battling {
THROW("Invalid target requested.");
}
HitData* GetTargetIteratorBegin(ArbUt::BorrowedPtr<Creature> creature) {
HitData* non_null GetTargetIteratorBegin(ArbUt::BorrowedPtr<Creature> creature) {
for (u8 i = 0; i < _targets.Count(); i++) {
if (!_targets[i].HasValue()) {
continue;

127
src/Battling/ScriptHandling/BattleScript.hpp
View File

@@ -36,7 +36,7 @@ namespace CreatureLib::Battling {
virtual ~BattleScript() = default;
virtual BattleScript* Clone(const ArbUt::OptionalBorrowedPtr<void>& owner) = 0;
virtual BattleScript* non_null Clone(const ArbUt::OptionalBorrowedPtr<void>& owner) = 0;
virtual void Stack(){};
virtual void OnRemove(){};
@@ -45,82 +45,89 @@ namespace CreatureLib::Battling {
#define _par_ [[maybe_unused]]
virtual void OnInitialize(_par_ const BattleLibrary*,
virtual void OnInitialize(_par_ const BattleLibrary* non_null,
_par_ const ArbUt::List<CreatureLib::Library::EffectParameter*>& parameters){};
virtual void OnBeforeTurn(_par_ const BaseTurnChoice* choice){};
virtual void OnBeforeTurn(_par_ const BaseTurnChoice* non_null choice){};
virtual void ChangeSpeed(_par_ BaseTurnChoice* choice, _par_ u32* speed){};
virtual void ChangePriority(_par_ AttackTurnChoice* choice, _par_ i8* priority){};
virtual void ChangeAttack(_par_ AttackTurnChoice* choice, _par_ ArbUt::StringView* outAttack){};
virtual void ModifyNumberOfHits(_par_ AttackTurnChoice* choice, _par_ u8* numberOfHits){};
virtual void PreventAttack(_par_ ExecutingAttack* attack, _par_ bool* outResult){};
virtual void FailAttack(_par_ ExecutingAttack* attack, _par_ bool* outFailed){};
virtual void StopBeforeAttack(_par_ ExecutingAttack* attack, _par_ bool* outResult){};
virtual void OnBeforeAttack(_par_ ExecutingAttack* attack){};
virtual void ChangeSpeed(_par_ BaseTurnChoice* non_null choice, _par_ u32* non_null speed){};
virtual void ChangePriority(_par_ AttackTurnChoice* non_null choice, _par_ i8* non_null priority){};
virtual void ChangeAttack(_par_ AttackTurnChoice* non_null choice,
_par_ ArbUt::StringView* non_null outAttack){};
virtual void ModifyNumberOfHits(_par_ AttackTurnChoice* non_null choice, _par_ u8* non_null numberOfHits){};
virtual void PreventAttack(_par_ ExecutingAttack* non_null attack, _par_ bool* non_null outResult){};
virtual void FailAttack(_par_ ExecutingAttack* non_null attack, _par_ bool* non_null outFailed){};
virtual void StopBeforeAttack(_par_ ExecutingAttack* non_null attack, _par_ bool* non_null outResult){};
virtual void OnBeforeAttack(_par_ ExecutingAttack* non_null attack){};
virtual void FailIncomingAttack(_par_ ExecutingAttack* attack, _par_ Creature* target, _par_ bool* outResult){};
virtual void IsInvulnerable(_par_ ExecutingAttack* attack, _par_ Creature* target, _par_ bool* outResult){};
virtual void OnAttackMiss(_par_ ExecutingAttack* attack, _par_ Creature* target){};
virtual void ChangeAttackType(_par_ ExecutingAttack* attack, _par_ Creature* target, _par_ u8 hitNumber,
_par_ u8* outType){};
virtual void ChangeEffectiveness(_par_ ExecutingAttack* attack, _par_ Creature* target, _par_ u8 hitNumber,
_par_ float* effectiveness){};
virtual void BlockCritical(_par_ ExecutingAttack* attack, _par_ Creature* target, _par_ u8 hitNumber,
_par_ bool* blockCritical){};
virtual void FailIncomingAttack(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ bool* non_null outResult){};
virtual void IsInvulnerable(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ bool* non_null outResult){};
virtual void OnAttackMiss(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target){};
virtual void ChangeAttackType(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitNumber, _par_ u8* non_null outType){};
virtual void ChangeEffectiveness(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitNumber, _par_ float* non_null effectiveness){};
virtual void BlockCritical(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitNumber, _par_ bool* non_null blockCritical){};
virtual void OverrideBasePower(_par_ ExecutingAttack* attack, _par_ Creature* target, _par_ u8 hitIndex,
_par_ u8* basePower){};
virtual void ChangeDamageStatsUser(_par_ ExecutingAttack* attack, _par_ Creature* target, _par_ u8 hitIndex,
_par_ Creature** statsUser){};
virtual void OverrideBasePower(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitIndex, _par_ u8* non_null basePower){};
virtual void ChangeDamageStatsUser(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitIndex, _par_ Creature* non_null* non_null statsUser){};
virtual void BypassDefensiveStat(_par_ ExecutingAttack* attack, _par_ Creature* target, _par_ u8 hitIndex,
_par_ bool* bypass){};
virtual void BypassOffensiveStat(_par_ ExecutingAttack* attack, _par_ Creature* target, _par_ u8 hitIndex,
_par_ bool* bypass){};
virtual void ModifyStatModifier(_par_ ExecutingAttack* attack, _par_ Creature* target, _par_ u8 hitIndex,
_par_ float* modifier){};
virtual void ModifyDamageModifier(_par_ ExecutingAttack* attack, _par_ Creature* target, _par_ u8 hitIndex,
_par_ float* modifier){};
virtual void OverrideDamage(_par_ ExecutingAttack* attack, _par_ Creature* target, _par_ u8 hitIndex,
_par_ u32* damage){};
virtual void OverrideIncomingDamage(_par_ ExecutingAttack* attack, _par_ Creature* target, _par_ u8 hitIndex,
_par_ u32* damage){};
virtual void BypassDefensiveStat(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitIndex, _par_ bool* non_null bypass){};
virtual void BypassOffensiveStat(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitIndex, _par_ bool* non_null bypass){};
virtual void ModifyStatModifier(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitIndex, _par_ float* non_null modifier){};
virtual void ModifyDamageModifier(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitIndex, _par_ float* non_null modifier){};
virtual void OverrideDamage(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitIndex, _par_ u32* non_null damage){};
virtual void OverrideIncomingDamage(_par_ ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitIndex, _par_ u32* non_null damage){};
virtual void OnIncomingHit(_par_ const ExecutingAttack* attack, _par_ Creature* target, _par_ u8 hitNumber){};
virtual void OnFaintingOpponent(_par_ const ExecutingAttack* attack, _par_ Creature* target,
virtual void OnIncomingHit(_par_ const ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitNumber){};
virtual void OnFaintingOpponent(_par_ const ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitNumber){};
virtual void PreventStatBoostChange(_par_ Creature* target, _par_ Library::Statistic stat, _par_ i8 diffAmount,
_par_ bool selfInflicted, _par_ bool* prevent){};
virtual void ModifyStatBoostChange(_par_ Creature* target, _par_ Library::Statistic stat,
_par_ i8* diffAmount){};
virtual void PreventSecondaryEffects(_par_ const ExecutingAttack* attack, _par_ Creature* target,
_par_ u8 hitNumber, _par_ bool* outResult){};
virtual void OnSecondaryEffect(_par_ const ExecutingAttack* attack, _par_ Creature* target,
virtual void PreventStatBoostChange(_par_ Creature* non_null target, _par_ Library::Statistic stat,
_par_ i8 diffAmount, _par_ bool selfInflicted,
_par_ bool* non_null prevent){};
virtual void ModifyStatBoostChange(_par_ Creature* non_null target, _par_ Library::Statistic stat,
_par_ i8* non_null diffAmount){};
virtual void PreventSecondaryEffects(_par_ const ExecutingAttack* non_null attack,
_par_ Creature* non_null target, _par_ u8 hitNumber,
_par_ bool* non_null outResult){};
virtual void OnSecondaryEffect(_par_ const ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ u8 hitNumber){};
virtual void OnAfterHits(_par_ const ExecutingAttack* attack, _par_ Creature* target){};
virtual void OnAfterHits(_par_ const ExecutingAttack* non_null attack, _par_ Creature* non_null target){};
virtual void PreventSelfSwitch(_par_ const SwitchTurnChoice* choice, _par_ bool* outResult){};
virtual void PreventOpponentSwitch(_par_ const SwitchTurnChoice* choice, _par_ bool* outResult){};
virtual void PreventSelfSwitch(_par_ const SwitchTurnChoice* non_null choice, _par_ bool* non_null outResult){};
virtual void PreventOpponentSwitch(_par_ const SwitchTurnChoice* non_null choice,
_par_ bool* non_null outResult){};
virtual void ModifyEffectChance(_par_ const ExecutingAttack* attack, _par_ Creature* target,
_par_ float* chance){};
virtual void ModifyIncomingEffectChance(_par_ const ExecutingAttack* attack, _par_ Creature* target,
_par_ float* chance){};
virtual void ModifyEffectChance(_par_ const ExecutingAttack* non_null attack, _par_ Creature* non_null target,
_par_ float* non_null chance){};
virtual void ModifyIncomingEffectChance(_par_ const ExecutingAttack* non_null attack,
_par_ Creature* non_null target, _par_ float* non_null chance){};
virtual void OnFail(_par_ Creature* target){};
virtual void OnOpponentFail(_par_ Creature* target){};
virtual void OnFail(_par_ Creature* non_null target){};
virtual void OnOpponentFail(_par_ Creature* non_null target){};
virtual void PreventRunAway(_par_ const FleeTurnChoice* choice, _par_ bool* result){};
virtual void PreventOpponentRunAway(_par_ const FleeTurnChoice* choice, _par_ bool* result){};
virtual void PreventRunAway(_par_ const FleeTurnChoice* non_null choice, _par_ bool* non_null result){};
virtual void PreventOpponentRunAway(_par_ const FleeTurnChoice* non_null choice, _par_ bool* non_null result){};
virtual void OnEndTurn(){};
virtual void OnDamage(Creature*, DamageSource, _par_ u32 oldHealth, _par_ u32 newHealth){};
virtual void OnFaint(Creature*, DamageSource){};
virtual void OnSwitchIn(Creature*){};
virtual void OnDamage(Creature* non_null, DamageSource, _par_ u32 oldHealth, _par_ u32 newHealth){};
virtual void OnFaint(Creature* non_null, DamageSource){};
virtual void OnSwitchIn(Creature* non_null){};
virtual void OnAfterHeldItemConsume(Creature*, const Library::Item*){};
virtual void OnAfterHeldItemConsume(Creature* non_null, const Library::Item* non_null){};
};
}

13
src/Battling/ScriptHandling/ItemUseScript.hpp
View File

@@ -11,20 +11,23 @@ namespace CreatureLib::Battling {
public:
virtual ~ItemUseScript() = default;
virtual void
OnInitialize([[maybe_unused]] const ArbUt::List<CreatureLib::Library::EffectParameter*>& parameters){};
virtual void OnInitialize(
[[maybe_unused]] const ArbUt::List<CreatureLib::Library::EffectParameter * non_null>& parameters){};
/// @brief Is the item an item we are able to use?
[[nodiscard]] virtual bool IsItemUsable() const { return false; }
/// @brief Do we need to use the item on a creature?
[[nodiscard]] virtual bool IsCreatureUseItem() const { return false; }
/// @brief Can the item be used on the given creature.
[[nodiscard]] virtual bool IsUseValidForCreature([[maybe_unused]] Creature* creature) const { return false; }
[[nodiscard]] virtual bool IsUseValidForCreature([[maybe_unused]] Creature* non_null creature) const {
return false;
}
/// @brief Can the item be held?
[[nodiscard]] virtual bool IsHoldable() const { return false; }
virtual void OnUse([[maybe_unused]] Battle* battle) const {}
virtual void OnCreatureUse([[maybe_unused]] Creature* creature, [[maybe_unused]] bool isBattle) const {}
virtual void OnUse([[maybe_unused]] Battle* non_null battle) const {}
virtual void OnCreatureUse([[maybe_unused]] Creature* non_null creature, [[maybe_unused]] bool isBattle) const {
}
};
}

11
src/Battling/ScriptHandling/ScriptResolver.hpp
View File

@@ -17,14 +17,15 @@ namespace CreatureLib::Battling {
virtual ~ScriptResolver() = default;
virtual void Initialize([[maybe_unused]] BattleLibrary* library){};
virtual BattleScript* LoadScript([[maybe_unused]] const ArbUt::OptionalBorrowedPtr<void>& owner,
[[maybe_unused]] ScriptCategory category,
[[maybe_unused]] const ArbUt::StringView& scriptName) {
virtual void Initialize([[maybe_unused]] BattleLibrary* non_null library){};
virtual BattleScript* nullable LoadScript([[maybe_unused]] const ArbUt::OptionalBorrowedPtr<void>& owner,
[[maybe_unused]] ScriptCategory category,
[[maybe_unused]] const ArbUt::StringView& scriptName) {
return nullptr;
};
virtual ItemUseScript* LoadItemScript([[maybe_unused]] const CreatureLib::Library::Item* item) {
virtual ItemUseScript* nullable
LoadItemScript([[maybe_unused]] const CreatureLib::Library::Item* non_null item) {
return nullptr;
};
};

2
src/Battling/ScriptHandling/ScriptSet.hpp
View File

@@ -22,7 +22,7 @@ namespace CreatureLib::Battling {
}
}
BattleScript* Add(BattleScript* script) {
BattleScript* non_null Add(BattleScript* non_null script) {
auto v = _lookup.TryGet(script->GetName());
if (v.has_value()) {
_scripts[v.value()]->Stack();

18
src/Battling/ScriptHandling/ScriptWrapper.hpp
View File

@@ -9,21 +9,23 @@ namespace CreatureLib::Battling {
bool _isSet;
union {
std::unique_ptr<BattleScript> const* _script;
const ScriptSet* _scriptSet;
std::unique_ptr<BattleScript> const* nullable _script;
const ScriptSet* nullable _scriptSet;
};
ScriptWrapper(std::unique_ptr<BattleScript>* s, bool isSet) : _isSet(isSet), _script(s){};
ScriptWrapper(ScriptSet* s, bool isSet) : _isSet(isSet), _scriptSet(s){};
ScriptWrapper(std::unique_ptr<BattleScript>* nullable s, bool isSet) : _isSet(isSet), _script(s){};
ScriptWrapper(ScriptSet* nullable s, bool isSet) : _isSet(isSet), _scriptSet(s){};
public:
static inline ScriptWrapper FromScript(std::unique_ptr<BattleScript>* s) { return ScriptWrapper(s, false); }
static inline ScriptWrapper FromSet(ScriptSet* s) { return ScriptWrapper(s, true); }
static inline ScriptWrapper FromScript(std::unique_ptr<BattleScript>* nullable s) {
return ScriptWrapper(s, false);
}
static inline ScriptWrapper FromSet(ScriptSet* nullable s) { return ScriptWrapper(s, true); }
inline bool IsSet() const noexcept { return _isSet; }
inline const std::unique_ptr<BattleScript>* GetScript() const noexcept { return _script; }
inline const ScriptSet* GetScriptSet() const noexcept { return _scriptSet; }
inline const std::unique_ptr<BattleScript>* nullable GetScript() const noexcept { return _script; }
inline const ScriptSet* nullable GetScriptSet() const noexcept { return _scriptSet; }
inline bool HasValue() const noexcept {
if (_isSet)