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

Update to latest Arbutils, use new integer defines

This commit is contained in:
Deukhoofd 2022-03-23 13:56:45 +01:00
parent 52127f6555
commit 3cc19de61f
Signed by: Deukhoofd
GPG Key ID: F63E044490819F6F
102 changed files with 687 additions and 742 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
CInterface/Battling/Battle.cpp
View File

@ -2,9 +2,9 @@
#include "../Core.hpp" #include "../Core.hpp"
using namespace CreatureLib::Battling; using namespace CreatureLib::Battling;
export uint8_t CreatureLib_Battle_Construct(Battle*& out, const BattleLibrary* library, BattleParty* partyArr[], export u8 CreatureLib_Battle_Construct(Battle*& out, const BattleLibrary* library, BattleParty* partyArr[],
size_t numberOfParties, bool canFlee, uint8_t numberOfSides, size_t numberOfParties, bool canFlee, u8 numberOfSides, u8 creaturesPerSide,
uint8_t creaturesPerSide, uint_fast32_t randomSeed) { uint_fast32_t randomSeed) {
Try(ArbUt::List<BattleParty*> parties(partyArr, partyArr + numberOfParties); Try(ArbUt::List<BattleParty*> parties(partyArr, partyArr + numberOfParties);
out = new Battle(library, parties, canFlee, numberOfSides, creaturesPerSide, randomSeed);) out = new Battle(library, parties, canFlee, numberOfSides, creaturesPerSide, randomSeed);)
} }
@ -12,38 +12,36 @@ export uint8_t CreatureLib_Battle_Construct(Battle*& out, const BattleLibrary* l
export void CreatureLib_Battle_Destruct(const Battle* p) { delete p; } export void CreatureLib_Battle_Destruct(const Battle* p) { delete p; }
export const BattleLibrary* CreatureLib_Battle_GetLibrary(const Battle* p) { return p->GetLibrary().GetRaw(); } export const BattleLibrary* CreatureLib_Battle_GetLibrary(const Battle* p) { return p->GetLibrary().GetRaw(); }
export uint8_t CreatureLib_Battle_CanUse(bool& out, Battle* p, BaseTurnChoice* turnChoice) { export u8 CreatureLib_Battle_CanUse(bool& out, Battle* p, BaseTurnChoice* turnChoice) {
Try(out = p->CanUse(turnChoice);) Try(out = p->CanUse(turnChoice);)
} }
export uint8_t CreatureLib_Battle_TrySetChoice(bool& out, Battle* p, BaseTurnChoice* turnChoice) { export u8 CreatureLib_Battle_TrySetChoice(bool& out, Battle* p, BaseTurnChoice* turnChoice) {
Try(out = p->TrySetChoice(turnChoice);) Try(out = p->TrySetChoice(turnChoice);)
} }
export bool CreatureLib_Battle_CanFlee(const Battle* p) { return p->CanFlee(); } export bool CreatureLib_Battle_CanFlee(const Battle* p) { return p->CanFlee(); }
export uint8_t CreatureLib_Battle_CheckChoicesSetAndRun(Battle* p) { Try(p->CheckChoicesSetAndRun();) } export u8 CreatureLib_Battle_CheckChoicesSetAndRun(Battle* p) { Try(p->CheckChoicesSetAndRun();) }
export uint32_t CreatureLib_Battle_GetCurrentTurn(Battle* p) { return p->GetCurrentTurn(); } export u32 CreatureLib_Battle_GetCurrentTurn(Battle* p) { return p->GetCurrentTurn(); }
export uint32_t CreatureLib_Battle_GetCreaturesPerSide(Battle* p) { return p->GetCreaturesPerSide(); } export u32 CreatureLib_Battle_GetCreaturesPerSide(Battle* p) { return p->GetCreaturesPerSide(); }
export ChoiceQueue* CreatureLib_Battle_GetCurrentTurnQueue(const Battle* p) { export ChoiceQueue* CreatureLib_Battle_GetCurrentTurnQueue(const Battle* p) {
return p->GetCurrentTurnQueue().GetRaw(); return p->GetCurrentTurnQueue().GetRaw();
} }
export BattleRandom* CreatureLib_Battle_GetRandom(Battle* p) { return p->GetRandom(); } export BattleRandom* CreatureLib_Battle_GetRandom(Battle* p) { return p->GetRandom(); }
export uint8_t CreatureLib_Battle_CreatureInField(bool& out, const Battle* p, Creature* c) { export u8 CreatureLib_Battle_CreatureInField(bool& out, const Battle* p, Creature* c) {
Try(out = p->CreatureInField(c);) Try(out = p->CreatureInField(c);)
} }
export uint8_t CreatureLib_Battle_GetCreature(Creature*& out, const Battle* p, uint8_t side, uint8_t target) { export u8 CreatureLib_Battle_GetCreature(Creature*& out, const Battle* p, u8 side, u8 target) {
Try(out = p->GetCreature(side, target).GetValue();) Try(out = p->GetCreature(side, target).GetValue();)
} }
export uint8_t CreatureLib_Battle_ForceRecall(Battle* p, uint8_t side, uint8_t target) { export u8 CreatureLib_Battle_ForceRecall(Battle* p, u8 side, u8 target) { Try(p->ForceRecall(side, target);) }
Try(p->ForceRecall(side, target);) export u8 CreatureLib_Battle_SwitchCreature(Battle* p, u8 side, u8 target, Creature* c) {
}
export uint8_t CreatureLib_Battle_SwitchCreature(Battle* p, uint8_t side, uint8_t target, Creature* c) {
Try(p->SwitchCreature(side, target, c);) Try(p->SwitchCreature(side, target, c);)
} }
export uint8_t CreatureLib_Battle_CanSlotBeFilled(bool& out, const Battle* p, uint8_t side, uint8_t target) { export u8 CreatureLib_Battle_CanSlotBeFilled(bool& out, const Battle* p, u8 side, u8 target) {
Try(out = p->CanSlotBeFilled(side, target);) Try(out = p->CanSlotBeFilled(side, target);)
} }
export uint8_t CreatureLib_Battle_ValidateBattleState(Battle* p) { Try(p->ValidateBattleState();) } export u8 CreatureLib_Battle_ValidateBattleState(Battle* p) { Try(p->ValidateBattleState();) }
export bool CreatureLib_Battle_HasEnded(const Battle* p) { return p->HasEnded(); } export bool CreatureLib_Battle_HasEnded(const Battle* p) { return p->HasEnded(); }
export bool CreatureLib_Battle_HasConclusiveResult(const Battle* p) { return p->GetResult().IsConclusiveResult(); } export bool CreatureLib_Battle_HasConclusiveResult(const Battle* p) { return p->GetResult().IsConclusiveResult(); }
@ -64,29 +62,27 @@ export BattleScript* CreatureLib_Battle_GetVolatileScript(Battle* p, const char*
} }
return v.GetValue(); return v.GetValue();
} }
export uint8_t CreatureLib_Battle_AddVolatileScriptByName(Battle* p, const char* key) { export u8 CreatureLib_Battle_AddVolatileScriptByName(Battle* p, const char* key) {
Try(p->AddVolatileScript(ArbUt::StringView(key));) Try(p->AddVolatileScript(ArbUt::StringView(key));)
} }
export uint8_t CreatureLib_Battle_AddVolatileScript(Battle* p, BattleScript* script) { export u8 CreatureLib_Battle_AddVolatileScript(Battle* p, BattleScript* script) { Try(p->AddVolatileScript(script);) }
Try(p->AddVolatileScript(script);)
}
export uint8_t CreatureLib_Battle_RemoveVolatileScript(Battle* p, const char* key) { export u8 CreatureLib_Battle_RemoveVolatileScript(Battle* p, const char* key) {
Try(p->RemoveVolatileScript(ArbUt::StringView::CalculateHash(key));) Try(p->RemoveVolatileScript(ArbUt::StringView::CalculateHash(key));)
} }
export uint8_t CreatureLib_Battle_RemoveVolatileScriptWithScript(Battle* p, BattleScript* script) { export u8 CreatureLib_Battle_RemoveVolatileScriptWithScript(Battle* p, BattleScript* script) {
Try(p->RemoveVolatileScript(script);) Try(p->RemoveVolatileScript(script);)
} }
export bool CreatureLib_Battle_HasVolatileScript(Battle* p, const char* key) { export bool CreatureLib_Battle_HasVolatileScript(Battle* p, const char* key) {
return p->HasVolatileScript(ArbUt::StringView::CalculateHash(key)); return p->HasVolatileScript(ArbUt::StringView::CalculateHash(key));
} }
export uint8_t CreatureLib_Battle_RegisterEventListener(Battle* p, void (*func)(const EventData*)) { export u8 CreatureLib_Battle_RegisterEventListener(Battle* p, void (*func)(const EventData*)) {
Try(p->RegisterEventListener(func);) Try(p->RegisterEventListener(func);)
} }
export const HistoryHolder* CreatureLib_Battle_GetHistory(Battle* p) { return p->GetHistory(); } export const HistoryHolder* CreatureLib_Battle_GetHistory(Battle* p) { return p->GetHistory(); }
export uint8_t CreatureLib_Battle_EndBattle(Battle* p) { Try(p->EndBattle()) } export u8 CreatureLib_Battle_EndBattle(Battle* p) { Try(p->EndBattle()) }
export uint8_t CreatureLib_Battle_ClearBattle(Battle* p) { Try(p->ClearBattle()) } export u8 CreatureLib_Battle_ClearBattle(Battle* p) { Try(p->ClearBattle()) }
SIMPLE_GET_FUNC(Battle, GetLastTurnTimeMicroseconds, long); SIMPLE_GET_FUNC(Battle, GetLastTurnTimeMicroseconds, long);

10
CInterface/Battling/BattleLibrary.cpp
View File

@ -2,11 +2,11 @@
#include "../Core.hpp" #include "../Core.hpp"
using namespace CreatureLib::Battling; using namespace CreatureLib::Battling;
export uint8_t CreatureLib_BattleLibrary_Construct(const BattleLibrary*& out, export u8 CreatureLib_BattleLibrary_Construct(const BattleLibrary*& out,
const CreatureLib::Library::DataLibrary* staticLib, const CreatureLib::Library::DataLibrary* staticLib,
BattleStatCalculator* statCalculator, DamageLibrary* damageLibrary, BattleStatCalculator* statCalculator, DamageLibrary* damageLibrary,
ExperienceLibrary* experienceLibrary, ScriptResolver* scriptResolver, ExperienceLibrary* experienceLibrary, ScriptResolver* scriptResolver,
MiscLibrary* miscLibrary) { MiscLibrary* miscLibrary) {
Try(out = new BattleLibrary(staticLib, statCalculator, damageLibrary, experienceLibrary, scriptResolver, Try(out = new BattleLibrary(staticLib, statCalculator, damageLibrary, experienceLibrary, scriptResolver,
miscLibrary);) miscLibrary);)
} }

7
CInterface/Battling/BattleParty.cpp
View File

@ -4,8 +4,8 @@ using namespace CreatureLib::Battling;
// Note that creatureIndices should be twice the size of numberOfIndices, and have index of side, index of creature on // Note that creatureIndices should be twice the size of numberOfIndices, and have index of side, index of creature on
// side, one after the other. // side, one after the other.
export uint8_t CreatureLib_BattleParty_Construct(BattleParty*& out, CreatureParty* p, uint8_t creatureIndices[], export u8 CreatureLib_BattleParty_Construct(BattleParty*& out, CreatureParty* p, u8 creatureIndices[],
size_t numberOfIndices) { size_t numberOfIndices) {
Try(ArbUt::List<CreatureIndex> indices(numberOfIndices); for (size_t i = 0; i < numberOfIndices; i++) { Try(ArbUt::List<CreatureIndex> indices(numberOfIndices); for (size_t i = 0; i < numberOfIndices; i++) {
indices.Append(CreatureIndex(creatureIndices[i * 2], creatureIndices[i * 2 + 1])); indices.Append(CreatureIndex(creatureIndices[i * 2], creatureIndices[i * 2 + 1]));
} out = new BattleParty(p, indices);) } out = new BattleParty(p, indices);)
@ -14,8 +14,7 @@ export uint8_t CreatureLib_BattleParty_Construct(BattleParty*& out, CreaturePart
export void CreatureLib_BattleParty_Destruct(const BattleParty* p) { delete p; } export void CreatureLib_BattleParty_Destruct(const BattleParty* p) { delete p; }
BORROWED_GET_FUNC(BattleParty, GetParty, CreatureParty*); BORROWED_GET_FUNC(BattleParty, GetParty, CreatureParty*);
export uint8_t CreatureLib_BattleParty_IsResponsibleForIndex(bool& out, const BattleParty* p, uint8_t side, export u8 CreatureLib_BattleParty_IsResponsibleForIndex(bool& out, const BattleParty* p, u8 side, u8 creature) {
uint8_t creature) {
Try(out = p->IsResponsibleForIndex(side, creature);) Try(out = p->IsResponsibleForIndex(side, creature);)
} }
export bool CreatureLib_BattleParty_HasCreaturesNotInField(const BattleParty* p) { return p->HasCreaturesNotInField(); } export bool CreatureLib_BattleParty_HasCreaturesNotInField(const BattleParty* p) { return p->HasCreaturesNotInField(); }

78
CInterface/Battling/BattleScript.cpp
View File

@ -4,92 +4,92 @@ using namespace CreatureLib::Battling;
export void CreatureLib_Script_Destruct(BattleScript* p) { delete p; } export void CreatureLib_Script_Destruct(BattleScript* p) { delete p; }
export uint8_t CreatureLib_Script_Stack(BattleScript* p) { Try(p->Stack()); } export u8 CreatureLib_Script_Stack(BattleScript* p) { Try(p->Stack()); }
export uint8_t CreatureLib_Script_OnRemove(BattleScript* p) { Try(p->OnRemove()); } export u8 CreatureLib_Script_OnRemove(BattleScript* p) { Try(p->OnRemove()); }
export const char* CreatureLib_Script_GetName(BattleScript* p) { return p->GetName().c_str(); } export const char* CreatureLib_Script_GetName(BattleScript* p) { return p->GetName().c_str(); }
export uint8_t CreatureLib_Script_OnBeforeTurn(BattleScript* p, const BaseTurnChoice* choice) { export u8 CreatureLib_Script_OnBeforeTurn(BattleScript* p, const BaseTurnChoice* choice) {
Try(p->OnBeforeTurn(choice)); Try(p->OnBeforeTurn(choice));
} }
export uint8_t CreatureLib_Script_ChangeAttack(BattleScript* p, AttackTurnChoice* choice, const char*& outAttack) { export u8 CreatureLib_Script_ChangeAttack(BattleScript* p, AttackTurnChoice* choice, const char*& outAttack) {
Try(auto sv = ArbUt::StringView(outAttack); p->ChangeAttack(choice, &sv); outAttack = sv.c_str();); Try(auto sv = ArbUt::StringView(outAttack); p->ChangeAttack(choice, &sv); outAttack = sv.c_str(););
} }
export uint8_t CreatureLib_Script_PreventAttack(BattleScript* p, ExecutingAttack* attack, bool* outResult) { export u8 CreatureLib_Script_PreventAttack(BattleScript* p, ExecutingAttack* attack, bool* outResult) {
Try(p->PreventAttack(attack, outResult)); Try(p->PreventAttack(attack, outResult));
} }
export uint8_t CreatureLib_Script_FailAttack(BattleScript* p, ExecutingAttack* attack, bool* outResult) { export u8 CreatureLib_Script_FailAttack(BattleScript* p, ExecutingAttack* attack, bool* outResult) {
Try(p->FailAttack(attack, outResult)); Try(p->FailAttack(attack, outResult));
} }
export uint8_t CreatureLib_Script_StopBeforeAttack(BattleScript* p, ExecutingAttack* attack, bool* outResult) { export u8 CreatureLib_Script_StopBeforeAttack(BattleScript* p, ExecutingAttack* attack, bool* outResult) {
Try(p->StopBeforeAttack(attack, outResult)); Try(p->StopBeforeAttack(attack, outResult));
} }
export uint8_t CreatureLib_Script_OnBeforeAttack(BattleScript* p, ExecutingAttack* attack) { export u8 CreatureLib_Script_OnBeforeAttack(BattleScript* p, ExecutingAttack* attack) {
Try(p->OnBeforeAttack(attack)); Try(p->OnBeforeAttack(attack));
} }
export uint8_t CreatureLib_Script_FailIncomingAttack(BattleScript* p, ExecutingAttack* attack, Creature* target, export u8 CreatureLib_Script_FailIncomingAttack(BattleScript* p, ExecutingAttack* attack, Creature* target,
bool* outResult) { bool* outResult) {
Try(p->FailIncomingAttack(attack, target, outResult)); Try(p->FailIncomingAttack(attack, target, outResult));
} }
export uint8_t CreatureLib_Script_IsInvulnerable(BattleScript* p, ExecutingAttack* attack, Creature* target, export u8 CreatureLib_Script_IsInvulnerable(BattleScript* p, ExecutingAttack* attack, Creature* target,
bool* outResult) { bool* outResult) {
Try(p->IsInvulnerable(attack, target, outResult)); Try(p->IsInvulnerable(attack, target, outResult));
} }
export uint8_t CreatureLib_Script_OnAttackMiss(BattleScript* p, ExecutingAttack* attack, Creature* target) { export u8 CreatureLib_Script_OnAttackMiss(BattleScript* p, ExecutingAttack* attack, Creature* target) {
Try(p->OnAttackMiss(attack, target)); Try(p->OnAttackMiss(attack, target));
} }
export uint8_t CreatureLib_Script_ChangeAttackType(BattleScript* p, ExecutingAttack* attack, Creature* target, export u8 CreatureLib_Script_ChangeAttackType(BattleScript* p, ExecutingAttack* attack, Creature* target, u8 hitNumber,
uint8_t hitNumber, uint8_t* outType) { u8* outType) {
Try(p->ChangeAttackType(attack, target, hitNumber, outType)) Try(p->ChangeAttackType(attack, target, hitNumber, outType))
} }
export uint8_t CreatureLib_Script_OverrideBasePower(BattleScript* p, ExecutingAttack* attack, Creature* target, export u8 CreatureLib_Script_OverrideBasePower(BattleScript* p, ExecutingAttack* attack, Creature* target, u8 hitNumber,
uint8_t hitNumber, uint8_t* basePower) { u8* basePower) {
Try(p->OverrideBasePower(attack, target, hitNumber, basePower)); Try(p->OverrideBasePower(attack, target, hitNumber, basePower));
} }
export uint8_t CreatureLib_Script_ChangeDamageStatsUser(BattleScript* p, ExecutingAttack* attack, Creature* target, export u8 CreatureLib_Script_ChangeDamageStatsUser(BattleScript* p, ExecutingAttack* attack, Creature* target,
uint8_t hitNumber, Creature** statsUser) { u8 hitNumber, Creature** statsUser) {
Try(p->ChangeDamageStatsUser(attack, target, hitNumber, statsUser)); Try(p->ChangeDamageStatsUser(attack, target, hitNumber, statsUser));
} }
export uint8_t CreatureLib_Script_BypassDefensiveStat(BattleScript* p, ExecutingAttack* attack, Creature* target, export u8 CreatureLib_Script_BypassDefensiveStat(BattleScript* p, ExecutingAttack* attack, Creature* target,
uint8_t hitNumber, bool* bypass) { u8 hitNumber, bool* bypass) {
Try(p->BypassDefensiveStat(attack, target, hitNumber, bypass)); Try(p->BypassDefensiveStat(attack, target, hitNumber, bypass));
} }
export uint8_t CreatureLib_Script_BypassOffensiveStat(BattleScript* p, ExecutingAttack* attack, Creature* target, export u8 CreatureLib_Script_BypassOffensiveStat(BattleScript* p, ExecutingAttack* attack, Creature* target,
uint8_t hitNumber, bool* bypass) { u8 hitNumber, bool* bypass) {
Try(p->BypassOffensiveStat(attack, target, hitNumber, bypass)); Try(p->BypassOffensiveStat(attack, target, hitNumber, bypass));
} }
export uint8_t CreatureLib_Script_ModifyStatModifier(BattleScript* p, ExecutingAttack* attack, Creature* target, export u8 CreatureLib_Script_ModifyStatModifier(BattleScript* p, ExecutingAttack* attack, Creature* target,
uint8_t hitNumber, float* modifier) { u8 hitNumber, float* modifier) {
Try(p->ModifyStatModifier(attack, target, hitNumber, modifier)); Try(p->ModifyStatModifier(attack, target, hitNumber, modifier));
} }
export uint8_t CreatureLib_Script_ModifyDamageModifier(BattleScript* p, ExecutingAttack* attack, Creature* target, export u8 CreatureLib_Script_ModifyDamageModifier(BattleScript* p, ExecutingAttack* attack, Creature* target,
uint8_t hitNumber, float* modifier) { u8 hitNumber, float* modifier) {
Try(p->ModifyDamageModifier(attack, target, hitNumber, modifier)); Try(p->ModifyDamageModifier(attack, target, hitNumber, modifier));
} }
export uint8_t CreatureLib_Script_OverrideDamage(BattleScript* p, ExecutingAttack* attack, Creature* target, export u8 CreatureLib_Script_OverrideDamage(BattleScript* p, ExecutingAttack* attack, Creature* target, u8 hitNumber,
uint8_t hitNumber, uint32_t* damage) { u32* damage) {
Try(p->OverrideDamage(attack, target, hitNumber, damage)); Try(p->OverrideDamage(attack, target, hitNumber, damage));
} }
export uint8_t CreatureLib_Script_PreventSecondaryEffects(BattleScript* p, ExecutingAttack* attack, Creature* target, export u8 CreatureLib_Script_PreventSecondaryEffects(BattleScript* p, ExecutingAttack* attack, Creature* target,
uint8_t hitNumber, bool* outResult) { u8 hitNumber, bool* outResult) {
Try(p->PreventSecondaryEffects(attack, target, hitNumber, outResult)); Try(p->PreventSecondaryEffects(attack, target, hitNumber, outResult));
} }
export uint8_t CreatureLib_Script_OnSecondaryEffect(BattleScript* p, ExecutingAttack* attack, Creature* target, export u8 CreatureLib_Script_OnSecondaryEffect(BattleScript* p, ExecutingAttack* attack, Creature* target,
uint8_t hitNumber) { u8 hitNumber) {
Try(p->OnSecondaryEffect(attack, target, hitNumber)); Try(p->OnSecondaryEffect(attack, target, hitNumber));
} }
export uint8_t CreatureLib_Script_OnAfterHits(BattleScript* p, ExecutingAttack* attack, Creature* target) { export u8 CreatureLib_Script_OnAfterHits(BattleScript* p, ExecutingAttack* attack, Creature* target) {
Try(p->OnAfterHits(attack, target)); Try(p->OnAfterHits(attack, target));
} }
export uint8_t CreatureLib_Script_PreventSelfSwitch(BattleScript* p, const SwitchTurnChoice* choice, bool* outResult) { export u8 CreatureLib_Script_PreventSelfSwitch(BattleScript* p, const SwitchTurnChoice* choice, bool* outResult) {
Try(p->PreventSelfSwitch(choice, outResult)); Try(p->PreventSelfSwitch(choice, outResult));
} }
export uint8_t CreatureLib_Script_ModifyEffectChance(BattleScript* p, const ExecutingAttack* attack, Creature* target, export u8 CreatureLib_Script_ModifyEffectChance(BattleScript* p, const ExecutingAttack* attack, Creature* target,
float* chance) { float* chance) {
Try(p->ModifyEffectChance(attack, target, chance)); Try(p->ModifyEffectChance(attack, target, chance));
} }
export uint8_t CreatureLib_Script_ModifyIncomingEffectChance(BattleScript* p, const ExecutingAttack* attack, export u8 CreatureLib_Script_ModifyIncomingEffectChance(BattleScript* p, const ExecutingAttack* attack,
Creature* target, float* chance) { Creature* target, float* chance) {
Try(p->ModifyIncomingEffectChance(attack, target, chance)); Try(p->ModifyIncomingEffectChance(attack, target, chance));
} }

26
CInterface/Battling/BattleSide.cpp
View File

@ -2,7 +2,7 @@
#include "../Core.hpp" #include "../Core.hpp"
using namespace CreatureLib::Battling; using namespace CreatureLib::Battling;
export BattleSide* CreatureLib_BattleSide_Construct(uint8_t index, Battle* battle, uint8_t creaturesPerSide) { export BattleSide* CreatureLib_BattleSide_Construct(u8 index, Battle* battle, u8 creaturesPerSide) {
return new BattleSide(index, battle, creaturesPerSide); return new BattleSide(index, battle, creaturesPerSide);
} }
@ -11,30 +11,28 @@ export void CreatureLib_BattleSide_Destruct(BattleSide* p) { delete p; }
export Battle* CreatureLib_BattleSide_GetBattle(BattleSide* p) { return p->GetBattle(); } export Battle* CreatureLib_BattleSide_GetBattle(BattleSide* p) { return p->GetBattle(); }
export bool CreatureLib_BattleSide_AllChoicesSet(BattleSide* p) { return p->AllChoicesSet(); } export bool CreatureLib_BattleSide_AllChoicesSet(BattleSide* p) { return p->AllChoicesSet(); }
export uint8_t CreatureLib_BattleSide_AllPossibleSlotsFilled(bool& out, BattleSide* p) { export u8 CreatureLib_BattleSide_AllPossibleSlotsFilled(bool& out, BattleSide* p) {
Try(out = p->AllPossibleSlotsFilled()); Try(out = p->AllPossibleSlotsFilled());
} }
export uint8_t CreatureLib_BattleSide_SetChoice(BattleSide* p, BaseTurnChoice* choice) { Try(p->SetChoice(choice);) } export u8 CreatureLib_BattleSide_SetChoice(BattleSide* p, BaseTurnChoice* choice) { Try(p->SetChoice(choice);) }
export void CreatureLib_BattleSide_ResetChoices(BattleSide* p) { p->ResetChoices(); } export void CreatureLib_BattleSide_ResetChoices(BattleSide* p) { p->ResetChoices(); }
export uint8_t CreatureLib_BattleSide_SetCreature(BattleSide* p, Creature* creature, uint8_t index) { export u8 CreatureLib_BattleSide_SetCreature(BattleSide* p, Creature* creature, u8 index) {
Try(p->SetCreature(creature, index)); Try(p->SetCreature(creature, index));
} }
export uint8_t CreatureLib_BattleSide_GetCreature(Creature*& out, BattleSide* p, uint8_t index) { export u8 CreatureLib_BattleSide_GetCreature(Creature*& out, BattleSide* p, u8 index) {
Try(out = p->GetCreature(index).GetValue()); Try(out = p->GetCreature(index).GetValue());
} }
export uint8_t CreatureLib_BattleSide_GetSideIndex(BattleSide* p) { return p->GetSideIndex(); } export u8 CreatureLib_BattleSide_GetSideIndex(BattleSide* p) { return p->GetSideIndex(); }
export uint8_t CreatureLib_BattleSide_GetCreatureIndex(uint8_t& out, BattleSide* p, Creature* c) { export u8 CreatureLib_BattleSide_GetCreatureIndex(u8& out, BattleSide* p, Creature* c) {
Try(out = p->GetCreatureIndex(c)); Try(out = p->GetCreatureIndex(c));
} }
export uint8_t CreatureLib_BattleSide_MarkSlotAsUnfillable(BattleSide* p, Creature* c) { export u8 CreatureLib_BattleSide_MarkSlotAsUnfillable(BattleSide* p, Creature* c) { Try(p->MarkSlotAsUnfillable(c)); }
Try(p->MarkSlotAsUnfillable(c));
}
export bool CreatureLib_BattleSide_IsDefeated(BattleSide* p) { return p->IsDefeated(); } export bool CreatureLib_BattleSide_IsDefeated(BattleSide* p) { return p->IsDefeated(); }
export bool CreatureLib_BattleSide_HasFled(BattleSide* p) { return p->HasFled(); } export bool CreatureLib_BattleSide_HasFled(BattleSide* p) { return p->HasFled(); }
@ -51,17 +49,17 @@ export BattleScript* CreatureLib_BattleSide_GetVolatileScript(BattleSide* p, con
} }
return v.GetValue(); return v.GetValue();
} }
export uint8_t CreatureLib_BattleSide_AddVolatileScriptByName(BattleSide* p, const char* key) { export u8 CreatureLib_BattleSide_AddVolatileScriptByName(BattleSide* p, const char* key) {
Try(p->AddVolatileScript(ArbUt::StringView(key));) Try(p->AddVolatileScript(ArbUt::StringView(key));)
} }
export uint8_t CreatureLib_BattleSide_AddVolatileScript(BattleSide* p, BattleScript* script) { export u8 CreatureLib_BattleSide_AddVolatileScript(BattleSide* p, BattleScript* script) {
Try(p->AddVolatileScript(script);) Try(p->AddVolatileScript(script);)
} }
export uint8_t CreatureLib_BattleSide_RemoveVolatileScript(BattleSide* p, const char* key) { export u8 CreatureLib_BattleSide_RemoveVolatileScript(BattleSide* p, const char* key) {
Try(p->RemoveVolatileScript(ArbUt::StringView::CalculateHash(key));) Try(p->RemoveVolatileScript(ArbUt::StringView::CalculateHash(key));)
} }
export uint8_t CreatureLib_BattleSide_RemoveVolatileScriptWithScript(BattleSide* p, BattleScript* script) { export u8 CreatureLib_BattleSide_RemoveVolatileScriptWithScript(BattleSide* p, BattleScript* script) {
Try(p->RemoveVolatileScript(script);) Try(p->RemoveVolatileScript(script);)
} }
export bool CreatureLib_BattleSide_HasVolatileScript(BattleSide* p, const char* key) { export bool CreatureLib_BattleSide_HasVolatileScript(BattleSide* p, const char* key) {

90
CInterface/Battling/Creature.cpp
View File

@ -2,13 +2,13 @@
#include "../Core.hpp" #include "../Core.hpp"
using namespace CreatureLib::Battling; using namespace CreatureLib::Battling;
export uint8_t CreatureLib_Creature_Construct(Creature*& out, const BattleLibrary* library, export u8 CreatureLib_Creature_Construct(Creature*& out, const BattleLibrary* library,
const CreatureLib::Library::CreatureSpecies* species, const CreatureLib::Library::CreatureSpecies* species,
const CreatureLib::Library::SpeciesVariant* variant, level_int_t level, const CreatureLib::Library::SpeciesVariant* variant, level_int_t level,
uint32_t experience, uint32_t uid, CreatureLib::Library::Gender gender, u32 experience, u32 uid, CreatureLib::Library::Gender gender, u8 coloring,
uint8_t coloring, const CreatureLib::Library::Item* heldItem, const CreatureLib::Library::Item* heldItem, const char* nickname,
const char* nickname, bool secretTalent, uint8_t talent, bool secretTalent, u8 talent, LearnedAttack* attacks[], size_t attacksNum,
LearnedAttack* attacks[], size_t attacksNum, bool allowedExperienceGain) { bool allowedExperienceGain) {
Try(auto attacksVec = std::vector<LearnedAttack*>(attacks, attacks + (attacksNum * sizeof(LearnedAttack*))); Try(auto attacksVec = std::vector<LearnedAttack*>(attacks, attacks + (attacksNum * sizeof(LearnedAttack*)));
out = out =
new Creature(library, ArbUt::BorrowedPtr<const CreatureLib::Library::CreatureSpecies>(species), variant, new Creature(library, ArbUt::BorrowedPtr<const CreatureLib::Library::CreatureSpecies>(species), variant,
@ -19,39 +19,39 @@ export uint8_t CreatureLib_Creature_Construct(Creature*& out, const BattleLibrar
export void CreatureLib_Creature_Destruct(const Creature* p) { delete p; } export void CreatureLib_Creature_Destruct(const Creature* p) { delete p; }
export uint8_t CreatureLib_Creature_Initialize(Creature* p) { Try(p->Initialize();) } export u8 CreatureLib_Creature_Initialize(Creature* p) { Try(p->Initialize();) }
BORROWED_GET_FUNC(Creature, GetLibrary, const CreatureLib::Battling::BattleLibrary*); BORROWED_GET_FUNC(Creature, GetLibrary, const CreatureLib::Battling::BattleLibrary*);
BORROWED_GET_FUNC(Creature, GetSpecies, const CreatureLib::Library::CreatureSpecies*); BORROWED_GET_FUNC(Creature, GetSpecies, const CreatureLib::Library::CreatureSpecies*);
BORROWED_GET_FUNC(Creature, GetVariant, const CreatureLib::Library::SpeciesVariant*); BORROWED_GET_FUNC(Creature, GetVariant, const CreatureLib::Library::SpeciesVariant*);
export uint8_t CreatureLib_Creature_ChangeSpecies(Creature* p, const CreatureLib::Library::CreatureSpecies* species, export u8 CreatureLib_Creature_ChangeSpecies(Creature* p, const CreatureLib::Library::CreatureSpecies* species,
const CreatureLib::Library::SpeciesVariant* variant) { const CreatureLib::Library::SpeciesVariant* variant) {
Try(p->ChangeSpecies(species, variant);) Try(p->ChangeSpecies(species, variant);)
} }
export uint8_t CreatureLib_Creature_ChangeVariant(Creature* p, const CreatureLib::Library::SpeciesVariant* variant) { export u8 CreatureLib_Creature_ChangeVariant(Creature* p, const CreatureLib::Library::SpeciesVariant* variant) {
Try(p->ChangeVariant(variant);) Try(p->ChangeVariant(variant);)
} }
SIMPLE_GET_FUNC(Creature, GetLevel, level_int_t); SIMPLE_GET_FUNC(Creature, GetLevel, level_int_t);
SIMPLE_GET_FUNC(Creature, GetExperience, uint32_t); SIMPLE_GET_FUNC(Creature, GetExperience, u32);
SIMPLE_GET_FUNC(Creature, GetUniqueIdentifier, uint32_t); SIMPLE_GET_FUNC(Creature, GetUniqueIdentifier, u32);
SIMPLE_GET_FUNC(Creature, GetGender, CreatureLib::Library::Gender); SIMPLE_GET_FUNC(Creature, GetGender, CreatureLib::Library::Gender);
SIMPLE_GET_FUNC(Creature, GetColoring, uint8_t); SIMPLE_GET_FUNC(Creature, GetColoring, u8);
export bool CreatureLib_Creature_HasHeldItem(const Creature* p, const char* name) { export bool CreatureLib_Creature_HasHeldItem(const Creature* p, const char* name) {
return p->HasHeldItem(ArbUt::StringView(name)); return p->HasHeldItem(ArbUt::StringView(name));
} }
export bool CreatureLib_Creature_HasHeldItemWithHash(const Creature* p, uint32_t hash) { return p->HasHeldItem(hash); } export bool CreatureLib_Creature_HasHeldItemWithHash(const Creature* p, u32 hash) { return p->HasHeldItem(hash); }
OPTIONAL_GET_FUNC(Creature, GetHeldItem, const CreatureLib::Library::Item*); OPTIONAL_GET_FUNC(Creature, GetHeldItem, const CreatureLib::Library::Item*);
export uint8_t CreatureLib_Creature_SetHeldItem(Creature* p, const char* name) { export u8 CreatureLib_Creature_SetHeldItem(Creature* p, const char* name) {
Try(p->SetHeldItem(ArbUt::StringView(name));) Try(p->SetHeldItem(ArbUt::StringView(name));)
} }
export uint8_t CreatureLib_Creature_SetHeldItemWithHash(Creature* p, uint32_t hash) { Try(p->SetHeldItem(hash);) } export u8 CreatureLib_Creature_SetHeldItemWithHash(Creature* p, u32 hash) { Try(p->SetHeldItem(hash);) }
export void CreatureLib_Creature_SetHeldItemFromItem(Creature* p, const CreatureLib::Library::Item* item) { export void CreatureLib_Creature_SetHeldItemFromItem(Creature* p, const CreatureLib::Library::Item* item) {
return p->SetHeldItem(ArbUt::BorrowedPtr<const CreatureLib::Library::Item>(item)); return p->SetHeldItem(ArbUt::BorrowedPtr<const CreatureLib::Library::Item>(item));
} }
SIMPLE_GET_FUNC(Creature, GetCurrentHealth, uint32_t); SIMPLE_GET_FUNC(Creature, GetCurrentHealth, u32);
OPTIONAL_GET_FUNC(Creature, GetBattle, Battle*); OPTIONAL_GET_FUNC(Creature, GetBattle, Battle*);
OPTIONAL_GET_FUNC(Creature, GetBattleSide, BattleSide*); OPTIONAL_GET_FUNC(Creature, GetBattleSide, BattleSide*);
SIMPLE_GET_FUNC(Creature, IsOnBattleField, bool); SIMPLE_GET_FUNC(Creature, IsOnBattleField, bool);
@ -63,42 +63,36 @@ export const char* CreatureLib_Creature_GetNickname(Creature* p) {
return ""; return "";
} }
export void CreatureLib_Creature_SetNickname(Creature* p, const char* nickname) { p->SetNickname(nickname); } export void CreatureLib_Creature_SetNickname(Creature* p, const char* nickname) { p->SetNickname(nickname); }
export bool CreatureLib_Creature_HasType(Creature* p, uint8_t type) { return p->HasType(type); } export bool CreatureLib_Creature_HasType(Creature* p, u8 type) { return p->HasType(type); }
export size_t CreatureLib_Creature_GetTypeCount(Creature* p) { return p->GetTypes().size(); } export size_t CreatureLib_Creature_GetTypeCount(Creature* p) { return p->GetTypes().size(); }
export const uint8_t* CreatureLib_Creature_GetTypes(Creature* p) { return p->GetTypes().data(); } export const u8* CreatureLib_Creature_GetTypes(Creature* p) { return p->GetTypes().data(); }
SIMPLE_GET_FUNC(Creature, GetMaxHealth, uint32_t); SIMPLE_GET_FUNC(Creature, GetMaxHealth, u32);
export uint8_t CreatureLib_Creature_ChangeLevelBy(Creature* p, int8_t level) { Try(p->ChangeLevelBy(level);) } export u8 CreatureLib_Creature_ChangeLevelBy(Creature* p, i8 level) { Try(p->ChangeLevelBy(level);) }
export uint8_t CreatureLib_Creature_Damage(Creature* p, uint32_t damage, DamageSource source) { export u8 CreatureLib_Creature_Damage(Creature* p, u32 damage, DamageSource source) { Try(p->Damage(damage, source);) }
Try(p->Damage(damage, source);) export u8 CreatureLib_Creature_Heal(Creature* p, u32 health, bool canRevive) { Try(p->Heal(health, canRevive);) }
} export u8 CreatureLib_Creature_RestoreAllAttackUses(Creature* p) { Try(p->RestoreAllAttackUses();) }
export uint8_t CreatureLib_Creature_Heal(Creature* p, uint32_t health, bool canRevive) {
Try(p->Heal(health, canRevive);)
}
export uint8_t CreatureLib_Creature_RestoreAllAttackUses(Creature* p) { Try(p->RestoreAllAttackUses();) }
export bool CreatureLib_Creature_GetRealTalentIsSecret(const Creature* p) { return p->GetRealTalent().IsSecret(); } export bool CreatureLib_Creature_GetRealTalentIsSecret(const Creature* p) { return p->GetRealTalent().IsSecret(); }
export bool CreatureLib_Creature_GetRealTalentIndex(const Creature* p) { return p->GetRealTalent().GetIndex(); } export bool CreatureLib_Creature_GetRealTalentIndex(const Creature* p) { return p->GetRealTalent().GetIndex(); }
export uint8_t CreatureLib_Creature_GetActiveTalent(const Creature* p, const CreatureLib::Library::Talent*& out) { export u8 CreatureLib_Creature_GetActiveTalent(const Creature* p, const CreatureLib::Library::Talent*& out) {
Try(out = p->GetActiveTalent().GetRaw();) Try(out = p->GetActiveTalent().GetRaw();)
} }
export uint8_t CreatureLib_Creature_OverrideActiveTalent(Creature* p, const char* talent) { export u8 CreatureLib_Creature_OverrideActiveTalent(Creature* p, const char* talent) {
Try(p->OverrideActiveTalent(ArbUt::StringView(talent));) Try(p->OverrideActiveTalent(ArbUt::StringView(talent));)
} }
export uint8_t CreatureLib_Creature_AddExperience(Creature* p, uint32_t experience) { export u8 CreatureLib_Creature_AddExperience(Creature* p, u32 experience) { Try(p->AddExperience(experience);) }
Try(p->AddExperience(experience);) export u8 CreatureLib_Creature_ClearVolatileScripts(Creature* p) { Try(p->ClearVolatileScripts();) }
} export u8 CreatureLib_Creature_AddVolatileScriptByName(Creature* p, const char* scriptName) {
export uint8_t CreatureLib_Creature_ClearVolatileScripts(Creature* p) { Try(p->ClearVolatileScripts();) }
export uint8_t CreatureLib_Creature_AddVolatileScriptByName(Creature* p, const char* scriptName) {
Try(p->AddVolatileScript(ArbUt::StringView(scriptName));) Try(p->AddVolatileScript(ArbUt::StringView(scriptName));)
} }
export uint8_t CreatureLib_Creature_AddVolatileScript(Creature* p, BattleScript* script) { export u8 CreatureLib_Creature_AddVolatileScript(Creature* p, BattleScript* script) {
Try(p->AddVolatileScript(script);) Try(p->AddVolatileScript(script);)
} }
export uint8_t CreatureLib_Creature_RemoveVolatileScriptByName(Creature* p, const char* scriptName) { export u8 CreatureLib_Creature_RemoveVolatileScriptByName(Creature* p, const char* scriptName) {
Try(p->RemoveVolatileScript(ArbUt::StringView(scriptName));) Try(p->RemoveVolatileScript(ArbUt::StringView(scriptName));)
} }
export uint8_t CreatureLib_Creature_RemoveVolatileScript(Creature* p, BattleScript* script) { export u8 CreatureLib_Creature_RemoveVolatileScript(Creature* p, BattleScript* script) {
Try(p->RemoveVolatileScript(script);) Try(p->RemoveVolatileScript(script);)
} }
export bool CreatureLib_Creature_HasVolatileScript(Creature* p, const char* scriptName) { export bool CreatureLib_Creature_HasVolatileScript(Creature* p, const char* scriptName) {
@ -120,28 +114,28 @@ export void CreatureLib_Creature_SetDisplayVariant(Creature* p, const CreatureLi
export bool CreatureLib_Creature_AllowedExperienceGain(Creature* p) { return p->AllowedExperienceGain(); } export bool CreatureLib_Creature_AllowedExperienceGain(Creature* p) { return p->AllowedExperienceGain(); }
export void CreatureLib_Creature_SetAllowedExperienceGain(Creature* p, bool b) { p->SetAllowedExperienceGain(b); } export void CreatureLib_Creature_SetAllowedExperienceGain(Creature* p, bool b) { p->SetAllowedExperienceGain(b); }
export void CreatureLib_Creature_ChangeStatBoost(Creature* p, CreatureLib::Library::Statistic stat, int8_t diffAmount) { export void CreatureLib_Creature_ChangeStatBoost(Creature* p, CreatureLib::Library::Statistic stat, i8 diffAmount) {
p->ChangeStatBoost(stat, diffAmount); p->ChangeStatBoost(stat, diffAmount);
} }
export uint32_t CreatureLib_Creature_GetFlatStat(Creature* p, CreatureLib::Library::Statistic stat) { export u32 CreatureLib_Creature_GetFlatStat(Creature* p, CreatureLib::Library::Statistic stat) {
return p->GetFlatStat(stat); return p->GetFlatStat(stat);
} }
export uint32_t CreatureLib_Creature_GetBoostedStat(Creature* p, CreatureLib::Library::Statistic stat) { export u32 CreatureLib_Creature_GetBoostedStat(Creature* p, CreatureLib::Library::Statistic stat) {
return p->GetBoostedStat(stat); return p->GetBoostedStat(stat);
} }
export uint32_t CreatureLib_Creature_GetBaseStat(Creature* p, CreatureLib::Library::Statistic stat) { export u32 CreatureLib_Creature_GetBaseStat(Creature* p, CreatureLib::Library::Statistic stat) {
return p->GetBaseStat(stat); return p->GetBaseStat(stat);
} }
export int8_t CreatureLib_Creature_GetStatBoost(Creature* p, CreatureLib::Library::Statistic stat) { export i8 CreatureLib_Creature_GetStatBoost(Creature* p, CreatureLib::Library::Statistic stat) {
return p->GetStatBoost(stat); return p->GetStatBoost(stat);
} }
SIMPLE_GET_FUNC(Creature, GetAvailableAttackSlot, uint8_t); SIMPLE_GET_FUNC(Creature, GetAvailableAttackSlot, u8);
export uint8_t CreatureLib_Creature_AddAttack(Creature* p, LearnedAttack* attack) { Try(p->AddAttack(attack);) } export u8 CreatureLib_Creature_AddAttack(Creature* p, LearnedAttack* attack) { Try(p->AddAttack(attack);) }
export uint8_t CreatureLib_Creature_ReplaceAttack(Creature* p, size_t index, LearnedAttack* attack) { export u8 CreatureLib_Creature_ReplaceAttack(Creature* p, size_t index, LearnedAttack* attack) {
Try(p->ReplaceAttack(index, attack);) Try(p->ReplaceAttack(index, attack);)
} }
export uint8_t CreatureLib_Creature_SwapAttack(Creature* p, size_t a, size_t b) { Try(p->SwapAttacks(a, b);) } export u8 CreatureLib_Creature_SwapAttack(Creature* p, size_t a, size_t b) { Try(p->SwapAttacks(a, b);) }
export u8 CreatureLib_Creature_SetStatus(Creature* p, const char* name) { Try(p->SetStatus(ArbUt::StringView(name))); }; export u8 CreatureLib_Creature_SetStatus(Creature* p, const char* name) { Try(p->SetStatus(ArbUt::StringView(name))); };
export u8 CreatureLib_Creature_ClearStatus(Creature* p) { Try(p->ClearStatus()); }; export u8 CreatureLib_Creature_ClearStatus(Creature* p) { Try(p->ClearStatus()); };

8
CInterface/Battling/CreatureParty.cpp
View File

@ -9,14 +9,14 @@ export CreatureParty* CreatureLib_CreatureParty_ConstructFromArray(Creature* cre
export void CreatureLib_CreatureParty_Destruct(const CreatureParty* p) { delete p; } export void CreatureLib_CreatureParty_Destruct(const CreatureParty* p) { delete p; }
export uint8_t CreatureLib_CreatureParty_GetAtIndex(Creature*& out, const CreatureParty* p, size_t index) { export u8 CreatureLib_CreatureParty_GetAtIndex(Creature*& out, const CreatureParty* p, size_t index) {
Try(out = p->GetAtIndex(index).GetValue();) Try(out = p->GetAtIndex(index).GetValue();)
} }
export uint8_t CreatureLib_CreatureParty_Switch(CreatureParty* p, size_t a, size_t b) { Try(p->Switch(a, b);) } export u8 CreatureLib_CreatureParty_Switch(CreatureParty* p, size_t a, size_t b) { Try(p->Switch(a, b);) }
export uint8_t CreatureLib_CreatureParty_PackParty(CreatureParty* p) { Try(p->PackParty();) } export u8 CreatureLib_CreatureParty_PackParty(CreatureParty* p) { Try(p->PackParty();) }
export uint8_t CreatureLib_CreatureParty_SwapInto(Creature*& out, CreatureParty* p, size_t index, Creature* creature) { export u8 CreatureLib_CreatureParty_SwapInto(Creature*& out, CreatureParty* p, size_t index, Creature* creature) {
Try(out = p->SwapInto(index, creature);) Try(out = p->SwapInto(index, creature);)
} }

21
CInterface/Battling/DamageLibrary.cpp
View File

@ -6,24 +6,21 @@ export const DamageLibrary* CreatureLib_DamageLibrary_Construct() { return new D
export void CreatureLib_DamageLibrary_Destruct(const DamageLibrary* p) { delete p; } export void CreatureLib_DamageLibrary_Destruct(const DamageLibrary* p) { delete p; }
export uint8_t CreatureLib_DamageLibrary_GetDamage(uint32_t& out, const DamageLibrary* p, ExecutingAttack* attack, export u8 CreatureLib_DamageLibrary_GetDamage(u32& out, const DamageLibrary* p, ExecutingAttack* attack,
Creature* target, uint8_t hitIndex, Creature* target, u8 hitIndex, ExecutingAttack::HitData* hitData) {
ExecutingAttack::HitData* hitData) {
Try(out = p->GetDamage(attack, target, hitIndex, *hitData);) Try(out = p->GetDamage(attack, target, hitIndex, *hitData);)
} }
export uint8_t CreatureLib_DamageLibrary_GetBasePower(uint8_t& out, const DamageLibrary* p, ExecutingAttack* attack, export u8 CreatureLib_DamageLibrary_GetBasePower(u8& out, const DamageLibrary* p, ExecutingAttack* attack,
Creature* target, uint8_t hitIndex, Creature* target, u8 hitIndex, ExecutingAttack::HitData* hitData) {
ExecutingAttack::HitData* hitData) {
Try(out = p->GetBasePower(attack, target, hitIndex, *hitData);) Try(out = p->GetBasePower(attack, target, hitIndex, *hitData);)
} }
export uint8_t CreatureLib_DamageLibrary_GetStatModifier(float& out, const DamageLibrary* p, ExecutingAttack* attack, export u8 CreatureLib_DamageLibrary_GetStatModifier(float& out, const DamageLibrary* p, ExecutingAttack* attack,
Creature* target, uint8_t hitIndex, Creature* target, u8 hitIndex, ExecutingAttack::HitData* hitData) {
ExecutingAttack::HitData* hitData) {
Try(out = p->GetStatModifier(attack, target, hitIndex, *hitData);) Try(out = p->GetStatModifier(attack, target, hitIndex, *hitData);)
} }
export uint8_t CreatureLib_DamageLibrary_GetDamageModifier(float& out, const DamageLibrary* p, ExecutingAttack* attack, export u8 CreatureLib_DamageLibrary_GetDamageModifier(float& out, const DamageLibrary* p, ExecutingAttack* attack,
Creature* target, uint8_t hitIndex, Creature* target, u8 hitIndex,
ExecutingAttack::HitData* hitData) { ExecutingAttack::HitData* hitData) {
Try(out = p->GetDamageModifier(attack, target, hitIndex, *hitData);) Try(out = p->GetDamageModifier(attack, target, hitIndex, *hitData);)
} }

20
CInterface/Battling/EventData.cpp
View File

@ -8,21 +8,21 @@ SIMPLE_GET_FUNC(EventData, GetKind, EventDataKind);
BORROWED_GET_FUNC(DamageEvent, GetCreature, Creature*); BORROWED_GET_FUNC(DamageEvent, GetCreature, Creature*);
SIMPLE_GET_FUNC(DamageEvent, GetDamageSource, DamageSource); SIMPLE_GET_FUNC(DamageEvent, GetDamageSource, DamageSource);
SIMPLE_GET_FUNC(DamageEvent, GetOriginalHealth, uint32_t); SIMPLE_GET_FUNC(DamageEvent, GetOriginalHealth, u32);
SIMPLE_GET_FUNC(DamageEvent, GetNewHealth, uint32_t); SIMPLE_GET_FUNC(DamageEvent, GetNewHealth, u32);
DESTRUCTOR(DamageEvent); DESTRUCTOR(DamageEvent);
BORROWED_GET_FUNC(HealEvent, GetCreature, Creature*); BORROWED_GET_FUNC(HealEvent, GetCreature, Creature*);
SIMPLE_GET_FUNC(HealEvent, GetOriginalHealth, uint32_t); SIMPLE_GET_FUNC(HealEvent, GetOriginalHealth, u32);
SIMPLE_GET_FUNC(HealEvent, GetNewHealth, uint32_t); SIMPLE_GET_FUNC(HealEvent, GetNewHealth, u32);
DESTRUCTOR(HealEvent); DESTRUCTOR(HealEvent);
BORROWED_GET_FUNC(FaintEvent, GetCreature, Creature*); BORROWED_GET_FUNC(FaintEvent, GetCreature, Creature*);
DESTRUCTOR(FaintEvent); DESTRUCTOR(FaintEvent);
BORROWED_GET_FUNC(SwitchEvent, GetNewCreature, Creature*); BORROWED_GET_FUNC(SwitchEvent, GetNewCreature, Creature*);
export uint8_t CreatureLib_SwitchEvent_GetSide(const SwitchEvent* p) { return p->GetIndex().GetSideIndex(); } export u8 CreatureLib_SwitchEvent_GetSide(const SwitchEvent* p) { return p->GetIndex().GetSideIndex(); }
export uint8_t CreatureLib_SwitchEvent_GetIndex(const SwitchEvent* p) { return p->GetIndex().GetCreatureIndex(); } export u8 CreatureLib_SwitchEvent_GetIndex(const SwitchEvent* p) { return p->GetIndex().GetCreatureIndex(); }
DESTRUCTOR(SwitchEvent); DESTRUCTOR(SwitchEvent);
DESTRUCTOR(TurnStartEvent); DESTRUCTOR(TurnStartEvent);
@ -30,8 +30,8 @@ DESTRUCTOR(TurnStartEvent);
DESTRUCTOR(TurnEndEvent); DESTRUCTOR(TurnEndEvent);
BORROWED_GET_FUNC(ExperienceGainEvent, GetCreature, const Creature*); BORROWED_GET_FUNC(ExperienceGainEvent, GetCreature, const Creature*);
SIMPLE_GET_FUNC(ExperienceGainEvent, GetPreviousExperience, uint32_t); SIMPLE_GET_FUNC(ExperienceGainEvent, GetPreviousExperience, u32);
SIMPLE_GET_FUNC(ExperienceGainEvent, GetNewExperience, uint32_t); SIMPLE_GET_FUNC(ExperienceGainEvent, GetNewExperience, u32);
DESTRUCTOR(ExperienceGainEvent); DESTRUCTOR(ExperienceGainEvent);
BORROWED_GET_FUNC(MissEvent, GetCreature, const Creature*); BORROWED_GET_FUNC(MissEvent, GetCreature, const Creature*);
@ -53,7 +53,7 @@ export void CreatureLib_DisplayTextEvent_Destruct(const DisplayTextEvent* p) { d
BORROWED_GET_FUNC(ChangeStatBoostEvent, GetCreature, const Creature*); BORROWED_GET_FUNC(ChangeStatBoostEvent, GetCreature, const Creature*);
SIMPLE_GET_FUNC(ChangeStatBoostEvent, GetStatistic, CreatureLib::Library::Statistic); SIMPLE_GET_FUNC(ChangeStatBoostEvent, GetStatistic, CreatureLib::Library::Statistic);
SIMPLE_GET_FUNC(ChangeStatBoostEvent, GetOldValue, int8_t); SIMPLE_GET_FUNC(ChangeStatBoostEvent, GetOldValue, i8);
SIMPLE_GET_FUNC(ChangeStatBoostEvent, GetNewValue, int8_t); SIMPLE_GET_FUNC(ChangeStatBoostEvent, GetNewValue, i8);
DESTRUCTOR(ChangeStatBoostEvent); DESTRUCTOR(ChangeStatBoostEvent);

28
CInterface/Battling/ExecutingAttack.cpp
View File

@ -2,11 +2,9 @@
#include "../Core.hpp" #include "../Core.hpp"
using namespace CreatureLib::Battling; using namespace CreatureLib::Battling;
export uint8_t CreatureLib_ExecutingAttack_Construct(ExecutingAttack*& out, Creature* const* targets, export u8 CreatureLib_ExecutingAttack_Construct(ExecutingAttack*& out, Creature* const* targets, size_t targetCount,
size_t targetCount, uint8_t numberHits, Creature* user, u8 numberHits, Creature* user, LearnedAttack* attack,
LearnedAttack* attack, CreatureLib::Library::AttackData* attackData, BattleScript* script) {
CreatureLib::Library::AttackData* attackData,
BattleScript* script) {
Try(auto ls = ArbUt::List<ArbUt::OptionalBorrowedPtr<Creature>>(targetCount); Try(auto ls = ArbUt::List<ArbUt::OptionalBorrowedPtr<Creature>>(targetCount);
for (size_t i = 0; i < targetCount; i++) { ls.Append(targets[i]); } auto s = for (size_t i = 0; i < targetCount; i++) { ls.Append(targets[i]); } auto s =
std::unique_ptr<BattleScript>(script); std::unique_ptr<BattleScript>(script);
@ -15,16 +13,16 @@ export uint8_t CreatureLib_ExecutingAttack_Construct(ExecutingAttack*& out, Crea
export void CreatureLib_ExecutingAttack_Destruct(ExecutingAttack* p) { delete p; } export void CreatureLib_ExecutingAttack_Destruct(ExecutingAttack* p) { delete p; }
SIMPLE_GET_FUNC(ExecutingAttack, GetNumberOfHits, uint8_t); SIMPLE_GET_FUNC(ExecutingAttack, GetNumberOfHits, u8);
export uint8_t CreatureLib_ExecutingAttack_GetHitData(ExecutingAttack::HitData*& out, ExecutingAttack* p, export u8 CreatureLib_ExecutingAttack_GetHitData(ExecutingAttack::HitData*& out, ExecutingAttack* p, Creature* target,
Creature* target, uint8_t hit) { u8 hit) {
Try(out = &p->GetHitData(target, hit);) Try(out = &p->GetHitData(target, hit);)
} }
export bool CreatureLib_ExecutingAttack_IsCreatureTarget(ExecutingAttack* p, Creature* target) { export bool CreatureLib_ExecutingAttack_IsCreatureTarget(ExecutingAttack* p, Creature* target) {
return p->IsCreatureTarget(target); return p->IsCreatureTarget(target);
} }
export uint8_t CreatureLib_ExecutingAttack_GetTargetCount(ExecutingAttack* p) { return p->GetTargetCount(); } export u8 CreatureLib_ExecutingAttack_GetTargetCount(ExecutingAttack* p) { return p->GetTargetCount(); }
export const Creature* const* CreatureLib_ExecutingAttack_GetTargets(ExecutingAttack* p) { export const Creature* const* CreatureLib_ExecutingAttack_GetTargets(ExecutingAttack* p) {
return reinterpret_cast<const Creature* const*>(p->GetTargets().RawData()); return reinterpret_cast<const Creature* const*>(p->GetTargets().RawData());
} }
@ -39,19 +37,19 @@ export const CreatureLib::Library::AttackData* CreatureLib_ExecutingAttack_GetUs
export returnType CreatureLib_HitData##_##name(const ExecutingAttack::HitData* p) { return p->name(); } export returnType CreatureLib_HitData##_##name(const ExecutingAttack::HitData* p) { return p->name(); }
HITDATA_GET_FUNC(IsCritical, bool); HITDATA_GET_FUNC(IsCritical, bool);
HITDATA_GET_FUNC(GetBasePower, uint8_t); HITDATA_GET_FUNC(GetBasePower, u8);
HITDATA_GET_FUNC(GetEffectiveness, float); HITDATA_GET_FUNC(GetEffectiveness, float);
HITDATA_GET_FUNC(GetDamage, uint32_t); HITDATA_GET_FUNC(GetDamage, u32);
HITDATA_GET_FUNC(GetType, uint8_t); HITDATA_GET_FUNC(GetType, u8);
#define HITDATA_SET_FUNC(name, type) \ #define HITDATA_SET_FUNC(name, type) \
export void CreatureLib_HitData##_##name(ExecutingAttack::HitData* p, type val) { p->name(val); } export void CreatureLib_HitData##_##name(ExecutingAttack::HitData* p, type val) { p->name(val); }
HITDATA_SET_FUNC(SetCritical, bool); HITDATA_SET_FUNC(SetCritical, bool);
HITDATA_SET_FUNC(SetBasePower, uint8_t); HITDATA_SET_FUNC(SetBasePower, u8);
HITDATA_SET_FUNC(SetEffectiveness, float); HITDATA_SET_FUNC(SetEffectiveness, float);
HITDATA_SET_FUNC(SetDamage, uint32_t); HITDATA_SET_FUNC(SetDamage, u32);
HITDATA_SET_FUNC(SetType, uint8_t); HITDATA_SET_FUNC(SetType, u8);
#undef HITDATA_GET_FUNC #undef HITDATA_GET_FUNC
#undef HITDATA_SET_FUNC #undef HITDATA_SET_FUNC

14
CInterface/Battling/ItemUseScript.cpp
View File

@ -3,18 +3,16 @@
using namespace CreatureLib::Battling; using namespace CreatureLib::Battling;
export void CreatureLib_ItemUseScript_Destruct(ItemUseScript* p) { delete p; } export void CreatureLib_ItemUseScript_Destruct(ItemUseScript* p) { delete p; }
export uint8_t CreatureLib_ItemUseScript_IsItemUsable(ItemUseScript* p, uint8_t& out) { Try(out = p->IsItemUsable()) } export u8 CreatureLib_ItemUseScript_IsItemUsable(ItemUseScript* p, u8& out) { Try(out = p->IsItemUsable()) }
export uint8_t CreatureLib_ItemUseScript_IsCreatureUseItem(ItemUseScript* p, uint8_t& out) { export u8 CreatureLib_ItemUseScript_IsCreatureUseItem(ItemUseScript* p, u8& out) { Try(out = p->IsCreatureUseItem()) }
Try(out = p->IsCreatureUseItem())
}
export uint8_t CreatureLib_ItemUseScript_IsUseValidForCreature(ItemUseScript* p, Creature* creature, uint8_t& out) { export u8 CreatureLib_ItemUseScript_IsUseValidForCreature(ItemUseScript* p, Creature* creature, u8& out) {
Try(out = p->IsUseValidForCreature(creature)) Try(out = p->IsUseValidForCreature(creature))
} }
export uint8_t CreatureLib_ItemUseScript_IsHoldable(ItemUseScript* p, uint8_t& out) { Try(out = p->IsHoldable()) } export u8 CreatureLib_ItemUseScript_IsHoldable(ItemUseScript* p, u8& out) { Try(out = p->IsHoldable()) }
export uint8_t CreatureLib_ItemUseScript_OnUse(ItemUseScript* p, Battle* battle) { Try(p->OnUse(battle)) } export u8 CreatureLib_ItemUseScript_OnUse(ItemUseScript* p, Battle* battle) { Try(p->OnUse(battle)) }
export uint8_t CreatureLib_ItemUseScript_OnCreatureUse(ItemUseScript* p, Creature* creature, bool isBattle) { export u8 CreatureLib_ItemUseScript_OnCreatureUse(ItemUseScript* p, Creature* creature, bool isBattle) {
Try(p->OnCreatureUse(creature, isBattle)) Try(p->OnCreatureUse(creature, isBattle))
} }

14
CInterface/Battling/LearnedAttack.cpp
View File

@ -2,19 +2,19 @@
#include "../Core.hpp" #include "../Core.hpp"
using namespace CreatureLib::Battling; using namespace CreatureLib::Battling;
export uint8_t CreatureLib_LearnedAttack_Construct(LearnedAttack*& out, const CreatureLib::Library::AttackData* attack, export u8 CreatureLib_LearnedAttack_Construct(LearnedAttack*& out, const CreatureLib::Library::AttackData* attack,
uint8_t maxUses, AttackLearnMethod learnMethod) { u8 maxUses, AttackLearnMethod learnMethod) {
Try(out = new LearnedAttack(ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData>(attack), maxUses, Try(out = new LearnedAttack(ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData>(attack), maxUses,
learnMethod);) learnMethod);)
} }
export void CreatureLib_LearnedAttack_Destruct(LearnedAttack* p) { delete p; } export void CreatureLib_LearnedAttack_Destruct(LearnedAttack* p) { delete p; }
BORROWED_GET_FUNC(LearnedAttack, GetAttack, const CreatureLib::Library::AttackData*); BORROWED_GET_FUNC(LearnedAttack, GetAttack, const CreatureLib::Library::AttackData*);
SIMPLE_GET_FUNC(LearnedAttack, GetMaxUses, uint8_t); SIMPLE_GET_FUNC(LearnedAttack, GetMaxUses, u8);
SIMPLE_GET_FUNC(LearnedAttack, GetRemainingUses, uint8_t); SIMPLE_GET_FUNC(LearnedAttack, GetRemainingUses, u8);
SIMPLE_GET_FUNC(LearnedAttack, GetLearnMethod, AttackLearnMethod); SIMPLE_GET_FUNC(LearnedAttack, GetLearnMethod, AttackLearnMethod);
export bool CreatureLib_LearnedAttack_TryUse(LearnedAttack* p, uint8_t uses) { return p->TryUse(uses); } export bool CreatureLib_LearnedAttack_TryUse(LearnedAttack* p, u8 uses) { return p->TryUse(uses); }
export void CreatureLib_LearnedAttack_DecreaseUses(LearnedAttack* p, uint8_t uses) { p->DecreaseUses(uses); } export void CreatureLib_LearnedAttack_DecreaseUses(LearnedAttack* p, u8 uses) { p->DecreaseUses(uses); }
export void CreatureLib_LearnedAttack_RestoreUses(LearnedAttack* p, uint8_t uses) { p->RestoreUses(uses); } export void CreatureLib_LearnedAttack_RestoreUses(LearnedAttack* p, u8 uses) { p->RestoreUses(uses); }
export void CreatureLib_LearnedAttack_RestoreAllUses(LearnedAttack* p) { p->RestoreAllUses(); } export void CreatureLib_LearnedAttack_RestoreAllUses(LearnedAttack* p) { p->RestoreAllUses(); }

10
CInterface/Battling/MiscLibrary.cpp
View File

@ -6,14 +6,14 @@ export MiscLibrary* CreatureLib_MiscLibrary_Construct() { return new MiscLibrary
export void CreatureLib_MiscLibrary_Destruct(const MiscLibrary* p) { delete p; } export void CreatureLib_MiscLibrary_Destruct(const MiscLibrary* p) { delete p; }
export uint8_t CreatureLib_MiscLibrary_IsCritical(bool& out, MiscLibrary* p, ExecutingAttack* attack, Creature* target, export u8 CreatureLib_MiscLibrary_IsCritical(bool& out, MiscLibrary* p, ExecutingAttack* attack, Creature* target,
uint8_t hit) { u8 hit) {
Try(out = p->IsCritical(attack, target, hit);) Try(out = p->IsCritical(attack, target, hit);)
}; };
export uint8_t CreatureLib_MiscLibrary_CanFlee(bool& out, MiscLibrary* p, FleeTurnChoice* switchChoice) { export u8 CreatureLib_MiscLibrary_CanFlee(bool& out, MiscLibrary* p, FleeTurnChoice* switchChoice) {
Try(out = p->CanFlee(switchChoice);) Try(out = p->CanFlee(switchChoice);)
}; };
export uint8_t CreatureLib_MiscLibrary_ReplacementAttack(BaseTurnChoice*& out, MiscLibrary* p, Creature* user, export u8 CreatureLib_MiscLibrary_ReplacementAttack(BaseTurnChoice*& out, MiscLibrary* p, Creature* user, u8 sideTarget,
uint8_t sideTarget, uint8_t creatureTarget) { u8 creatureTarget) {
Try(out = p->ReplacementAttack(user, CreatureIndex(sideTarget, creatureTarget));) Try(out = p->ReplacementAttack(user, CreatureIndex(sideTarget, creatureTarget));)
}; };

10
CInterface/Battling/ScriptResolver.cpp
View File

@ -6,15 +6,15 @@ export ScriptResolver* CreatureLib_ScriptResolver_Construct() { return new Scrip
export void CreatureLib_ScriptResolver_Destruct(const ScriptResolver* p) { delete p; } export void CreatureLib_ScriptResolver_Destruct(const ScriptResolver* p) { delete p; }
export uint8_t CreatureLib_ScriptResolver_Initialize(ScriptResolver* p, BattleLibrary* library) { export u8 CreatureLib_ScriptResolver_Initialize(ScriptResolver* p, BattleLibrary* library) {
Try(p->Initialize(library);) Try(p->Initialize(library);)
}; };
export uint8_t CreatureLib_ScriptResolver_LoadScript(BattleScript*& out, ScriptResolver* p, void* owner, export u8 CreatureLib_ScriptResolver_LoadScript(BattleScript*& out, ScriptResolver* p, void* owner,
ScriptCategory category, const char* scriptName) { ScriptCategory category, const char* scriptName) {
Try(out = p->LoadScript(owner, category, ArbUt::StringView(scriptName));) Try(out = p->LoadScript(owner, category, ArbUt::StringView(scriptName));)
}; };
export uint8_t CreatureLib_ScriptResolver_LoadItemScript(ItemUseScript*& out, ScriptResolver* p, export u8 CreatureLib_ScriptResolver_LoadItemScript(ItemUseScript*& out, ScriptResolver* p,
const CreatureLib::Library::Item* item) { const CreatureLib::Library::Item* item) {
Try(out = p->LoadItemScript(item);) Try(out = p->LoadItemScript(item);)
}; };

12
CInterface/Battling/TurnChoices.cpp
View File

@ -5,8 +5,8 @@
#include "../Core.hpp" #include "../Core.hpp"
using namespace CreatureLib::Battling; using namespace CreatureLib::Battling;
export AttackTurnChoice* CreatureLib_AttackTurnChoice_Construct(Creature* user, LearnedAttack* attack, export AttackTurnChoice* CreatureLib_AttackTurnChoice_Construct(Creature* user, LearnedAttack* attack, u8 sideIndex,
uint8_t sideIndex, uint8_t targetIndex) { u8 targetIndex) {
return new AttackTurnChoice(user, attack, CreatureIndex(sideIndex, targetIndex)); return new AttackTurnChoice(user, attack, CreatureIndex(sideIndex, targetIndex));
} }
export void CreatureLib_AttackTurnChoice_Destruct(AttackTurnChoice* p) { delete p; } export void CreatureLib_AttackTurnChoice_Destruct(AttackTurnChoice* p) { delete p; }
@ -25,15 +25,13 @@ BORROWED_GET_FUNC(BaseTurnChoice, GetUser, Creature*)
BORROWED_GET_FUNC(AttackTurnChoice, GetAttack, LearnedAttack*) BORROWED_GET_FUNC(AttackTurnChoice, GetAttack, LearnedAttack*)
SIMPLE_GET_FUNC(AttackTurnChoice, GetKind, TurnChoiceKind) SIMPLE_GET_FUNC(AttackTurnChoice, GetKind, TurnChoiceKind)
export uint8_t CreatureLib_AttackTurnChoice_GetPriority(int8_t& out, AttackTurnChoice* p) { export u8 CreatureLib_AttackTurnChoice_GetPriority(i8& out, AttackTurnChoice* p) { Try(out = p->GetPriority()); }
Try(out = p->GetPriority());
}
SMART_GET_FUNC(AttackTurnChoice, GetAttackScript, BattleScript*) SMART_GET_FUNC(AttackTurnChoice, GetAttackScript, BattleScript*)
export uint8_t CreatureLib_AttackTurnChoice_GetTargetSideIndex(const AttackTurnChoice* p) { export u8 CreatureLib_AttackTurnChoice_GetTargetSideIndex(const AttackTurnChoice* p) {
return p->GetTarget().GetSideIndex(); return p->GetTarget().GetSideIndex();
} }
export uint8_t CreatureLib_AttackTurnChoice_GetTargetCreatureIndex(const AttackTurnChoice* p) { export u8 CreatureLib_AttackTurnChoice_GetTargetCreatureIndex(const AttackTurnChoice* p) {
return p->GetTarget().GetCreatureIndex(); return p->GetTarget().GetCreatureIndex();
} }

23
CInterface/Library/AttackData.cpp
View File

@ -2,14 +2,13 @@
#include "../Core.hpp" #include "../Core.hpp"
using namespace CreatureLib::Library; using namespace CreatureLib::Library;
export uint8_t CreatureLib_AttackData_Construct(AttackData*& out, const char* name, uint8_t type, export u8 CreatureLib_AttackData_Construct(AttackData*& out, const char* name, u8 type, AttackCategory category,
AttackCategory category, uint8_t power, uint8_t accuracy, u8 power, u8 accuracy, u8 baseUsage, AttackTarget target, i8 priority,
uint8_t baseUsage, AttackTarget target, int8_t priority, float effectChance, const char* effectName,
float effectChance, const char* effectName, EffectParameter* effectParameters[], size_t effectParameterCount,
EffectParameter* effectParameters[], size_t effectParameterCount, const char* flags[], size_t flagsCount) {
const char* flags[], size_t flagsCount) {
Try({ Try({
std::unordered_set<uint32_t> conversedFlags(flagsCount); std::unordered_set<u32> conversedFlags(flagsCount);
for (size_t i = 0; i < flagsCount; i++) { for (size_t i = 0; i < flagsCount; i++) {
conversedFlags.insert(ArbUt::StringView::CalculateHash(flags[i])); conversedFlags.insert(ArbUt::StringView::CalculateHash(flags[i]));
} }
@ -28,13 +27,13 @@ export uint8_t CreatureLib_AttackData_Construct(AttackData*& out, const char* na
export void CreatureLib_AttackData_Destruct(const AttackData* p) { delete p; } export void CreatureLib_AttackData_Destruct(const AttackData* p) { delete p; }
export const char* CreatureLib_AttackData_GetName(const AttackData* p) { return p->GetName().c_str(); } export const char* CreatureLib_AttackData_GetName(const AttackData* p) { return p->GetName().c_str(); }
SIMPLE_GET_FUNC(AttackData, GetType, uint8_t); SIMPLE_GET_FUNC(AttackData, GetType, u8);
SIMPLE_GET_FUNC(AttackData, GetCategory, AttackCategory); SIMPLE_GET_FUNC(AttackData, GetCategory, AttackCategory);
SIMPLE_GET_FUNC(AttackData, GetBasePower, uint8_t); SIMPLE_GET_FUNC(AttackData, GetBasePower, u8);
SIMPLE_GET_FUNC(AttackData, GetAccuracy, uint8_t); SIMPLE_GET_FUNC(AttackData, GetAccuracy, u8);
SIMPLE_GET_FUNC(AttackData, GetBaseUsages, uint8_t); SIMPLE_GET_FUNC(AttackData, GetBaseUsages, u8);
SIMPLE_GET_FUNC(AttackData, GetTarget, AttackTarget); SIMPLE_GET_FUNC(AttackData, GetTarget, AttackTarget);
SIMPLE_GET_FUNC(AttackData, GetPriority, int8_t); SIMPLE_GET_FUNC(AttackData, GetPriority, i8);
export bool CreatureLib_AttackData_HasSecondaryEffect(const AttackData* p) { return p->HasSecondaryEffect(); } export bool CreatureLib_AttackData_HasSecondaryEffect(const AttackData* p) { return p->HasSecondaryEffect(); }

2
CInterface/Library/AttackLibrary.cpp
View File

@ -4,7 +4,7 @@
using namespace CreatureLib::Library; using namespace CreatureLib::Library;
export uint8_t CreatureLib_AttackLibrary_Construct(AttackLibrary*& library, size_t initialCapacity = 32) { export u8 CreatureLib_AttackLibrary_Construct(AttackLibrary*& library, size_t initialCapacity = 32) {
Try(library = new AttackLibrary(initialCapacity);) Try(library = new AttackLibrary(initialCapacity);)
}; };

18
CInterface/Library/BaseLibrary.cpp
View File

@ -1,19 +1,17 @@
#include "../Core.hpp" #include "../Core.hpp"
#define BASELIBRARY(simpleName, fullname, returnType) \ #define BASELIBRARY(simpleName, fullname, returnType) \
export uint8_t simpleName##_Insert(fullname* p, const char* name, returnType* t) { \ export u8 simpleName##_Insert(fullname* p, const char* name, returnType* t) { \
Try(p->Insert(ArbUt::StringView::CalculateHash(name), t);) \ Try(p->Insert(ArbUt::StringView::CalculateHash(name), t);) \
} \ } \
\ \
export uint8_t simpleName##_InsertWithHash(fullname* p, uint32_t hashedKey, returnType* t) { \ export u8 simpleName##_InsertWithHash(fullname* p, u32 hashedKey, returnType* t) { Try(p->Insert(hashedKey, t);) } \
Try(p->Insert(hashedKey, t);) \
} \
\ \
export uint8_t simpleName##_Delete(fullname* p, const char* name) { \ export u8 simpleName##_Delete(fullname* p, const char* name) { \
Try(p->Delete(ArbUt::StringView::CalculateHash(name));) \ Try(p->Delete(ArbUt::StringView::CalculateHash(name));) \
} \ } \
\ \
export uint8_t simpleName##_DeleteWithHash(fullname* p, uint32_t hashedKey) { Try(p->Delete(hashedKey);) } \ export u8 simpleName##_DeleteWithHash(fullname* p, u32 hashedKey) { Try(p->Delete(hashedKey);) } \
\ \
export bool simpleName##_TryGet(fullname* p, const char* name, const returnType*& out) { \ export bool simpleName##_TryGet(fullname* p, const char* name, const returnType*& out) { \
ArbUt::BorrowedPtr<const returnType> o; \ ArbUt::BorrowedPtr<const returnType> o; \
@ -27,7 +25,7 @@
} \ } \
} \ } \
\ \
export bool simpleName##_TryGetWithHash(fullname* p, uint32_t hashedKey, const returnType*& out) { \ export bool simpleName##_TryGetWithHash(fullname* p, u32 hashedKey, const returnType*& out) { \
ArbUt::BorrowedPtr<const returnType> o; \ ArbUt::BorrowedPtr<const returnType> o; \
auto v = p->TryGet(hashedKey); \ auto v = p->TryGet(hashedKey); \
if (!v.has_value()) { \ if (!v.has_value()) { \
@ -39,15 +37,15 @@
} \ } \
} \ } \
\ \
export uint8_t simpleName##_Get(fullname* p, const char* name, const returnType*& out) { \ export u8 simpleName##_Get(fullname* p, const char* name, const returnType*& out) { \
Try(out = p->Get(ArbUt::StringView::CalculateHash(name)).GetRaw();) \ Try(out = p->Get(ArbUt::StringView::CalculateHash(name)).GetRaw();) \
} \ } \
\ \
export uint8_t simpleName##_GetWithHash(fullname* p, uint32_t hashedKey, const returnType*& out) { \ export u8 simpleName##_GetWithHash(fullname* p, u32 hashedKey, const returnType*& out) { \
Try(out = p->Get(hashedKey).GetRaw();) \ Try(out = p->Get(hashedKey).GetRaw();) \
} \ } \
\ \
export size_t simpleName##_GetCount(fullname* p) { return p->GetCount(); } \ export size_t simpleName##_GetCount(fullname* p) { return p->GetCount(); } \
export uint8_t simpleName##_GetAtIndex(fullname* p, size_t index, const returnType*& out) { \ export u8 simpleName##_GetAtIndex(fullname* p, size_t index, const returnType*& out) { \
Try(out = p->GetAtIndex(index).GetRaw();) \ Try(out = p->GetAtIndex(index).GetRaw();) \
} }

28
CInterface/Library/CreatureSpecies.cpp
View File

@ -2,12 +2,12 @@
#include "../Core.hpp" #include "../Core.hpp"
using namespace CreatureLib::Library; using namespace CreatureLib::Library;
export uint8_t CreatureLib_CreatureSpecies_Construct(CreatureSpecies*& out, uint16_t id, const char* name, export u8 CreatureLib_CreatureSpecies_Construct(CreatureSpecies*& out, u16 id, const char* name,
SpeciesVariant* defaultVariant, float genderRatio, SpeciesVariant* defaultVariant, float genderRatio,
const char* growthRate, uint8_t captureRate, const char* flags[], const char* growthRate, u8 captureRate, const char* flags[],
size_t flagsCount) { size_t flagsCount) {
Try(std::unordered_set<uint32_t> conversedFlags(flagsCount); Try(std::unordered_set<u32> conversedFlags(flagsCount);
for (size_t i = 0; i < flagsCount; i++) { conversedFlags.insert(ArbUt::StringView::CalculateHash(flags[i])); } for (size_t i = 0; i < flagsCount; i++) { conversedFlags.insert(ArbUt::StringView::CalculateHash(flags[i])); }
out = new CreatureSpecies(id, ArbUt::StringView(name), defaultVariant, genderRatio, out = new CreatureSpecies(id, ArbUt::StringView(name), defaultVariant, genderRatio,
@ -16,9 +16,9 @@ export uint8_t CreatureLib_CreatureSpecies_Construct(CreatureSpecies*& out, uint
export void CreatureLib_CreatureSpecies_Destruct(const CreatureSpecies* p) { delete p; } export void CreatureLib_CreatureSpecies_Destruct(const CreatureSpecies* p) { delete p; }
SIMPLE_GET_FUNC(CreatureSpecies, GetId, uint16_t); SIMPLE_GET_FUNC(CreatureSpecies, GetId, u16);
SIMPLE_GET_FUNC(CreatureSpecies, GetGenderRate, float); SIMPLE_GET_FUNC(CreatureSpecies, GetGenderRate, float);
SIMPLE_GET_FUNC(CreatureSpecies, GetCaptureRate, uint8_t); SIMPLE_GET_FUNC(CreatureSpecies, GetCaptureRate, u8);
export const char* CreatureLib_CreatureSpecies_GetName(const CreatureSpecies* p) { return p->GetName().c_str(); } export const char* CreatureLib_CreatureSpecies_GetName(const CreatureSpecies* p) { return p->GetName().c_str(); }
export const char* CreatureLib_CreatureSpecies_GetGrowthRate(const CreatureSpecies* p) { export const char* CreatureLib_CreatureSpecies_GetGrowthRate(const CreatureSpecies* p) {
return p->GetGrowthRate().c_str(); return p->GetGrowthRate().c_str();
@ -26,7 +26,7 @@ export const char* CreatureLib_CreatureSpecies_GetGrowthRate(const CreatureSpeci
export bool CreatureLib_CreatureSpecies_HasVariant(const CreatureSpecies* p, const char* name) { export bool CreatureLib_CreatureSpecies_HasVariant(const CreatureSpecies* p, const char* name) {
return p->HasVariant(ArbUt::StringView::CalculateHash(name)); return p->HasVariant(ArbUt::StringView::CalculateHash(name));
} }
export bool CreatureLib_CreatureSpecies_HasVariantWithHash(const CreatureSpecies* p, uint32_t hash) { export bool CreatureLib_CreatureSpecies_HasVariantWithHash(const CreatureSpecies* p, u32 hash) {
return p->HasVariant(hash); return p->HasVariant(hash);
} }
export bool CreatureLib_CreatureSpecies_TryGetVariant(const CreatureSpecies* p, const char* name, export bool CreatureLib_CreatureSpecies_TryGetVariant(const CreatureSpecies* p, const char* name,
@ -37,7 +37,7 @@ export bool CreatureLib_CreatureSpecies_TryGetVariant(const CreatureSpecies* p,
out = res.value(); out = res.value();
return true; return true;
} }
export bool CreatureLib_CreatureSpecies_TryGetVariantWithHash(const CreatureSpecies* p, uint32_t hash, export bool CreatureLib_CreatureSpecies_TryGetVariantWithHash(const CreatureSpecies* p, u32 hash,
const SpeciesVariant*& out) { const SpeciesVariant*& out) {
auto res = p->TryGetVariant(hash); auto res = p->TryGetVariant(hash);
if (!res.has_value()) if (!res.has_value())
@ -46,15 +46,15 @@ export bool CreatureLib_CreatureSpecies_TryGetVariantWithHash(const CreatureSpec
return true; return true;
} }
export uint8_t CreatureLib_CreatureSpecies_GetVariant(const SpeciesVariant*& out, const CreatureSpecies* p, export u8 CreatureLib_CreatureSpecies_GetVariant(const SpeciesVariant*& out, const CreatureSpecies* p,
const char* name) { const char* name) {
Try(out = p->GetVariant(ArbUt::StringView::CalculateHash(name)).GetRaw();) Try(out = p->GetVariant(ArbUt::StringView::CalculateHash(name)).GetRaw();)
} }
export uint8_t CreatureLib_CreatureSpecies_GetVariantWithHash(const SpeciesVariant*& out, const CreatureSpecies* p, export u8 CreatureLib_CreatureSpecies_GetVariantWithHash(const SpeciesVariant*& out, const CreatureSpecies* p,
uint32_t hash) { u32 hash) {
Try(out = p->GetVariant(hash).GetRaw();) Try(out = p->GetVariant(hash).GetRaw();)
} }
export uint8_t CreatureLib_CreatureSpecies_SetVariant(CreatureSpecies* p, const char* name, SpeciesVariant* variant) { export u8 CreatureLib_CreatureSpecies_SetVariant(CreatureSpecies* p, const char* name, SpeciesVariant* variant) {
Try(p->SetVariant(ArbUt::StringView(name), variant);) Try(p->SetVariant(ArbUt::StringView(name), variant);)
} }

7
CInterface/Library/DataLibrary.cpp
View File

@ -2,10 +2,9 @@
#include "../Core.hpp" #include "../Core.hpp"
using namespace CreatureLib::Library; using namespace CreatureLib::Library;
export uint8_t CreatureLib_DataLibrary_Construct(const DataLibrary*& out, LibrarySettings* settings, export u8 CreatureLib_DataLibrary_Construct(const DataLibrary*& out, LibrarySettings* settings, SpeciesLibrary* species,
SpeciesLibrary* species, AttackLibrary* attacks, ItemLibrary* items, AttackLibrary* attacks, ItemLibrary* items, GrowthRateLibrary* growthRates,
GrowthRateLibrary* growthRates, TypeLibrary* typeLibrary, TypeLibrary* typeLibrary, TalentLibrary* talentLibrary) {
TalentLibrary* talentLibrary) {
Try(out = new DataLibrary(settings, species, attacks, items, growthRates, typeLibrary, talentLibrary);) Try(out = new DataLibrary(settings, species, attacks, items, growthRates, typeLibrary, talentLibrary);)
} }

10
CInterface/Library/EffectParameter.cpp
View File

@ -3,7 +3,7 @@
using namespace CreatureLib::Library; using namespace CreatureLib::Library;
export EffectParameter* CreatureLib_EffectParameter_FromBool(bool b) { return new EffectParameter(b); } export EffectParameter* CreatureLib_EffectParameter_FromBool(bool b) { return new EffectParameter(b); }
export EffectParameter* CreatureLib_EffectParameter_FromInt(int64_t i) { return new EffectParameter(i); } export EffectParameter* CreatureLib_EffectParameter_FromInt(i64 i) { return new EffectParameter(i); }
export EffectParameter* CreatureLib_EffectParameter_FromFloat(float f) { return new EffectParameter(f); } export EffectParameter* CreatureLib_EffectParameter_FromFloat(float f) { return new EffectParameter(f); }
export EffectParameter* CreatureLib_EffectParameter_FromString(const char* c) { export EffectParameter* CreatureLib_EffectParameter_FromString(const char* c) {
return new EffectParameter(ArbUt::StringView(c)); return new EffectParameter(ArbUt::StringView(c));
@ -11,9 +11,9 @@ export EffectParameter* CreatureLib_EffectParameter_FromString(const char* c) {
export void CreatureLib_EffectParameter_Destruct(const EffectParameter* p) { delete p; } export void CreatureLib_EffectParameter_Destruct(const EffectParameter* p) { delete p; }
export EffectParameterType CreatureLib_EffectParameter_GetType(const EffectParameter* p) { return p->GetType(); } export EffectParameterType CreatureLib_EffectParameter_GetType(const EffectParameter* p) { return p->GetType(); }
export uint8_t CreatureLib_EffectParameter_AsBool(const EffectParameter* p, bool& out) { Try(out = p->AsBool();) } export u8 CreatureLib_EffectParameter_AsBool(const EffectParameter* p, bool& out) { Try(out = p->AsBool();) }
export uint8_t CreatureLib_EffectParameter_AsInt(const EffectParameter* p, int64_t& out) { Try(out = p->AsInt();) } export u8 CreatureLib_EffectParameter_AsInt(const EffectParameter* p, i64& out) { Try(out = p->AsInt();) }
export uint8_t CreatureLib_EffectParameter_AsFloat(const EffectParameter* p, float& out) { Try(out = p->AsFloat();) } export u8 CreatureLib_EffectParameter_AsFloat(const EffectParameter* p, float& out) { Try(out = p->AsFloat();) }
export uint8_t CreatureLib_EffectParameter_AsString(const EffectParameter* p, const char*& out) { export u8 CreatureLib_EffectParameter_AsString(const EffectParameter* p, const char*& out) {
Try(out = p->AsString().c_str();) Try(out = p->AsString().c_str();)
} }

12
CInterface/Library/GrowthRate.cpp
View File

@ -4,13 +4,13 @@
#include "../Core.hpp" #include "../Core.hpp"
using namespace CreatureLib::Library; using namespace CreatureLib::Library;
export GrowthRate* CreatureLib_LookupGrowthRate_Construct(uint32_t experiencePerLevel[], size_t count) { export GrowthRate* CreatureLib_LookupGrowthRate_Construct(u32 experiencePerLevel[], size_t count) {
ArbUt::List<uint32_t> exp(experiencePerLevel, experiencePerLevel + count); ArbUt::List<u32> exp(experiencePerLevel, experiencePerLevel + count);
return new LookupGrowthRate(exp); return new LookupGrowthRate(exp);
}; };
export uint8_t CreatureLib_ExternGrowthRate_Construct(GrowthRate*& out, level_int_t (*calcLevel)(uint32_t), export u8 CreatureLib_ExternGrowthRate_Construct(GrowthRate*& out, level_int_t (*calcLevel)(u32),
uint32_t (*calcExperience)(level_int_t)) { u32 (*calcExperience)(level_int_t)) {
Try(out = new ExternGrowthRate(calcLevel, calcExperience);) Try(out = new ExternGrowthRate(calcLevel, calcExperience);)
}; };
@ -18,10 +18,10 @@ export void CreatureLib_GrowthRate_Destruct(const GrowthRate* p) { delete p; }
export void CreatureLib_LookupGrowthRate_Destruct(const LookupGrowthRate* p) { delete p; } export void CreatureLib_LookupGrowthRate_Destruct(const LookupGrowthRate* p) { delete p; }
export void CreatureLib_ExternGrowthRate_Destruct(const ExternGrowthRate* p) { delete p; } export void CreatureLib_ExternGrowthRate_Destruct(const ExternGrowthRate* p) { delete p; }
export uint8_t CreatureLib_GrowthRate_CalculateLevel(level_int_t& out, const GrowthRate* p, uint32_t experience) { export u8 CreatureLib_GrowthRate_CalculateLevel(level_int_t& out, const GrowthRate* p, u32 experience) {
Try(out = p->CalculateLevel(experience);) Try(out = p->CalculateLevel(experience);)
} }
export uint8_t CreatureLib_GrowthRate_CalculateExperience(uint32_t& out, const GrowthRate* p, level_int_t level) { export u8 CreatureLib_GrowthRate_CalculateExperience(u32& out, const GrowthRate* p, level_int_t level) {
Try(out = p->CalculateExperience(level);) Try(out = p->CalculateExperience(level);)
} }

24
CInterface/Library/GrowthRateLibrary.cpp
View File

@ -8,30 +8,30 @@ export GrowthRateLibrary* CreatureLib_GrowthRateLibrary_Construct(size_t initial
export void CreatureLib_GrowthRateLibrary_Destruct(GrowthRateLibrary* p) { delete p; } export void CreatureLib_GrowthRateLibrary_Destruct(GrowthRateLibrary* p) { delete p; }
export uint8_t CreatureLib_GrowthRateLibrary_CalculateLevel(level_int_t& out, GrowthRateLibrary* library, export u8 CreatureLib_GrowthRateLibrary_CalculateLevel(level_int_t& out, GrowthRateLibrary* library,
const char* growthRate, uint32_t experience) { const char* growthRate, u32 experience) {
Try(out = library->CalculateLevel(ArbUt::StringView::CalculateHash(growthRate), experience);) Try(out = library->CalculateLevel(ArbUt::StringView::CalculateHash(growthRate), experience);)
} }
export uint8_t CreatureLib_GrowthRateLibrary_CalculateLevelWithHash(level_int_t& out, GrowthRateLibrary* library, export u8 CreatureLib_GrowthRateLibrary_CalculateLevelWithHash(level_int_t& out, GrowthRateLibrary* library,
uint32_t growthRateHash, uint32_t experience) { u32 growthRateHash, u32 experience) {
Try(out = library->CalculateLevel(growthRateHash, experience);) Try(out = library->CalculateLevel(growthRateHash, experience);)
} }
export uint8_t CreatureLib_GrowthRateLibrary_CalculateExperience(uint32_t& out, GrowthRateLibrary* library, export u8 CreatureLib_GrowthRateLibrary_CalculateExperience(u32& out, GrowthRateLibrary* library,
const char* growthRate, level_int_t level) { const char* growthRate, level_int_t level) {
Try(out = library->CalculateExperience(ArbUt::StringView::CalculateHash(growthRate), level);) Try(out = library->CalculateExperience(ArbUt::StringView::CalculateHash(growthRate), level);)
} }
export uint8_t CreatureLib_GrowthRateLibrary_CalculateExperienceWithHash(uint32_t& out, GrowthRateLibrary* library, export u8 CreatureLib_GrowthRateLibrary_CalculateExperienceWithHash(u32& out, GrowthRateLibrary* library,
uint32_t growthRateHash, level_int_t level) { u32 growthRateHash, level_int_t level) {
Try(out = library->CalculateExperience(growthRateHash, level);) Try(out = library->CalculateExperience(growthRateHash, level);)
} }
export uint8_t CreatureLib_GrowthRateLibrary_AddGrowthRate(GrowthRateLibrary* library, const char* growthRateName, export u8 CreatureLib_GrowthRateLibrary_AddGrowthRate(GrowthRateLibrary* library, const char* growthRateName,
GrowthRate* growthRate) { GrowthRate* growthRate) {
Try(library->AddGrowthRate(ArbUt::StringView::CalculateHash(growthRateName), growthRate);) Try(library->AddGrowthRate(ArbUt::StringView::CalculateHash(growthRateName), growthRate);)
} }
export uint8_t CreatureLib_GrowthRateLibrary_AddGrowthRateWithHash(GrowthRateLibrary* library, uint32_t growthRateHash, export u8 CreatureLib_GrowthRateLibrary_AddGrowthRateWithHash(GrowthRateLibrary* library, u32 growthRateHash,
GrowthRate* growthRate) { GrowthRate* growthRate) {
Try(library->AddGrowthRate(growthRateHash, growthRate);) Try(library->AddGrowthRate(growthRateHash, growthRate);)
} }

6
CInterface/Library/Item.cpp
View File

@ -3,12 +3,12 @@
using namespace CreatureLib::Library; using namespace CreatureLib::Library;
export Item* CreatureLib_Item_Construct(const char* name, ItemCategory category, BattleItemCategory battleCategory, export Item* CreatureLib_Item_Construct(const char* name, ItemCategory category, BattleItemCategory battleCategory,
int32_t price, const char* effectName, EffectParameter* effectParameters[], i32 price, const char* effectName, EffectParameter* effectParameters[],
size_t effectParameterCount, const char* battleTriggerEffectName, size_t effectParameterCount, const char* battleTriggerEffectName,
EffectParameter* battleTriggerEffectParameters[], EffectParameter* battleTriggerEffectParameters[],
size_t battleTriggerEffectParameterCount, const char* flags[], size_t battleTriggerEffectParameterCount, const char* flags[],
size_t flagsCount) { size_t flagsCount) {
std::unordered_set<uint32_t> conversedFlags(flagsCount); std::unordered_set<u32> conversedFlags(flagsCount);
for (size_t i = 0; i < flagsCount; i++) { for (size_t i = 0; i < flagsCount; i++) {
conversedFlags.insert(ArbUt::StringView::CalculateHash(flags[i])); conversedFlags.insert(ArbUt::StringView::CalculateHash(flags[i]));
} }
@ -29,7 +29,7 @@ export void CreatureLib_Item_Destruct(const Item* p) { delete p; }
export const char* CreatureLib_Item_GetName(const Item* p) { return p->GetName().c_str(); } export const char* CreatureLib_Item_GetName(const Item* p) { return p->GetName().c_str(); }
SIMPLE_GET_FUNC(Item, GetCategory, ItemCategory); SIMPLE_GET_FUNC(Item, GetCategory, ItemCategory);
SIMPLE_GET_FUNC(Item, GetBattleCategory, BattleItemCategory); SIMPLE_GET_FUNC(Item, GetBattleCategory, BattleItemCategory);
SIMPLE_GET_FUNC(Item, GetPrice, int32_t); SIMPLE_GET_FUNC(Item, GetPrice, i32);
export bool CreatureLib_Item_HasFlag(const Item* p, const char* key) { export bool CreatureLib_Item_HasFlag(const Item* p, const char* key) {
return p->HasFlag(ArbUt::StringView::CalculateHash(key)); return p->HasFlag(ArbUt::StringView::CalculateHash(key));

8
CInterface/Library/LearnableAttacks.cpp
View File

@ -2,7 +2,7 @@
#include "../Core.hpp" #include "../Core.hpp"
using namespace CreatureLib::Library; using namespace CreatureLib::Library;
export uint8_t CreatureLib_LearnableAttacks_Construct(LearnableAttacks*& out, size_t levelAttackCapacity) { export u8 CreatureLib_LearnableAttacks_Construct(LearnableAttacks*& out, size_t levelAttackCapacity) {
Try(out = new LearnableAttacks(levelAttackCapacity);) Try(out = new LearnableAttacks(levelAttackCapacity);)
}; };
@ -13,13 +13,13 @@ export void CreatureLib_LearnableAttacks_AddLevelAttack(LearnableAttacks* p, lev
p->AddLevelAttack(level, attack); p->AddLevelAttack(level, attack);
} }
export const AttackData* const* CreatureLib_LearnableAttacks_GetAttacksForLevel(LearnableAttacks* p, uint8_t level) { export const AttackData* const* CreatureLib_LearnableAttacks_GetAttacksForLevel(LearnableAttacks* p, u8 level) {
return reinterpret_cast<const AttackData* const*>(p->GetAttacksForLevel(level).RawData()); return reinterpret_cast<const AttackData* const*>(p->GetAttacksForLevel(level).RawData());
} }
export bool CreatureLib_LearnableAttacks_HasAttacksForLevel(LearnableAttacks* p, uint8_t level) { export bool CreatureLib_LearnableAttacks_HasAttacksForLevel(LearnableAttacks* p, u8 level) {
return p->HasAttacksForLevel(level); return p->HasAttacksForLevel(level);
} }
export size_t CreatureLib_LearnableAttacks_GetAttacksForLevelCount(LearnableAttacks* p, uint8_t level) { export size_t CreatureLib_LearnableAttacks_GetAttacksForLevelCount(LearnableAttacks* p, u8 level) {
return p->GetAttacksForLevel(level).Count(); return p->GetAttacksForLevel(level).Count();
} }

4
CInterface/Library/LibrarySettings.cpp
View File

@ -2,11 +2,11 @@
#include "../Core.hpp" #include "../Core.hpp"
using namespace CreatureLib::Library; using namespace CreatureLib::Library;
export const LibrarySettings* CreatureLib_LibrarySettings_Construct(uint8_t maximalLevel, uint8_t maximalMoves) { export const LibrarySettings* CreatureLib_LibrarySettings_Construct(u8 maximalLevel, u8 maximalMoves) {
return new LibrarySettings(maximalLevel, maximalMoves); return new LibrarySettings(maximalLevel, maximalMoves);
} }
export void CreatureLib_LibrarySettings_Destruct(const LibrarySettings* p) { delete p; } export void CreatureLib_LibrarySettings_Destruct(const LibrarySettings* p) { delete p; }
SIMPLE_GET_FUNC(LibrarySettings, GetMaximalLevel, level_int_t); SIMPLE_GET_FUNC(LibrarySettings, GetMaximalLevel, level_int_t);
SIMPLE_GET_FUNC(LibrarySettings, GetMaximalAttacks, uint8_t); SIMPLE_GET_FUNC(LibrarySettings, GetMaximalAttacks, u8);

2
CInterface/Library/SpeciesLibrary.cpp
View File

@ -11,6 +11,6 @@ export void CreatureLib_SpeciesLibrary_Destruct(const SpeciesLibrary* p) { delet
BASELIBRARY(CreatureLib_SpeciesLibrary, SpeciesLibrary, CreatureSpecies); BASELIBRARY(CreatureLib_SpeciesLibrary, SpeciesLibrary, CreatureSpecies);
export const CreatureSpecies* CreatureLib_SpeciesLibrary_GetById(const SpeciesLibrary* p, uint16_t id) { export const CreatureSpecies* CreatureLib_SpeciesLibrary_GetById(const SpeciesLibrary* p, u16 id) {
return p->GetById(id).GetRaw(); return p->GetById(id).GetRaw();
} }

34
CInterface/Library/SpeciesVariant.cpp
View File

@ -3,15 +3,13 @@
using namespace CreatureLib::Library; using namespace CreatureLib::Library;
export SpeciesVariant* export SpeciesVariant* CreatureLib_SpeciesVariant_Construct(
CreatureLib_SpeciesVariant_Construct(const char* name, float height, float weight, uint32_t baseExperience, const char* name, float height, float weight, u32 baseExperience, u8 types[], size_t typeLength, u16 baseHealth,
uint8_t types[], size_t typeLength, uint16_t baseHealth, uint16_t baseAttack, u16 baseAttack, u16 baseDefense, u16 baseMagicalAttack, u16 baseMagicalDefense, u16 baseSpeed,
uint16_t baseDefense, uint16_t baseMagicalAttack, uint16_t baseMagicalDefense, const Talent* talents[], size_t talentsLength, const Talent* secretTalents[], size_t secretTalentsLength,
uint16_t baseSpeed, const Talent* talents[], size_t talentsLength, const LearnableAttacks* attacks, const char* flags[], size_t flagsCount) {
const Talent* secretTalents[], size_t secretTalentsLength,
const LearnableAttacks* attacks, const char* flags[], size_t flagsCount) {
std::unordered_set<uint32_t> conversedFlags(flagsCount); std::unordered_set<u32> conversedFlags(flagsCount);
for (size_t i = 0; i < flagsCount; i++) { for (size_t i = 0; i < flagsCount; i++) {
conversedFlags.insert(ArbUt::StringView::CalculateHash(flags[i])); conversedFlags.insert(ArbUt::StringView::CalculateHash(flags[i]));
} }
@ -25,11 +23,11 @@ CreatureLib_SpeciesVariant_Construct(const char* name, float height, float weigh
secretTalentsWrapped.Append(secretTalents[i]); secretTalentsWrapped.Append(secretTalents[i]);
} }
return new SpeciesVariant( return new SpeciesVariant(ArbUt::StringView(name), height, weight, baseExperience,
ArbUt::StringView(name), height, weight, baseExperience, ArbUt::List<uint8_t>(types, types + typeLength), ArbUt::List<u8>(types, types + typeLength),
CreatureLib::Library::StatisticSet<uint16_t>(baseHealth, baseAttack, baseDefense, baseMagicalAttack, CreatureLib::Library::StatisticSet<u16>(baseHealth, baseAttack, baseDefense,
baseMagicalDefense, baseSpeed), baseMagicalAttack, baseMagicalDefense, baseSpeed),
talentsWrapped, secretTalentsWrapped, attacks, conversedFlags); talentsWrapped, secretTalentsWrapped, attacks, conversedFlags);
} }
export void CreatureLib_SpeciesVariant_Destruct(SpeciesVariant* p) { delete p; } export void CreatureLib_SpeciesVariant_Destruct(SpeciesVariant* p) { delete p; }
@ -37,21 +35,21 @@ export void CreatureLib_SpeciesVariant_Destruct(SpeciesVariant* p) { delete p; }
export const char* CreatureLib_SpeciesVariant_GetName(SpeciesVariant* p) { return p->GetName().c_str(); } export const char* CreatureLib_SpeciesVariant_GetName(SpeciesVariant* p) { return p->GetName().c_str(); }
SIMPLE_GET_FUNC(SpeciesVariant, GetHeight, float); SIMPLE_GET_FUNC(SpeciesVariant, GetHeight, float);
SIMPLE_GET_FUNC(SpeciesVariant, GetWeight, float); SIMPLE_GET_FUNC(SpeciesVariant, GetWeight, float);
SIMPLE_GET_FUNC(SpeciesVariant, GetBaseExperience, uint32_t); SIMPLE_GET_FUNC(SpeciesVariant, GetBaseExperience, u32);
SIMPLE_GET_FUNC(SpeciesVariant, GetTypeCount, size_t); SIMPLE_GET_FUNC(SpeciesVariant, GetTypeCount, size_t);
export uint8_t CreatureLib_SpeciesVariant_GetType(SpeciesVariant* p, size_t index) { return p->GetType(index); } export u8 CreatureLib_SpeciesVariant_GetType(SpeciesVariant* p, size_t index) { return p->GetType(index); }
export uint16_t CreatureLib_SpeciesVariant_GetStatistic(SpeciesVariant* p, CreatureLib::Library::Statistic stat) { export u16 CreatureLib_SpeciesVariant_GetStatistic(SpeciesVariant* p, CreatureLib::Library::Statistic stat) {
return p->GetStatistic(stat); return p->GetStatistic(stat);
} }
SIMPLE_GET_FUNC(SpeciesVariant, GetTalentCount, size_t); SIMPLE_GET_FUNC(SpeciesVariant, GetTalentCount, size_t);
SIMPLE_GET_FUNC(SpeciesVariant, GetSecretTalentCount, size_t); SIMPLE_GET_FUNC(SpeciesVariant, GetSecretTalentCount, size_t);
export uint8_t CreatureLib_SpeciesVariant_GetTalent(SpeciesVariant* p, bool secret, uint8_t index, const Talent*& out) { export u8 CreatureLib_SpeciesVariant_GetTalent(SpeciesVariant* p, bool secret, u8 index, const Talent*& out) {
Try(out = p->GetTalent(TalentIndex(secret, index)).GetRaw();) Try(out = p->GetTalent(TalentIndex(secret, index)).GetRaw();)
} }
export const LearnableAttacks* CreatureLib_SpeciesVariant_GetLearnableAttacks(SpeciesVariant* p) { export const LearnableAttacks* CreatureLib_SpeciesVariant_GetLearnableAttacks(SpeciesVariant* p) {
return p->GetLearnableAttacks().GetRaw(); return p->GetLearnableAttacks().GetRaw();
} }
export uint8_t CreatureLib_SpeciesVariant_GetRandomTalent(SpeciesVariant* p, ArbUt::Random* rand) { export u8 CreatureLib_SpeciesVariant_GetRandomTalent(SpeciesVariant* p, ArbUt::Random* rand) {
return p->GetRandomTalent(*rand).GetIndex(); return p->GetRandomTalent(*rand).GetIndex();
} }
export bool CreatureLib_SpeciesVariant_HasFlag(const SpeciesVariant* p, const char* key) { export bool CreatureLib_SpeciesVariant_HasFlag(const SpeciesVariant* p, const char* key) {

2
CInterface/Library/TalentLibrary.cpp
View File

@ -4,7 +4,7 @@
using namespace CreatureLib::Library; using namespace CreatureLib::Library;
export uint8_t CreatureLib_TalentLibrary_Construct(TalentLibrary*& library, size_t initialCapacity = 32) { export u8 CreatureLib_TalentLibrary_Construct(TalentLibrary*& library, size_t initialCapacity = 32) {
Try(library = new TalentLibrary(initialCapacity);) Try(library = new TalentLibrary(initialCapacity);)
}; };

18
CInterface/Library/TypeLibrary.cpp
View File

@ -8,27 +8,25 @@ export TypeLibrary* CreatureLib_TypeLibrary_Construct(size_t initialCapacity) {
export void CreatureLib_TypeLibrary_Destruct(const TypeLibrary* p) { delete p; } export void CreatureLib_TypeLibrary_Destruct(const TypeLibrary* p) { delete p; }
export uint8_t CreatureLib_TypeLibrary_GetTypeId(uint8_t& out, const TypeLibrary* p, const char* type) { export u8 CreatureLib_TypeLibrary_GetTypeId(u8& out, const TypeLibrary* p, const char* type) {
Try(out = p->GetTypeId(ArbUt::StringView(type));) Try(out = p->GetTypeId(ArbUt::StringView(type));)
} }
export uint8_t CreatureLib_TypeLibrary_RegisterType(uint8_t& out, TypeLibrary* p, const char* type) { export u8 CreatureLib_TypeLibrary_RegisterType(u8& out, TypeLibrary* p, const char* type) {
Try(out = p->RegisterType(ArbUt::StringView(type));) Try(out = p->RegisterType(ArbUt::StringView(type));)
} }
export uint8_t CreatureLib_TypeLibrary_SetEffectiveness(TypeLibrary* p, uint8_t attacking, uint8_t defensive, export u8 CreatureLib_TypeLibrary_SetEffectiveness(TypeLibrary* p, u8 attacking, u8 defensive, float effectiveness) {
float effectiveness) {
Try(p->SetEffectiveness(attacking, defensive, effectiveness);) Try(p->SetEffectiveness(attacking, defensive, effectiveness);)
} }
export uint8_t CreatureLib_TypeLibrary_GetSingleEffectiveness(float& out, TypeLibrary* p, uint8_t attacking, export u8 CreatureLib_TypeLibrary_GetSingleEffectiveness(float& out, TypeLibrary* p, u8 attacking, u8 defensive) {
uint8_t defensive) {
Try(out = p->GetSingleEffectiveness(attacking, defensive);) Try(out = p->GetSingleEffectiveness(attacking, defensive);)
} }
export uint8_t CreatureLib_TypeLibrary_GetEffectiveness(float& out, TypeLibrary* p, uint8_t attacking, export u8 CreatureLib_TypeLibrary_GetEffectiveness(float& out, TypeLibrary* p, u8 attacking, u8 defensive[],
uint8_t defensive[], size_t defensiveCount) { size_t defensiveCount) {
Try(out = p->GetEffectiveness(attacking, std::vector<uint8_t>(defensive, defensive + defensiveCount));) Try(out = p->GetEffectiveness(attacking, std::vector<u8>(defensive, defensive + defensiveCount));)
} }
export uint8_t CreatureLib_TypeLibrary_GetTypeName(const char*& out, TypeLibrary* p, uint8_t type) { export u8 CreatureLib_TypeLibrary_GetTypeName(const char*& out, TypeLibrary* p, u8 type) {
Try(out = p->GetTypeName(type).c_str();) Try(out = p->GetTypeName(type).c_str();)
} }

4
CMakeLists.txt
View File

@ -127,7 +127,7 @@ if (CREATURELIB_TESTS)
# Add a definition for the test library # Add a definition for the test library
target_compile_definitions(CreatureLibTests PRIVATE TESTS_BUILD) target_compile_definitions(CreatureLibTests PRIVATE TESTS_BUILD)
if (SANITIZER_TESTS AND NOT WINDOWS) if (SANITIZER_TESTS AND NOT WINDOWS)
target_compile_options(CreatureLibTests PRIVATE -fsanitize=address) target_compile_options(CreatureLibTests PRIVATE -fsanitize=address,undefined,leak,integer,nullability -fno-sanitize-recover=all)
target_link_options(CreatureLibTests PRIVATE -fsanitize=address) target_link_options(CreatureLibTests PRIVATE -fsanitize=address,undefined,leak,integer,nullability -fno-sanitize-recover=all)
endif () endif ()
endif () endif ()

2
src/Battling/EventHooks/EventDataKind.hpp
View File

@ -4,7 +4,7 @@
#include <Arbutils/Enum.hpp> #include <Arbutils/Enum.hpp>
namespace CreatureLib::Battling { namespace CreatureLib::Battling {
ENUM(EventDataKind, uint8_t, Damage, Heal, Faint, Switch, TurnStart, TurnEnd, ExperienceGain, Miss, DisplayText, ENUM(EventDataKind, u8, Damage, Heal, Faint, Switch, TurnStart, TurnEnd, ExperienceGain, Miss, DisplayText,
ChangeSpecies, ChangeVariant, AttackUse, ChangeStatBoost, Fail, Swap, StatusChange) ChangeSpecies, ChangeVariant, AttackUse, ChangeStatBoost, Fail, Swap, StatusChange)
} }

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

@ -21,7 +21,7 @@ namespace CreatureLib::Battling {
std::vector<EventHookFunc> _listeners; std::vector<EventHookFunc> _listeners;
size_t _offset; size_t _offset;
size_t _capacity; size_t _capacity;
uint8_t* _memory = nullptr; u8* _memory = nullptr;
static constexpr size_t initialSize = 2048; static constexpr size_t initialSize = 2048;
static constexpr size_t stepSize = 1024; static constexpr size_t stepSize = 1024;
@ -32,7 +32,7 @@ namespace CreatureLib::Battling {
if (ptr == nullptr) { if (ptr == nullptr) {
THROW("Out of memory."); THROW("Out of memory.");
} }
_memory = static_cast<uint8_t*>(ptr); _memory = static_cast<u8*>(ptr);
} }
EventHook(const EventHook&) = delete; EventHook(const EventHook&) = delete;
EventHook& operator=(const EventHook&) = delete; EventHook& operator=(const EventHook&) = delete;
@ -52,9 +52,9 @@ namespace CreatureLib::Battling {
if (newPtr == nullptr) { if (newPtr == nullptr) {
THROW("Out of memory."); THROW("Out of memory.");
} }
_memory = static_cast<uint8_t*>(newPtr); _memory = static_cast<u8*>(newPtr);
} }
uint8_t* ptr = _memory + _offset; u8* ptr = _memory + _offset;
T* event = new (ptr) T(args...); T* event = new (ptr) T(args...);
_offset += sizeof(T); _offset += sizeof(T);
for (const auto& listener : _listeners) { for (const auto& listener : _listeners) {

10
src/Battling/EventHooks/Events/ChangeStatEvent.hpp
View File

@ -7,19 +7,19 @@ namespace CreatureLib::Battling {
class ChangeStatBoostEvent final : public EventData { class ChangeStatBoostEvent final : public EventData {
const ArbUt::BorrowedPtr<Creature> _creature; const ArbUt::BorrowedPtr<Creature> _creature;
const CreatureLib::Library::Statistic _statistic; const CreatureLib::Library::Statistic _statistic;
const int8_t _oldValue; const i8 _oldValue;
const int8_t _newValue; const i8 _newValue;
public: public:
ChangeStatBoostEvent(const ArbUt::BorrowedPtr<Creature>& creature, CreatureLib::Library::Statistic statistic, ChangeStatBoostEvent(const ArbUt::BorrowedPtr<Creature>& creature, CreatureLib::Library::Statistic statistic,
int8_t oldValue, int8_t newValue) noexcept i8 oldValue, i8 newValue) noexcept
: _creature(creature), _statistic(statistic), _oldValue(oldValue), _newValue(newValue) {} : _creature(creature), _statistic(statistic), _oldValue(oldValue), _newValue(newValue) {}
EventDataKind GetKind() const noexcept override { return EventDataKind ::ChangeStatBoost; } EventDataKind GetKind() const noexcept override { return EventDataKind ::ChangeStatBoost; }
const ArbUt::BorrowedPtr<Creature>& GetCreature() const noexcept { return _creature; } const ArbUt::BorrowedPtr<Creature>& GetCreature() const noexcept { return _creature; }
CreatureLib::Library::Statistic GetStatistic() const noexcept { return _statistic; } CreatureLib::Library::Statistic GetStatistic() const noexcept { return _statistic; }
int8_t GetOldValue() const noexcept { return _oldValue; } i8 GetOldValue() const noexcept { return _oldValue; }
int8_t GetNewValue() const noexcept { return _newValue; } i8 GetNewValue() const noexcept { return _newValue; }
}; };
} }

10
src/Battling/EventHooks/Events/DamageEvent.hpp
View File

@ -6,17 +6,17 @@ namespace CreatureLib::Battling {
class DamageEvent final : public EventData { class DamageEvent final : public EventData {
ArbUt::BorrowedPtr<Creature> _creature; ArbUt::BorrowedPtr<Creature> _creature;
DamageSource _damageSource; DamageSource _damageSource;
uint32_t _originalHealth; u32 _originalHealth;
uint32_t _newHealth; u32 _newHealth;
public: public:
DamageEvent(Creature* c, DamageSource s, uint32_t oHealth, uint32_t newHealth) noexcept DamageEvent(Creature* c, DamageSource s, u32 oHealth, u32 newHealth) noexcept
: _creature(c), _damageSource(s), _originalHealth(oHealth), _newHealth(newHealth) {} : _creature(c), _damageSource(s), _originalHealth(oHealth), _newHealth(newHealth) {}
EventDataKind GetKind() const noexcept override { return EventDataKind ::Damage; } EventDataKind GetKind() const noexcept override { return EventDataKind ::Damage; }
const ArbUt::BorrowedPtr<Creature>& GetCreature() const noexcept { return _creature; } const ArbUt::BorrowedPtr<Creature>& GetCreature() const noexcept { return _creature; }
DamageSource GetDamageSource() const noexcept { return _damageSource; } DamageSource GetDamageSource() const noexcept { return _damageSource; }
uint32_t GetOriginalHealth() const noexcept { return _originalHealth; } u32 GetOriginalHealth() const noexcept { return _originalHealth; }
uint32_t GetNewHealth() const noexcept { return _newHealth; } u32 GetNewHealth() const noexcept { return _newHealth; }
}; };
} }

10
src/Battling/EventHooks/Events/ExperienceGainEvent.hpp
View File

@ -5,16 +5,16 @@
namespace CreatureLib::Battling { namespace CreatureLib::Battling {
class ExperienceGainEvent final : public EventData { class ExperienceGainEvent final : public EventData {
ArbUt::BorrowedPtr<Creature> _creature; ArbUt::BorrowedPtr<Creature> _creature;
uint32_t _previousExperience; u32 _previousExperience;
uint32_t _newExperience; u32 _newExperience;
public: public:
ExperienceGainEvent(const ArbUt::BorrowedPtr<Creature>& creature, uint32_t previousExp, uint32_t newExp) ExperienceGainEvent(const ArbUt::BorrowedPtr<Creature>& creature, u32 previousExp, u32 newExp)
: _creature(creature), _previousExperience(previousExp), _newExperience(newExp) {} : _creature(creature), _previousExperience(previousExp), _newExperience(newExp) {}
EventDataKind GetKind() const noexcept override { return EventDataKind ::ExperienceGain; } EventDataKind GetKind() const noexcept override { return EventDataKind ::ExperienceGain; }
const ArbUt::BorrowedPtr<Creature>& GetCreature() const noexcept { return _creature; } const ArbUt::BorrowedPtr<Creature>& GetCreature() const noexcept { return _creature; }
uint32_t GetPreviousExperience() const noexcept { return _previousExperience; } u32 GetPreviousExperience() const noexcept { return _previousExperience; }
uint32_t GetNewExperience() const noexcept { return _newExperience; } u32 GetNewExperience() const noexcept { return _newExperience; }
}; };
} }

10
src/Battling/EventHooks/Events/HealEvent.hpp
View File

@ -5,16 +5,16 @@
namespace CreatureLib::Battling { namespace CreatureLib::Battling {
class HealEvent final : public EventData { class HealEvent final : public EventData {
ArbUt::BorrowedPtr<Creature> _creature; ArbUt::BorrowedPtr<Creature> _creature;
uint32_t _originalHealth; u32 _originalHealth;
uint32_t _newHealth; u32 _newHealth;
public: public:
HealEvent(ArbUt::BorrowedPtr<Creature> c, uint32_t oHealth, uint32_t newHealth) noexcept HealEvent(ArbUt::BorrowedPtr<Creature> c, u32 oHealth, u32 newHealth) noexcept
: _creature(c), _originalHealth(oHealth), _newHealth(newHealth) {} : _creature(c), _originalHealth(oHealth), _newHealth(newHealth) {}
EventDataKind GetKind() const noexcept override { return EventDataKind ::Heal; } EventDataKind GetKind() const noexcept override { return EventDataKind ::Heal; }
const ArbUt::BorrowedPtr<Creature>& GetCreature() const noexcept { return _creature; } const ArbUt::BorrowedPtr<Creature>& GetCreature() const noexcept { return _creature; }
uint32_t GetOriginalHealth() const noexcept { return _originalHealth; } u32 GetOriginalHealth() const noexcept { return _originalHealth; }
uint32_t GetNewHealth() const noexcept { return _newHealth; } u32 GetNewHealth() const noexcept { return _newHealth; }
}; };
} }

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

@ -5,7 +5,7 @@ using namespace CreatureLib::Battling;
using TargetList = List<OptionalBorrowedPtr<Creature>>; using TargetList = List<OptionalBorrowedPtr<Creature>>;
static inline constexpr uint8_t GetOppositeSide(uint8_t v) { static inline constexpr u8 GetOppositeSide(u8 v) {
if (v == 1) { if (v == 1) {
return 0; return 0;
} }

6
src/Battling/Flow/TurnHandler.cpp
View File

@ -150,7 +150,7 @@ void TurnHandler::ExecuteAttackChoice(const ArbUt::BorrowedPtr<AttackTurnChoice>
} }
HOOK(OnBeforeAttack, attack, attack); HOOK(OnBeforeAttack, attack, attack);
for (uint8_t i = 0; i < attack->GetTargetCount(); i++) { for (u8 i = 0; i < attack->GetTargetCount(); i++) {
auto target = attack->GetTargets()[i]; auto target = attack->GetTargets()[i];
if (target.HasValue()) { if (target.HasValue()) {
try_creature(HandleAttackForTarget(attack, target.GetValue()), "Exception occurred during handling attack " try_creature(HandleAttackForTarget(attack, target.GetValue()), "Exception occurred during handling attack "
@ -200,7 +200,7 @@ void TurnHandler::HandleAttackForTarget(ExecutingAttack* attack, const ArbUt::Bo
EnsureNotNull(miscLibrary) EnsureNotNull(miscLibrary)
auto* hitIterator = attack->GetTargetIteratorBegin(target); auto* hitIterator = attack->GetTargetIteratorBegin(target);
for (uint8_t hitIndex = 0; hitIndex < numberOfHits; hitIndex++) { for (u8 hitIndex = 0; hitIndex < numberOfHits; hitIndex++) {
if (battle.GetValue()->HasEnded()) { if (battle.GetValue()->HasEnded()) {
return; return;
} }
@ -211,7 +211,7 @@ void TurnHandler::HandleAttackForTarget(ExecutingAttack* attack, const ArbUt::Bo
break; break;
} }
auto& hit = hitIterator[hitIndex]; auto& hit = hitIterator[hitIndex];
uint8_t hitType = attackData->GetType(); u8 hitType = attackData->GetType();
HOOK(ChangeAttackType, target, attack, target.GetRaw(), hitIndex, &hitType); HOOK(ChangeAttackType, target, attack, target.GetRaw(), hitIndex, &hitType);
hit.SetType(hitType); hit.SetType(hitType);
auto effectiveness = typeLibrary->GetEffectiveness(hitType, target->GetTypes()); auto effectiveness = typeLibrary->GetEffectiveness(hitType, target->GetTypes());

2
src/Battling/History/HistoryElementKind.hpp
View File

@ -3,5 +3,5 @@
#include <Arbutils/Enum.hpp> #include <Arbutils/Enum.hpp>
#include <cstdint> #include <cstdint>
ENUM(HistoryElementKind, uint8_t, AttackUse, Damage) ENUM(HistoryElementKind, u8, AttackUse, Damage)
#endif // CREATURELIB_HISTORYELEMENTKIND_HPP #endif // CREATURELIB_HISTORYELEMENTKIND_HPP

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

@ -3,47 +3,44 @@
using namespace CreatureLib; using namespace CreatureLib;
Library::StatisticSet<uint32_t> Battling::BattleStatCalculator::CalculateFlatStats(Battling::Creature* creature) const { Library::StatisticSet<u32> Battling::BattleStatCalculator::CalculateFlatStats(Battling::Creature* creature) const {
return Library::StatisticSet<uint32_t>(CalculateFlatStat(creature, Library::Statistic::Health), return Library::StatisticSet<u32>(CalculateFlatStat(creature, Library::Statistic::Health),
CalculateFlatStat(creature, Library::Statistic::PhysicalAttack), CalculateFlatStat(creature, Library::Statistic::PhysicalAttack),
CalculateFlatStat(creature, Library::Statistic::PhysicalDefense), CalculateFlatStat(creature, Library::Statistic::PhysicalDefense),
CalculateFlatStat(creature, Library::Statistic::MagicalAttack), CalculateFlatStat(creature, Library::Statistic::MagicalAttack),
CalculateFlatStat(creature, Library::Statistic::MagicalDefense), CalculateFlatStat(creature, Library::Statistic::MagicalDefense),
CalculateFlatStat(creature, Library::Statistic::Speed)); CalculateFlatStat(creature, Library::Statistic::Speed));
} }
Library::StatisticSet<uint32_t> Library::StatisticSet<u32> Battling::BattleStatCalculator::CalculateBoostedStats(Battling::Creature* creature) const {
Battling::BattleStatCalculator::CalculateBoostedStats(Battling::Creature* creature) const { return Library::StatisticSet<u32>(CalculateBoostedStat(creature, Library::Statistic::Health),
return Library::StatisticSet<uint32_t>(CalculateBoostedStat(creature, Library::Statistic::Health), CalculateBoostedStat(creature, Library::Statistic::PhysicalAttack),
CalculateBoostedStat(creature, Library::Statistic::PhysicalAttack), CalculateBoostedStat(creature, Library::Statistic::PhysicalDefense),
CalculateBoostedStat(creature, Library::Statistic::PhysicalDefense), CalculateBoostedStat(creature, Library::Statistic::MagicalAttack),
CalculateBoostedStat(creature, Library::Statistic::MagicalAttack), CalculateBoostedStat(creature, Library::Statistic::MagicalDefense),
CalculateBoostedStat(creature, Library::Statistic::MagicalDefense), CalculateBoostedStat(creature, Library::Statistic::Speed));
CalculateBoostedStat(creature, Library::Statistic::Speed));
} }
uint32_t CalculateHealthStat(Battling::Creature* creature) { u32 CalculateHealthStat(Battling::Creature* creature) {
EnsureNotNull(creature) EnsureNotNull(creature)
auto level = creature->GetLevel(); auto level = creature->GetLevel();
float a = (creature->GetBaseStat(Library::Statistic::Health)) * 2.0 * level; float a = (creature->GetBaseStat(Library::Statistic::Health)) * 2.0 * level;
return static_cast<uint32_t>(floor(a / 100.0) + level + 10); return static_cast<u32>(floor(a / 100.0) + level + 10);
} }
uint32_t CalculateOtherStat(Battling::Creature* creature, Library::Statistic stat) { u32 CalculateOtherStat(Battling::Creature* creature, Library::Statistic stat) {
EnsureNotNull(creature) EnsureNotNull(creature)
auto level = creature->GetLevel(); auto level = creature->GetLevel();
float a = (creature->GetBaseStat(stat)) * 2.0 * level; float a = (creature->GetBaseStat(stat)) * 2.0 * level;
return static_cast<uint32_t>(floor(a / 100.0) + 5); return static_cast<u32>(floor(a / 100.0) + 5);
} }
uint32_t Battling::BattleStatCalculator::CalculateFlatStat(Battling::Creature* creature, u32 Battling::BattleStatCalculator::CalculateFlatStat(Battling::Creature* creature, Library::Statistic stat) const {
Library::Statistic stat) const {
if (stat == Library::Statistic::Health) if (stat == Library::Statistic::Health)
return CalculateHealthStat(creature); return CalculateHealthStat(creature);
return CalculateOtherStat(creature, stat); return CalculateOtherStat(creature, stat);
} }
uint32_t Battling::BattleStatCalculator::CalculateBoostedStat(Battling::Creature* creature, u32 Battling::BattleStatCalculator::CalculateBoostedStat(Battling::Creature* creature, Library::Statistic stat) const {
Library::Statistic stat) const {
return creature->GetFlatStat(stat) + (creature->GetBoostedStat(stat)); return creature->GetFlatStat(stat) + (creature->GetBoostedStat(stat));
} }

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

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

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

@ -2,23 +2,23 @@
#include "../ScriptHandling/ScriptMacros.hpp" #include "../ScriptHandling/ScriptMacros.hpp"
using namespace CreatureLib::Battling; using namespace CreatureLib::Battling;
uint32_t DamageLibrary::GetDamage(ExecutingAttack* attack, Creature* target, uint8_t hitIndex, u32 DamageLibrary::GetDamage(ExecutingAttack* attack, Creature* target, u8 hitIndex,
const ExecutingAttack::HitData& hitData) const { const ExecutingAttack::HitData& hitData) const {
EnsureNotNull(attack) EnsureNotNull(attack)
EnsureNotNull(target) EnsureNotNull(target)
auto levelMod = static_cast<float>(2 * attack->GetUser()->GetLevel()) / 5 + 2; auto levelMod = static_cast<float>(2 * attack->GetUser()->GetLevel()) / 5 + 2;
auto bp = hitData.GetBasePower(); auto bp = hitData.GetBasePower();
auto statMod = GetStatModifier(attack, target, hitIndex, hitData); auto statMod = GetStatModifier(attack, target, hitIndex, hitData);
HOOK(ModifyStatModifier, attack, attack, target, hitIndex, &statMod); HOOK(ModifyStatModifier, attack, attack, target, hitIndex, &statMod);
uint32_t damage = static_cast<uint32_t>((((levelMod * static_cast<float>(bp) * statMod) / 50) + 2) * u32 damage = static_cast<u32>((((levelMod * static_cast<float>(bp) * statMod) / 50) + 2) *
GetDamageModifier(attack, target, hitIndex, hitData)); GetDamageModifier(attack, target, hitIndex, hitData));
HOOK(OverrideDamage, attack, attack, target, hitIndex, &damage); HOOK(OverrideDamage, attack, attack, target, hitIndex, &damage);
HOOK(OverrideIncomingDamage, target, attack, target, hitIndex, &damage); HOOK(OverrideIncomingDamage, target, attack, target, hitIndex, &damage);
return damage; return damage;
} }
uint8_t DamageLibrary::GetBasePower(ExecutingAttack* attack, Creature* target, uint8_t hitIndex, u8 DamageLibrary::GetBasePower(ExecutingAttack* attack, Creature* target, u8 hitIndex,
[[maybe_unused]] const ExecutingAttack::HitData& hitData) const { [[maybe_unused]] const ExecutingAttack::HitData& hitData) const {
EnsureNotNull(attack) EnsureNotNull(attack)
EnsureNotNull(target) EnsureNotNull(target)
auto bp = attack->GetUseAttack()->GetBasePower(); auto bp = attack->GetUseAttack()->GetBasePower();
@ -26,7 +26,7 @@ uint8_t DamageLibrary::GetBasePower(ExecutingAttack* attack, Creature* target, u
return bp; return bp;
} }
float DamageLibrary::GetStatModifier(ExecutingAttack* attack, Creature* target, uint8_t hitIndex, float DamageLibrary::GetStatModifier(ExecutingAttack* attack, Creature* target, u8 hitIndex,
const ExecutingAttack::HitData& hitData) const { const ExecutingAttack::HitData& hitData) const {
EnsureNotNull(attack) EnsureNotNull(attack)
EnsureNotNull(target) EnsureNotNull(target)
@ -65,7 +65,7 @@ float DamageLibrary::GetStatModifier(ExecutingAttack* attack, Creature* target,
return offensiveValue / defensiveValue; return offensiveValue / defensiveValue;
} }
float DamageLibrary::GetDamageModifier(ExecutingAttack* attack, Creature* target, uint8_t hitIndex, float DamageLibrary::GetDamageModifier(ExecutingAttack* attack, Creature* target, u8 hitIndex,
const ExecutingAttack::HitData& hitData) const { const ExecutingAttack::HitData& hitData) const {
EnsureNotNull(attack) EnsureNotNull(attack)
EnsureNotNull(target) EnsureNotNull(target)

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

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

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

@ -13,6 +13,6 @@ void CreatureLib::Battling::ExperienceLibrary::HandleExperienceGain(
if (levelDiff <= 0) if (levelDiff <= 0)
continue; continue;
auto experienceGain = levelDiff * 10; auto experienceGain = levelDiff * 10;
opponent->AddExperience(static_cast<uint32_t>(experienceGain)); opponent->AddExperience(static_cast<u32>(experienceGain));
} }
} }

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

@ -4,7 +4,7 @@
bool CreatureLib::Battling::MiscLibrary::IsCritical([[maybe_unused]] CreatureLib::Battling::ExecutingAttack* attack, bool CreatureLib::Battling::MiscLibrary::IsCritical([[maybe_unused]] CreatureLib::Battling::ExecutingAttack* attack,
CreatureLib::Battling::Creature* target, CreatureLib::Battling::Creature* target,
[[maybe_unused]] uint8_t hit) const { [[maybe_unused]] u8 hit) const {
EnsureNotNull(target) EnsureNotNull(target)
Ensure(target->GetBattle().HasValue()) Ensure(target->GetBattle().HasValue())
auto rand = target->GetBattle().GetValue()->GetRandom(); auto rand = target->GetBattle().GetValue()->GetRandom();

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

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

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

@ -62,7 +62,7 @@ void Battle::CheckChoicesSetAndRun() {
EnsureNotNull(choice) EnsureNotNull(choice)
if (choice->GetKind() == TurnChoiceKind::Attack) { if (choice->GetKind() == TurnChoiceKind::Attack) {
auto attack = std::static_pointer_cast<AttackTurnChoice>(choice); auto attack = std::static_pointer_cast<AttackTurnChoice>(choice);
uint8_t uses = 1; u8 uses = 1;
// HOOK: change number of uses needed. // HOOK: change number of uses needed.
if (attack->GetAttack()->GetRemainingUses() < uses) { if (attack->GetAttack()->GetRemainingUses() < uses) {
choice = std::shared_ptr<BaseTurnChoice>(_library->GetMiscLibrary()->ReplacementAttack( choice = std::shared_ptr<BaseTurnChoice>(_library->GetMiscLibrary()->ReplacementAttack(
@ -110,19 +110,19 @@ bool Battle::CreatureInField(ArbUt::BorrowedPtr<Creature> creature) const {
return std::any_of(_sides.begin(), _sides.end(), [creature](auto c) { return c->CreatureOnSide(creature); }); return std::any_of(_sides.begin(), _sides.end(), [creature](auto c) { return c->CreatureOnSide(creature); });
} }
void Battle::ForceRecall(uint8_t side, uint8_t index) { _sides[side]->SetCreature(nullptr, index); } void Battle::ForceRecall(u8 side, u8 index) { _sides[side]->SetCreature(nullptr, index); }
size_t Battle::ScriptCount() const { return 1; } size_t Battle::ScriptCount() const { return 1; }
void Battle::GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) { GetOwnScripts(scripts); } void Battle::GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) { GetOwnScripts(scripts); }
void Battle::GetOwnScripts(ArbUt::List<ScriptWrapper>& scripts) { scripts.Append(ScriptWrapper::FromSet(&_volatile)); } void Battle::GetOwnScripts(ArbUt::List<ScriptWrapper>& scripts) { scripts.Append(ScriptWrapper::FromSet(&_volatile)); }
void Battle::SwitchCreature(uint8_t sideIndex, uint8_t index, Creature* c) { void Battle::SwitchCreature(u8 sideIndex, u8 index, Creature* c) {
auto side = this->_sides[sideIndex]; auto side = this->_sides[sideIndex];
side->SetCreature(c, index); side->SetCreature(c, index);
} }
bool Battle::CanSlotBeFilled(uint8_t side, uint8_t index) const { bool Battle::CanSlotBeFilled(u8 side, u8 index) const {
for (const auto& party : _parties) { for (const auto& party : _parties) {
if (party->IsResponsibleForIndex(side, index)) { if (party->IsResponsibleForIndex(side, index)) {
if (party->HasCreaturesNotInField()) if (party->HasCreaturesNotInField())
@ -137,8 +137,8 @@ void Battle::ValidateBattleState() {
return; return;
} }
bool survivingSideExists = false; bool survivingSideExists = false;
uint8_t winningSide = 255; u8 winningSide = 255;
for (uint8_t i = 0; i < _sides.Count(); i++) { for (u8 i = 0; i < _sides.Count(); i++) {
auto side = _sides[i]; auto side = _sides[i];
if (side->HasFled()) { if (side->HasFled()) {
this->_battleResult = BattleResult::Inconclusive(); this->_battleResult = BattleResult::Inconclusive();
@ -200,8 +200,8 @@ Battle* Battle::Clone() const {
continue; continue;
} }
auto partyIndex = party->GetParty()->GetParty().IndexOf(creature.GetValue()); auto partyIndex = party->GetParty()->GetParty().IndexOf(creature.GetValue());
if (partyIndex != -1U) { if (partyIndex.has_value()) {
auto c = battle->_parties.At(j)->GetParty()->GetParty()[partyIndex]; auto c = battle->_parties.At(j)->GetParty()->GetParty()[partyIndex.value()];
battle->_sides.At(i)->SetCreature(c, creatureIndex); battle->_sides.At(i)->SetCreature(c, creatureIndex);
j = _parties.Count(); j = _parties.Count();
break; break;

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

@ -18,8 +18,8 @@ namespace CreatureLib::Battling {
ArbUt::BorrowedPtr<const BattleLibrary> _library; ArbUt::BorrowedPtr<const BattleLibrary> _library;
ArbUt::UniquePtrList<BattleParty> _parties; ArbUt::UniquePtrList<BattleParty> _parties;
bool _canFlee; bool _canFlee;
uint8_t _numberOfSides; u8 _numberOfSides;
uint8_t _creaturesPerSide; u8 _creaturesPerSide;
ArbUt::UniquePtrList<BattleSide> _sides; ArbUt::UniquePtrList<BattleSide> _sides;
BattleRandom _random; BattleRandom _random;
std::unique_ptr<ChoiceQueue> _currentTurnQueue = nullptr; std::unique_ptr<ChoiceQueue> _currentTurnQueue = nullptr;
@ -28,14 +28,14 @@ namespace CreatureLib::Battling {
EventHook _eventHook; EventHook _eventHook;
ArbUt::UniquePtr<HistoryHolder> _historyHolder = new HistoryHolder([this]() { return GetCurrentTurn(); }); ArbUt::UniquePtr<HistoryHolder> _historyHolder = new HistoryHolder([this]() { return GetCurrentTurn(); });
uint32_t _currentTurn = 0; u32 _currentTurn = 0;
ScriptSet _volatile; ScriptSet _volatile;
long _lastTurnTime; long _lastTurnTime;
public: public:
Battle(const BattleLibrary* library, ArbUt::List<BattleParty*> parties, bool canFlee = true, Battle(const BattleLibrary* library, ArbUt::List<BattleParty*> parties, bool canFlee = true,
uint8_t numberOfSides = 2, uint8_t creaturesPerSide = 1, u8 numberOfSides = 2, u8 creaturesPerSide = 1,
uint_fast32_t randomSeed = std::chrono::duration_cast<std::chrono::milliseconds>( uint_fast32_t randomSeed = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch()) std::chrono::system_clock::now().time_since_epoch())
.count()) .count())
@ -51,8 +51,8 @@ namespace CreatureLib::Battling {
virtual ~Battle() { ClearBattle(); } virtual ~Battle() { ClearBattle(); }
[[nodiscard]] const ArbUt::BorrowedPtr<const BattleLibrary>& GetLibrary() const noexcept; [[nodiscard]] const ArbUt::BorrowedPtr<const BattleLibrary>& GetLibrary() const noexcept;
[[nodiscard]] uint32_t GetCurrentTurn() const noexcept { return _currentTurn; } [[nodiscard]] u32 GetCurrentTurn() const noexcept { return _currentTurn; }
inline uint8_t GetCreaturesPerSide() const noexcept { return _creaturesPerSide; } inline u8 GetCreaturesPerSide() const noexcept { return _creaturesPerSide; }
virtual bool CanUse(const ArbUt::BorrowedPtr<BaseTurnChoice>& choice); virtual bool CanUse(const ArbUt::BorrowedPtr<BaseTurnChoice>& choice);
virtual bool TrySetChoice(BaseTurnChoice* choice); virtual bool TrySetChoice(BaseTurnChoice* choice);
@ -69,13 +69,13 @@ namespace CreatureLib::Battling {
const ArbUt::OptionalBorrowedPtr<Creature>& GetCreature(const CreatureIndex& target) const { const ArbUt::OptionalBorrowedPtr<Creature>& GetCreature(const CreatureIndex& target) const {
return _sides[target.GetSideIndex()]->GetCreature(target.GetCreatureIndex()); return _sides[target.GetSideIndex()]->GetCreature(target.GetCreatureIndex());
} }
const ArbUt::OptionalBorrowedPtr<Creature>& GetCreature(uint8_t side, uint8_t target) const { const ArbUt::OptionalBorrowedPtr<Creature>& GetCreature(u8 side, u8 target) const {
return _sides[side]->GetCreature(target); return _sides[side]->GetCreature(target);
} }
void ForceRecall(uint8_t side, uint8_t index); void ForceRecall(u8 side, u8 index);
void SwitchCreature(uint8_t side, uint8_t index, Creature* c); void SwitchCreature(u8 side, u8 index, Creature* c);
bool CanSlotBeFilled(uint8_t side, uint8_t index) const; bool CanSlotBeFilled(u8 side, u8 index) const;
size_t ScriptCount() const override; size_t ScriptCount() const override;
void GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) override; void GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) override;
@ -93,16 +93,16 @@ namespace CreatureLib::Battling {
ArbUt::OptionalBorrowedPtr<BattleScript> GetVolatileScript(const ArbUt::StringView& key) const { ArbUt::OptionalBorrowedPtr<BattleScript> GetVolatileScript(const ArbUt::StringView& key) const {
return _volatile.Get(key); return _volatile.Get(key);
} }
ArbUt::OptionalBorrowedPtr<BattleScript> GetVolatileScript(uint32_t keyHash) const noexcept { ArbUt::OptionalBorrowedPtr<BattleScript> GetVolatileScript(u32 keyHash) const noexcept {
return _volatile.Get(keyHash); return _volatile.Get(keyHash);
} }
BattleScript* AddVolatileScript(const ArbUt::StringView& key); BattleScript* AddVolatileScript(const ArbUt::StringView& key);
BattleScript* AddVolatileScript(BattleScript* script); BattleScript* AddVolatileScript(BattleScript* script);
void RemoveVolatileScript(const ArbUt::BasicStringView& name) { _volatile.Remove(name); } void RemoveVolatileScript(const ArbUt::BasicStringView& name) { _volatile.Remove(name); }
void RemoveVolatileScript(uint32_t keyHash) { _volatile.Remove(keyHash); } void RemoveVolatileScript(u32 keyHash) { _volatile.Remove(keyHash); }
void RemoveVolatileScript(BattleScript* script); void RemoveVolatileScript(BattleScript* script);
bool HasVolatileScript(const ArbUt::BasicStringView& name) const { return _volatile.Has(name); } bool HasVolatileScript(const ArbUt::BasicStringView& name) const { return _volatile.Has(name); }
bool HasVolatileScript(uint32_t keyHash) const { return _volatile.Has(keyHash); } bool HasVolatileScript(u32 keyHash) const { return _volatile.Has(keyHash); }
void DisplayText(const ArbUt::StringView& text); void DisplayText(const ArbUt::StringView& text);

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

@ -22,7 +22,7 @@ namespace CreatureLib::Battling {
return _responsibleIndices.Contains(index); return _responsibleIndices.Contains(index);
} }
inline bool IsResponsibleForIndex(uint8_t side, uint8_t index) const { inline bool IsResponsibleForIndex(u8 side, u8 index) const {
return std::any_of(_responsibleIndices.begin(), _responsibleIndices.end(), return std::any_of(_responsibleIndices.begin(), _responsibleIndices.end(),
[side, index](const CreatureIndex& ci) { [side, index](const CreatureIndex& ci) {
return ci.GetSideIndex() == side && ci.GetCreatureIndex() == index; return ci.GetSideIndex() == side && ci.GetCreatureIndex() == index;

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

@ -16,9 +16,9 @@ namespace CreatureLib::Battling {
explicit BattleRandom(uint_fast32_t seed) noexcept : _random(seed) {} explicit BattleRandom(uint_fast32_t seed) noexcept : _random(seed) {}
bool EffectChance(float chance, ExecutingAttack* attack, Creature* target); bool EffectChance(float chance, ExecutingAttack* attack, Creature* target);
int32_t Get() noexcept { return _random.Get(); } i32 Get() noexcept { return _random.Get(); }
int32_t Get(int32_t max) noexcept { return _random.Get(max); } i32 Get(i32 max) noexcept { return _random.Get(max); }
int32_t Get(int32_t min, int32_t max) noexcept { return _random.Get(min, max); } i32 Get(i32 min, i32 max) noexcept { return _random.Get(min, max); }
ArbUt::Random& GetRNG() noexcept { return _random; } ArbUt::Random& GetRNG() noexcept { return _random; }
uint_fast32_t GetSeed() const noexcept { return _random.GetSeed(); } uint_fast32_t GetSeed() const noexcept { return _random.GetSeed(); }
}; };

8
src/Battling/Models/BattleResult.hpp
View File

@ -4,20 +4,20 @@
namespace CreatureLib::Battling { namespace CreatureLib::Battling {
class BattleResult { class BattleResult {
bool _conclusiveResult; bool _conclusiveResult;
uint8_t _winningSide; u8 _winningSide;
BattleResult(bool conclusiveResult, uint8_t winningSide) BattleResult(bool conclusiveResult, u8 winningSide)
: _conclusiveResult(conclusiveResult), _winningSide(winningSide) {} : _conclusiveResult(conclusiveResult), _winningSide(winningSide) {}
public: public:
static BattleResult Inconclusive() { return BattleResult(false, 0); } static BattleResult Inconclusive() { return BattleResult(false, 0); }
static BattleResult Conclusive(uint8_t winner) { return BattleResult(true, winner); } static BattleResult Conclusive(u8 winner) { return BattleResult(true, winner); }
static BattleResult Empty() { return BattleResult(false, 0); } static BattleResult Empty() { return BattleResult(false, 0); }
/// Whether or not the battle has ended with a conclusive result. /// Whether or not the battle has ended with a conclusive result.
bool IsConclusiveResult() const noexcept { return _conclusiveResult; } bool IsConclusiveResult() const noexcept { return _conclusiveResult; }
/// Get the index of the side that has won the battle. Only valid if the battle has a conclusive result. /// Get the index of the side that has won the battle. Only valid if the battle has a conclusive result.
uint8_t GetWinningSide() const noexcept { return _winningSide; } u8 GetWinningSide() const noexcept { return _winningSide; }
}; };
} }

8
src/Battling/Models/BattleSide.cpp
View File

@ -25,7 +25,7 @@ bool BattleSide::AllPossibleSlotsFilled() const {
void BattleSide::ResetChoices() noexcept { void BattleSide::ResetChoices() noexcept {
_choicesSet = 0; _choicesSet = 0;
for (uint8_t i = 0; i < _creaturesPerSide; i++) { for (u8 i = 0; i < _creaturesPerSide; i++) {
_choices[i] = nullptr; _choices[i] = nullptr;
} }
} }
@ -50,7 +50,7 @@ void BattleSide::SetChoice(BaseTurnChoice* choice) {
THROW("User not found"); THROW("User not found");
} }
void BattleSide::SetCreature(ArbUt::OptionalBorrowedPtr<Creature> creature, uint8_t index) { void BattleSide::SetCreature(ArbUt::OptionalBorrowedPtr<Creature> creature, u8 index) {
auto old = _creatures[index]; auto old = _creatures[index];
if (old.HasValue()) { if (old.HasValue()) {
HOOK(OnRemove, old.GetValue()); HOOK(OnRemove, old.GetValue());
@ -82,7 +82,7 @@ bool BattleSide::CreatureOnSide(const ArbUt::BorrowedPtr<Creature>& creature) co
return std::find(_creatures.begin(), _creatures.end(), creature.GetRaw()) != _creatures.end(); return std::find(_creatures.begin(), _creatures.end(), creature.GetRaw()) != _creatures.end();
} }
const ArbUt::OptionalBorrowedPtr<Creature>& BattleSide::GetCreature(uint8_t index) const { return _creatures[index]; } const ArbUt::OptionalBorrowedPtr<Creature>& BattleSide::GetCreature(u8 index) const { return _creatures[index]; }
void BattleSide::GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) { void BattleSide::GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) {
GetOwnScripts(scripts); GetOwnScripts(scripts);
@ -93,7 +93,7 @@ void BattleSide::GetOwnScripts(ArbUt::List<ScriptWrapper>& scripts) {
} }
size_t BattleSide::ScriptCount() const { return _battle->ScriptCount() + 1; } size_t BattleSide::ScriptCount() const { return _battle->ScriptCount() + 1; }
uint8_t BattleSide::GetRandomCreatureIndex() { u8 BattleSide::GetRandomCreatureIndex() {
// TODO: Consider adding parameter to only get index for available creatures. // TODO: Consider adding parameter to only get index for available creatures.
return _battle->GetRandom()->Get(_creaturesPerSide); return _battle->GetRandom()->Get(_creaturesPerSide);
} }

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

@ -6,18 +6,18 @@
namespace CreatureLib::Battling { namespace CreatureLib::Battling {
class BattleSide : public ScriptSource { class BattleSide : public ScriptSource {
uint8_t _index; u8 _index;
uint8_t _creaturesPerSide; u8 _creaturesPerSide;
ArbUt::List<ArbUt::OptionalBorrowedPtr<Creature>> _creatures; ArbUt::List<ArbUt::OptionalBorrowedPtr<Creature>> _creatures;
ArbUt::List<std::shared_ptr<BaseTurnChoice>> _choices; ArbUt::List<std::shared_ptr<BaseTurnChoice>> _choices;
ArbUt::List<bool> _fillableSlots; ArbUt::List<bool> _fillableSlots;
uint8_t _choicesSet = 0; u8 _choicesSet = 0;
ScriptSet _volatile; ScriptSet _volatile;
ArbUt::BorrowedPtr<Battle> _battle; ArbUt::BorrowedPtr<Battle> _battle;
bool _hasFled = false; bool _hasFled = false;
public: public:
BattleSide(uint8_t index, ArbUt::BorrowedPtr<Battle> battle, uint8_t creaturesPerSide) noexcept BattleSide(u8 index, ArbUt::BorrowedPtr<Battle> battle, u8 creaturesPerSide) noexcept
: _index(index), _creaturesPerSide(creaturesPerSide), _creatures(creaturesPerSide), : _index(index), _creaturesPerSide(creaturesPerSide), _creatures(creaturesPerSide),
_choices(creaturesPerSide), _fillableSlots(creaturesPerSide), _battle(battle) { _choices(creaturesPerSide), _fillableSlots(creaturesPerSide), _battle(battle) {
for (size_t i = 0; i < creaturesPerSide; i++) { for (size_t i = 0; i < creaturesPerSide; i++) {
@ -42,10 +42,10 @@ namespace CreatureLib::Battling {
void SetChoice(BaseTurnChoice* choice); void SetChoice(BaseTurnChoice* choice);
void ResetChoices() noexcept; void ResetChoices() noexcept;
void ForceClearCreature(uint8_t index) { _creatures[index] = {}; } void ForceClearCreature(u8 index) { _creatures[index] = {}; }
void SetCreature(ArbUt::OptionalBorrowedPtr<Creature> creature, uint8_t index); void SetCreature(ArbUt::OptionalBorrowedPtr<Creature> creature, u8 index);
const ArbUt::OptionalBorrowedPtr<Creature>& GetCreature(uint8_t index) const; const ArbUt::OptionalBorrowedPtr<Creature>& GetCreature(u8 index) const;
bool CreatureOnSide(const ArbUt::BorrowedPtr<Creature>& creature) const; bool CreatureOnSide(const ArbUt::BorrowedPtr<Creature>& creature) const;
size_t ScriptCount() const override; size_t ScriptCount() const override;
@ -56,8 +56,8 @@ namespace CreatureLib::Battling {
const ArbUt::OptionalBorrowedPtr<Creature>& GetCreature(u8 index) { return _creatures[index]; } const ArbUt::OptionalBorrowedPtr<Creature>& GetCreature(u8 index) { return _creatures[index]; }
uint8_t GetSideIndex() noexcept { return _index; } u8 GetSideIndex() noexcept { return _index; }
uint8_t GetCreatureIndex(const ArbUt::BorrowedPtr<Creature>& c) { u8 GetCreatureIndex(const ArbUt::BorrowedPtr<Creature>& c) {
for (size_t i = 0; i < _creatures.Count(); i++) { for (size_t i = 0; i < _creatures.Count(); i++) {
if (!_creatures[i].HasValue()) if (!_creatures[i].HasValue())
continue; continue;
@ -68,7 +68,7 @@ namespace CreatureLib::Battling {
} }
void MarkSlotAsUnfillable(const ArbUt::BorrowedPtr<Creature>& creature) noexcept { void MarkSlotAsUnfillable(const ArbUt::BorrowedPtr<Creature>& creature) noexcept {
for (uint8_t i = 0; i < _creaturesPerSide; i++) { for (u8 i = 0; i < _creaturesPerSide; i++) {
if (!_creatures[i].HasValue()) if (!_creatures[i].HasValue())
continue; continue;
if (_creatures[i].GetValue() == creature) { if (_creatures[i].GetValue() == creature) {
@ -90,7 +90,7 @@ namespace CreatureLib::Battling {
void MarkAsFled() noexcept { _hasFled = true; } void MarkAsFled() noexcept { _hasFled = true; }
uint8_t GetRandomCreatureIndex(); u8 GetRandomCreatureIndex();
bool SwapPositions(u8 a, u8 b); bool SwapPositions(u8 a, u8 b);
@ -99,16 +99,16 @@ namespace CreatureLib::Battling {
ArbUt::OptionalBorrowedPtr<BattleScript> GetVolatileScript(const ArbUt::StringView& key) const { ArbUt::OptionalBorrowedPtr<BattleScript> GetVolatileScript(const ArbUt::StringView& key) const {
return _volatile.Get(key); return _volatile.Get(key);
} }
ArbUt::OptionalBorrowedPtr<BattleScript> GetVolatileScript(uint32_t keyHash) const noexcept { ArbUt::OptionalBorrowedPtr<BattleScript> GetVolatileScript(u32 keyHash) const noexcept {
return _volatile.Get(keyHash); return _volatile.Get(keyHash);
} }
BattleScript* AddVolatileScript(const ArbUt::StringView& key); BattleScript* AddVolatileScript(const ArbUt::StringView& key);
BattleScript* AddVolatileScript(BattleScript* script); BattleScript* AddVolatileScript(BattleScript* script);
void RemoveVolatileScript(const ArbUt::BasicStringView& name) { _volatile.Remove(name); } void RemoveVolatileScript(const ArbUt::BasicStringView& name) { _volatile.Remove(name); }
void RemoveVolatileScript(uint32_t keyHash) { _volatile.Remove(keyHash); } void RemoveVolatileScript(u32 keyHash) { _volatile.Remove(keyHash); }
void RemoveVolatileScript(BattleScript* script); void RemoveVolatileScript(BattleScript* script);
bool HasVolatileScript(const ArbUt::BasicStringView& name) const { return _volatile.Has(name); } bool HasVolatileScript(const ArbUt::BasicStringView& name) const { return _volatile.Has(name); }
bool HasVolatileScript(uint32_t keyHash) const { return _volatile.Has(keyHash); } bool HasVolatileScript(u32 keyHash) const { return _volatile.Has(keyHash); }
}; };
} }

8
src/Battling/Models/CreateCreature.hpp
View File

@ -10,18 +10,18 @@ namespace CreatureLib::Battling {
ArbUt::BorrowedPtr<const BattleLibrary> _library; ArbUt::BorrowedPtr<const BattleLibrary> _library;
ArbUt::StringView _species; ArbUt::StringView _species;
ArbUt::StringView _variant = "default"_cnc; ArbUt::StringView _variant = "default"_cnc;
uint8_t _level; u8 _level;
std::optional<std::string> _nickname = ""; std::optional<std::string> _nickname = "";
ArbUt::StringView _talent = ""_cnc; ArbUt::StringView _talent = ""_cnc;
Library::Gender _gender = static_cast<Library::Gender>(-1); Library::Gender _gender = static_cast<Library::Gender>(-1);
uint8_t _coloring = 0; u8 _coloring = 0;
ArbUt::StringView _heldItem = ""_cnc; ArbUt::StringView _heldItem = ""_cnc;
uint32_t _identifier = 0; u32 _identifier = 0;
ArbUt::List<std::tuple<ArbUt::BorrowedPtr<const Library::AttackData>, AttackLearnMethod>> _attacks; ArbUt::List<std::tuple<ArbUt::BorrowedPtr<const Library::AttackData>, AttackLearnMethod>> _attacks;
public: public:
CreateCreature(ArbUt::BorrowedPtr<const BattleLibrary> library, const ArbUt::StringView& species, uint8_t level) CreateCreature(ArbUt::BorrowedPtr<const BattleLibrary> library, const ArbUt::StringView& species, u8 level)
: _library(library), _species(species), _level(level), : _library(library), _species(species), _level(level),
_attacks(library->GetSettings()->GetMaximalAttacks()) {} _attacks(library->GetSettings()->GetMaximalAttacks()) {}

26
src/Battling/Models/Creature.cpp
View File

@ -12,7 +12,7 @@ namespace CreatureLib::Battling {
Creature::Creature(const ArbUt::BorrowedPtr<const BattleLibrary>& library, Creature::Creature(const ArbUt::BorrowedPtr<const BattleLibrary>& library,
const ArbUt::BorrowedPtr<const Library::CreatureSpecies>& species, const ArbUt::BorrowedPtr<const Library::CreatureSpecies>& species,
const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant, level_int_t level, const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant, level_int_t level,
uint32_t experience, uint32_t uid, Library::Gender gender, uint8_t coloring, u32 experience, u32 uid, Library::Gender gender, u8 coloring,
ArbUt::OptionalBorrowedPtr<const Library::Item> heldItem, std::optional<std::string> nickname, ArbUt::OptionalBorrowedPtr<const Library::Item> heldItem, std::optional<std::string> nickname,
const Library::TalentIndex& talent, const std::vector<LearnedAttack*>& attacks, const Library::TalentIndex& talent, const std::vector<LearnedAttack*>& attacks,
bool allowedExperienceGain) bool allowedExperienceGain)
@ -91,8 +91,8 @@ namespace CreatureLib::Battling {
// We modify the health of the creature by the change in its max health. // We modify the health of the creature by the change in its max health.
auto prevHealth = GetBoostedStat(CreatureLib::Library::Statistic::Health); auto prevHealth = GetBoostedStat(CreatureLib::Library::Statistic::Health);
RecalculateFlatStats(); RecalculateFlatStats();
int32_t diffHealth = GetBoostedStat(CreatureLib::Library::Statistic::Health) - prevHealth; i32 diffHealth = GetBoostedStat(CreatureLib::Library::Statistic::Health) - prevHealth;
if (_currentHealth < static_cast<uint32_t>(INT32_MAX) && static_cast<int32_t>(_currentHealth) < -diffHealth) { if (_currentHealth < static_cast<u32>(INT32_MAX) && static_cast<i32>(_currentHealth) < -diffHealth) {
_currentHealth = 0; _currentHealth = 0;
} else { } else {
_currentHealth += diffHealth; _currentHealth += diffHealth;
@ -105,7 +105,7 @@ namespace CreatureLib::Battling {
} }
} }
void Creature::ChangeLevelBy(int8_t amount) { void Creature::ChangeLevelBy(i8 amount) {
auto level = _level + amount; auto level = _level + amount;
if (level > _library->GetSettings()->GetMaximalLevel()) if (level > _library->GetSettings()->GetMaximalLevel())
level = _library->GetSettings()->GetMaximalLevel(); level = _library->GetSettings()->GetMaximalLevel();
@ -149,7 +149,7 @@ namespace CreatureLib::Battling {
} }
} }
bool Creature::ChangeStatBoost(Library::Statistic stat, int8_t diffAmount, bool selfInflicted) { bool Creature::ChangeStatBoost(Library::Statistic stat, i8 diffAmount, bool selfInflicted) {
bool preventStatChange = false; bool preventStatChange = false;
HOOK(PreventStatBoostChange, this, this, stat, diffAmount, selfInflicted, &preventStatChange); HOOK(PreventStatBoostChange, this, this, stat, diffAmount, selfInflicted, &preventStatChange);
if (preventStatChange) { if (preventStatChange) {
@ -218,7 +218,7 @@ namespace CreatureLib::Battling {
} }
} }
void Creature::Damage(uint32_t damage, DamageSource source) { void Creature::Damage(u32 damage, DamageSource source) {
if (damage > _currentHealth) { if (damage > _currentHealth) {
damage = _currentHealth; damage = _currentHealth;
} }
@ -238,7 +238,7 @@ namespace CreatureLib::Battling {
} }
} }
void Creature::Heal(uint32_t amount, bool canRevive) { void Creature::Heal(u32 amount, bool canRevive) {
if (_currentHealth == 0 && !canRevive) { if (_currentHealth == 0 && !canRevive) {
return; return;
} }
@ -271,9 +271,9 @@ namespace CreatureLib::Battling {
_overridenTalent = _library->GetStaticLib()->GetTalentLibrary()->Get(talent); _overridenTalent = _library->GetStaticLib()->GetTalentLibrary()->Get(talent);
} }
const std::vector<uint8_t>& Creature::GetTypes() const noexcept { return _types; } const std::vector<u8>& Creature::GetTypes() const noexcept { return _types; }
bool Creature::HasType(uint8_t type) const noexcept { bool Creature::HasType(u8 type) const noexcept {
return std::find(_types.begin(), _types.end(), type) != _types.end(); return std::find(_types.begin(), _types.end(), type) != _types.end();
} }
@ -307,7 +307,7 @@ namespace CreatureLib::Battling {
} }
void Creature::ClearVolatileScripts() { _volatile.Clear(); } void Creature::ClearVolatileScripts() { _volatile.Clear(); }
void Creature::AddExperience(uint32_t amount) { void Creature::AddExperience(u32 amount) {
auto maxLevel = _library->GetSettings()->GetMaximalLevel(); auto maxLevel = _library->GetSettings()->GetMaximalLevel();
if (_level >= maxLevel) { if (_level >= maxLevel) {
return; return;
@ -347,7 +347,7 @@ namespace CreatureLib::Battling {
_heldItem = v.value(); _heldItem = v.value();
} }
} }
void Creature::SetHeldItem(uint32_t itemNameHash) { void Creature::SetHeldItem(u32 itemNameHash) {
if (itemNameHash == ArbUt::StringView::CalculateHash("")) { if (itemNameHash == ArbUt::StringView::CalculateHash("")) {
_heldItem = {}; _heldItem = {};
_heldItemTriggerScript = {}; _heldItemTriggerScript = {};
@ -415,8 +415,8 @@ namespace CreatureLib::Battling {
} }
THROW("Can't add attack. The creature already has the maximum amount of attacks."); THROW("Can't add attack. The creature already has the maximum amount of attacks.");
} }
uint8_t Creature::GetAvailableAttackSlot() const noexcept { u8 Creature::GetAvailableAttackSlot() const noexcept {
for (uint8_t i = 0; i < (uint8_t)_attacks.Count(); i++) { for (u8 i = 0; i < (u8)_attacks.Count(); i++) {
if (_attacks[i] == nullptr) { if (_attacks[i] == nullptr) {
return i; return i;
} }

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

@ -29,19 +29,19 @@ namespace CreatureLib::Battling {
ArbUt::OptionalBorrowedPtr<const Library::SpeciesVariant> _displayVariant = nullptr; ArbUt::OptionalBorrowedPtr<const Library::SpeciesVariant> _displayVariant = nullptr;
level_int_t _level; level_int_t _level;
uint32_t _experience; u32 _experience;
uint32_t _uniqueIdentifier; u32 _uniqueIdentifier;
Library::Gender _gender; Library::Gender _gender;
uint8_t _coloring; u8 _coloring;
uint32_t _currentHealth = -1; u32 _currentHealth = -1;
f32 _weight; f32 _weight;
f32 _height; f32 _height;
Library::ClampedStatisticSet<int8_t, -6, 6> _statBoost; Library::ClampedStatisticSet<i8, -6, 6> _statBoost;
Library::StatisticSet<uint32_t> _flatStats; Library::StatisticSet<u32> _flatStats;
Library::StatisticSet<uint32_t> _boostedStats; Library::StatisticSet<u32> _boostedStats;
struct BattleData { struct BattleData {
bool OnBattleField = false; bool OnBattleField = false;
@ -75,11 +75,10 @@ namespace CreatureLib::Battling {
public: public:
Creature(const ArbUt::BorrowedPtr<const BattleLibrary>& library, Creature(const ArbUt::BorrowedPtr<const BattleLibrary>& library,
const ArbUt::BorrowedPtr<const Library::CreatureSpecies>& species, const ArbUt::BorrowedPtr<const Library::CreatureSpecies>& species,
const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant, level_int_t level, const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant, level_int_t level, u32 experience,
uint32_t experience, uint32_t uid, Library::Gender gender, uint8_t coloring, u32 uid, Library::Gender gender, u8 coloring, ArbUt::OptionalBorrowedPtr<const Library::Item> heldItem,
ArbUt::OptionalBorrowedPtr<const Library::Item> heldItem, std::optional<std::string> nickname, std::optional<std::string> nickname, const Library::TalentIndex& talent,
const Library::TalentIndex& talent, const std::vector<LearnedAttack*>& attacks, const std::vector<LearnedAttack*>& attacks, bool allowedExperienceGain = true);
bool allowedExperienceGain = true);
virtual ~Creature(); virtual ~Creature();
@ -98,23 +97,23 @@ namespace CreatureLib::Battling {
virtual void ChangeVariant(const ArbUt::StringView& variantName); virtual void ChangeVariant(const ArbUt::StringView& variantName);
virtual void ChangeVariant(const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant); virtual void ChangeVariant(const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant);
inline level_int_t GetLevel() const noexcept { return _level; } inline level_int_t GetLevel() const noexcept { return _level; }
inline uint32_t GetExperience() const noexcept { return _experience; } inline u32 GetExperience() const noexcept { return _experience; }
inline uint32_t GetUniqueIdentifier() const noexcept { return _uniqueIdentifier; } inline u32 GetUniqueIdentifier() const noexcept { return _uniqueIdentifier; }
inline Library::Gender GetGender() const noexcept { return _gender; } inline Library::Gender GetGender() const noexcept { return _gender; }
inline uint8_t GetColoring() const noexcept { return _coloring; } inline u8 GetColoring() const noexcept { return _coloring; }
inline bool HasHeldItem(const ArbUt::BasicStringView& name) const noexcept { inline bool HasHeldItem(const ArbUt::BasicStringView& name) const noexcept {
return _heldItem.HasValue() && _heldItem.GetValue()->GetName() == name; return _heldItem.HasValue() && _heldItem.GetValue()->GetName() == name;
} }
inline bool HasHeldItem(uint32_t nameHash) const noexcept { inline bool HasHeldItem(u32 nameHash) const noexcept {
return _heldItem.HasValue() && _heldItem.GetValue()->GetName() == nameHash; return _heldItem.HasValue() && _heldItem.GetValue()->GetName() == nameHash;
} }
inline const ArbUt::OptionalBorrowedPtr<const Library::Item>& GetHeldItem() const noexcept { return _heldItem; } inline const ArbUt::OptionalBorrowedPtr<const Library::Item>& GetHeldItem() const noexcept { return _heldItem; }
void SetHeldItem(const ArbUt::BasicStringView& itemName); void SetHeldItem(const ArbUt::BasicStringView& itemName);
void SetHeldItem(uint32_t itemNameHash); void SetHeldItem(u32 itemNameHash);
inline void SetHeldItem(const ArbUt::BorrowedPtr<const Library::Item>& item) noexcept { _heldItem = item; }; inline void SetHeldItem(const ArbUt::BorrowedPtr<const Library::Item>& item) noexcept { _heldItem = item; };
bool ConsumeHeldItem(); bool ConsumeHeldItem();
inline uint32_t GetCurrentHealth() const noexcept { return _currentHealth; } inline u32 GetCurrentHealth() const noexcept { return _currentHealth; }
inline f32 GetWeight() const noexcept { return _weight; } inline f32 GetWeight() const noexcept { return _weight; }
inline void SetWeight(f32 weight) noexcept { inline void SetWeight(f32 weight) noexcept {
@ -154,17 +153,17 @@ namespace CreatureLib::Battling {
/// Are we allowed to use this creature in a battle? /// Are we allowed to use this creature in a battle?
[[nodiscard]] virtual bool IsUsable() const noexcept; [[nodiscard]] virtual bool IsUsable() const noexcept;
[[nodiscard]] bool IsFainted() const noexcept; [[nodiscard]] bool IsFainted() const noexcept;
[[nodiscard]] const std::vector<uint8_t>& GetTypes() const noexcept; [[nodiscard]] const std::vector<u8>& GetTypes() const noexcept;
[[nodiscard]] bool HasType(uint8_t type) const noexcept; [[nodiscard]] bool HasType(u8 type) const noexcept;
void SetType(u8 index, u8 type) noexcept; void SetType(u8 index, u8 type) noexcept;
uint32_t GetMaxHealth() const noexcept { return _boostedStats.GetHealth(); } u32 GetMaxHealth() const noexcept { return _boostedStats.GetHealth(); }
void ChangeLevelBy(int8_t amount); void ChangeLevelBy(i8 amount);
void Damage(uint32_t damage, DamageSource source); void Damage(u32 damage, DamageSource source);
void Heal(uint32_t amount, bool canRevive = false); void Heal(u32 amount, bool canRevive = false);
void RestoreAllAttackUses() noexcept; void RestoreAllAttackUses() noexcept;
void OverrideActiveTalent(const ArbUt::StringView& talent); void OverrideActiveTalent(const ArbUt::StringView& talent);
void AddExperience(uint32_t amount); void AddExperience(u32 amount);
void MarkOpponentAsSeen(ArbUt::BorrowedPtr<Creature> creature) { _battleData.SeenOpponents.insert(creature); } void MarkOpponentAsSeen(ArbUt::BorrowedPtr<Creature> creature) { _battleData.SeenOpponents.insert(creature); }
const std::unordered_set<ArbUt::BorrowedPtr<Creature>>& GetSeenOpponents() const { const std::unordered_set<ArbUt::BorrowedPtr<Creature>>& GetSeenOpponents() const {
@ -205,7 +204,7 @@ namespace CreatureLib::Battling {
inline bool AllowedExperienceGain() const noexcept { return _allowedExperienceGain; } inline bool AllowedExperienceGain() const noexcept { return _allowedExperienceGain; }
inline void SetAllowedExperienceGain(bool allowed) noexcept { _allowedExperienceGain = allowed; } inline void SetAllowedExperienceGain(bool allowed) noexcept { _allowedExperienceGain = allowed; }
uint8_t GetAvailableAttackSlot() const noexcept; u8 GetAvailableAttackSlot() const noexcept;
void AddAttack(LearnedAttack* attack); void AddAttack(LearnedAttack* attack);
void ReplaceAttack(size_t index, LearnedAttack* attack); void ReplaceAttack(size_t index, LearnedAttack* attack);
void SwapAttacks(size_t a, size_t b) { _attacks.Swap(a, b); } void SwapAttacks(size_t a, size_t b) { _attacks.Swap(a, b); }
@ -220,15 +219,11 @@ namespace CreatureLib::Battling {
// region Stat APIs // region Stat APIs
bool ChangeStatBoost(Library::Statistic stat, int8_t diffAmount, bool selfInflicted = false); bool ChangeStatBoost(Library::Statistic stat, i8 diffAmount, bool selfInflicted = false);
[[nodiscard]] inline uint32_t GetFlatStat(Library::Statistic stat) const { return _flatStats.GetStat(stat); } [[nodiscard]] inline u32 GetFlatStat(Library::Statistic stat) const { return _flatStats.GetStat(stat); }
[[nodiscard]] inline uint32_t GetBoostedStat(Library::Statistic stat) const { [[nodiscard]] inline u32 GetBoostedStat(Library::Statistic stat) const { return _boostedStats.GetStat(stat); }
return _boostedStats.GetStat(stat); [[nodiscard]] inline u32 GetBaseStat(Library::Statistic stat) const { return _variant->GetStatistic(stat); }
} [[nodiscard]] inline i8 GetStatBoost(Library::Statistic stat) const { return _statBoost.GetStat(stat); }
[[nodiscard]] inline uint32_t GetBaseStat(Library::Statistic stat) const {
return _variant->GetStatistic(stat);
}
[[nodiscard]] inline int8_t GetStatBoost(Library::Statistic stat) const { return _statBoost.GetStat(stat); }
void RecalculateFlatStats(); void RecalculateFlatStats();
void RecalculateBoostedStats(); void RecalculateBoostedStats();
void RecalculateFlatStat(Library::Statistic); void RecalculateFlatStat(Library::Statistic);

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

@ -9,11 +9,11 @@ namespace CreatureLib::Battling {
public: public:
CreatureIndex() noexcept : _side(0), _creature(0) {} CreatureIndex() noexcept : _side(0), _creature(0) {}
CreatureIndex(uint8_t side, u8 creature) noexcept : _side(side), _creature(creature) {} CreatureIndex(u8 side, u8 creature) noexcept : _side(side), _creature(creature) {}
uint8_t GetSideIndex() const noexcept { return _side; } u8 GetSideIndex() const noexcept { return _side; }
uint8_t GetCreatureIndex() const noexcept { return _creature; } u8 GetCreatureIndex() const noexcept { return _creature; }
bool operator==(const CreatureIndex& rhs) const noexcept { bool operator==(const CreatureIndex& rhs) const noexcept {
return (_side == rhs._side) && (_creature == rhs._creature); return (_side == rhs._side) && (_creature == rhs._creature);

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

@ -48,7 +48,7 @@ namespace CreatureLib::Battling {
size_t GetLength() const noexcept { return _party.Count(); } size_t GetLength() const noexcept { return _party.Count(); }
void PackParty() { void PackParty() {
int32_t firstNil = -1; i32 firstNil = -1;
for (size_t i = 0; i < _party.Count(); i++) { for (size_t i = 0; i < _party.Count(); i++) {
if (_party[i] == nullptr) { if (_party[i] == nullptr) {
if (firstNil == -1) { if (firstNil == -1) {

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

@ -2,7 +2,7 @@
#define CREATURELIB_DAMAGESOURCE_HPP #define CREATURELIB_DAMAGESOURCE_HPP
namespace CreatureLib::Battling { namespace CreatureLib::Battling {
ENUM(DamageSource, uint8_t, AttackDamage, Misc); ENUM(DamageSource, u8, AttackDamage, Misc);
} }
#endif // CREATURELIB_DAMAGESOURCE_HPP #endif // CREATURELIB_DAMAGESOURCE_HPP

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

@ -8,32 +8,32 @@ namespace CreatureLib::Battling {
public: public:
class HitData { class HitData {
bool _critical = false; bool _critical = false;
uint8_t _basePower = 0; u8 _basePower = 0;
float _effectiveness = 1; float _effectiveness = 1;
uint32_t _damage = 0; u32 _damage = 0;
uint8_t _type = 0; u8 _type = 0;
bool _hasFailed = false; bool _hasFailed = false;
public: public:
HitData() noexcept {} HitData() noexcept {}
[[nodiscard]] inline bool IsCritical() const noexcept { return _critical; } [[nodiscard]] inline bool IsCritical() const noexcept { return _critical; }
[[nodiscard]] inline uint8_t GetBasePower() const noexcept { return _basePower; } [[nodiscard]] inline u8 GetBasePower() const noexcept { return _basePower; }
[[nodiscard]] inline float GetEffectiveness() const noexcept { return _effectiveness; } [[nodiscard]] inline float GetEffectiveness() const noexcept { return _effectiveness; }
[[nodiscard]] inline uint32_t GetDamage() const noexcept { return _damage; } [[nodiscard]] inline u32 GetDamage() const noexcept { return _damage; }
[[nodiscard]] inline uint8_t GetType() const noexcept { return _type; } [[nodiscard]] inline u8 GetType() const noexcept { return _type; }
[[nodiscard]] inline bool HasFailed() const noexcept { return _hasFailed; } [[nodiscard]] inline bool HasFailed() const noexcept { return _hasFailed; }
inline void SetCritical(bool value) noexcept { _critical = value; } inline void SetCritical(bool value) noexcept { _critical = value; }
inline void SetBasePower(uint8_t value) noexcept { _basePower = value; } inline void SetBasePower(u8 value) noexcept { _basePower = value; }
inline void SetEffectiveness(float value) noexcept { _effectiveness = value; } inline void SetEffectiveness(float value) noexcept { _effectiveness = value; }
inline void SetDamage(uint32_t value) noexcept { _damage = value; } inline void SetDamage(u32 value) noexcept { _damage = value; }
inline void SetType(uint8_t value) noexcept { _type = value; } inline void SetType(u8 value) noexcept { _type = value; }
inline void Fail() noexcept { _hasFailed = true; } inline void Fail() noexcept { _hasFailed = true; }
}; };
private: private:
uint8_t _numberHits; u8 _numberHits;
std::unique_ptr<HitData[]> _hits; std::unique_ptr<HitData[]> _hits;
ArbUt::BorrowedPtr<Creature> _user; ArbUt::BorrowedPtr<Creature> _user;
ArbUt::BorrowedPtr<LearnedAttack> _attack; ArbUt::BorrowedPtr<LearnedAttack> _attack;
@ -42,7 +42,7 @@ namespace CreatureLib::Battling {
ArbUt::List<ArbUt::OptionalBorrowedPtr<Creature>> _targets; ArbUt::List<ArbUt::OptionalBorrowedPtr<Creature>> _targets;
public: public:
ExecutingAttack(const ArbUt::List<ArbUt::OptionalBorrowedPtr<Creature>>& targets, uint8_t numberHits, ExecutingAttack(const ArbUt::List<ArbUt::OptionalBorrowedPtr<Creature>>& targets, u8 numberHits,
ArbUt::BorrowedPtr<Creature> user, const ArbUt::BorrowedPtr<LearnedAttack>& attack, ArbUt::BorrowedPtr<Creature> user, const ArbUt::BorrowedPtr<LearnedAttack>& attack,
const ArbUt::BorrowedPtr<const Library::AttackData>& useAttack, const ArbUt::BorrowedPtr<const Library::AttackData>& useAttack,
const std::unique_ptr<BattleScript>& script) const std::unique_ptr<BattleScript>& script)
@ -56,8 +56,8 @@ namespace CreatureLib::Battling {
virtual ~ExecutingAttack() noexcept = default; virtual ~ExecutingAttack() noexcept = default;
HitData& GetHitData(ArbUt::BorrowedPtr<Creature> creature, uint8_t hit) { HitData& GetHitData(ArbUt::BorrowedPtr<Creature> creature, u8 hit) {
for (uint8_t i = 0; i < _targets.Count(); i++) { for (u8 i = 0; i < _targets.Count(); i++) {
if (!_targets[i].HasValue()) { if (!_targets[i].HasValue()) {
continue; continue;
} }
@ -69,7 +69,7 @@ namespace CreatureLib::Battling {
} }
HitData* GetTargetIteratorBegin(ArbUt::BorrowedPtr<Creature> creature) { HitData* GetTargetIteratorBegin(ArbUt::BorrowedPtr<Creature> creature) {
for (uint8_t i = 0; i < _targets.Count(); i++) { for (u8 i = 0; i < _targets.Count(); i++) {
if (!_targets[i].HasValue()) { if (!_targets[i].HasValue()) {
continue; continue;
} }
@ -81,7 +81,7 @@ namespace CreatureLib::Battling {
} }
bool IsCreatureTarget(ArbUt::BorrowedPtr<Creature> creature) noexcept { bool IsCreatureTarget(ArbUt::BorrowedPtr<Creature> creature) noexcept {
for (uint8_t i = 0; i < _targets.Count(); i++) { for (u8 i = 0; i < _targets.Count(); i++) {
if (!_targets[i].HasValue()) { if (!_targets[i].HasValue()) {
continue; continue;
} }
@ -92,10 +92,10 @@ namespace CreatureLib::Battling {
return false; return false;
} }
inline uint8_t GetTargetCount() const noexcept { return _targets.Count(); } inline u8 GetTargetCount() const noexcept { return _targets.Count(); }
inline const ArbUt::List<ArbUt::OptionalBorrowedPtr<Creature>>& GetTargets() const noexcept { return _targets; } inline const ArbUt::List<ArbUt::OptionalBorrowedPtr<Creature>>& GetTargets() const noexcept { return _targets; }
inline uint8_t GetNumberOfHits() const noexcept { return _numberHits; } inline u8 GetNumberOfHits() const noexcept { return _numberHits; }
inline const ArbUt::BorrowedPtr<Creature>& GetUser() noexcept { return _user; } inline const ArbUt::BorrowedPtr<Creature>& GetUser() noexcept { return _user; }

13
src/Battling/Models/LearnedAttack.cpp
View File

@ -1,8 +1,7 @@
#include "LearnedAttack.hpp" #include "LearnedAttack.hpp"
CreatureLib::Battling::LearnedAttack::LearnedAttack( CreatureLib::Battling::LearnedAttack::LearnedAttack(
const ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData>& attack, uint8_t maxUses, const ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData>& attack, u8 maxUses, AttackLearnMethod learnMethod)
AttackLearnMethod learnMethod)
: _attack(attack), _maxUses(maxUses), _remainingUses(maxUses), _learnMethod(learnMethod) {} : _attack(attack), _maxUses(maxUses), _remainingUses(maxUses), _learnMethod(learnMethod) {}
CreatureLib::Battling::LearnedAttack::LearnedAttack( CreatureLib::Battling::LearnedAttack::LearnedAttack(
@ -14,23 +13,23 @@ CreatureLib::Battling::LearnedAttack::GetAttack() const noexcept {
return _attack; return _attack;
} }
uint8_t CreatureLib::Battling::LearnedAttack::GetMaxUses() const noexcept { return _maxUses; } u8 CreatureLib::Battling::LearnedAttack::GetMaxUses() const noexcept { return _maxUses; }
uint8_t CreatureLib::Battling::LearnedAttack::GetRemainingUses() const noexcept { return _remainingUses; } u8 CreatureLib::Battling::LearnedAttack::GetRemainingUses() const noexcept { return _remainingUses; }
CreatureLib::Battling::AttackLearnMethod CreatureLib::Battling::LearnedAttack::GetLearnMethod() const noexcept { CreatureLib::Battling::AttackLearnMethod CreatureLib::Battling::LearnedAttack::GetLearnMethod() const noexcept {
return _learnMethod; return _learnMethod;
} }
bool CreatureLib::Battling::LearnedAttack::TryUse(uint8_t uses) noexcept { bool CreatureLib::Battling::LearnedAttack::TryUse(u8 uses) noexcept {
if (uses > _remainingUses) if (uses > _remainingUses)
return false; return false;
_remainingUses -= uses; _remainingUses -= uses;
return true; return true;
} }
void CreatureLib::Battling::LearnedAttack::DecreaseUses(uint8_t amount) noexcept { _remainingUses -= amount; } void CreatureLib::Battling::LearnedAttack::DecreaseUses(u8 amount) noexcept { _remainingUses -= amount; }
void CreatureLib::Battling::LearnedAttack::RestoreUses(uint8_t amount) noexcept { _remainingUses += amount; } void CreatureLib::Battling::LearnedAttack::RestoreUses(u8 amount) noexcept { _remainingUses += amount; }
void CreatureLib::Battling::LearnedAttack::RestoreAllUses() noexcept { _remainingUses = _maxUses; } void CreatureLib::Battling::LearnedAttack::RestoreAllUses() noexcept { _remainingUses = _maxUses; }

16
src/Battling/Models/LearnedAttack.hpp
View File

@ -8,12 +8,12 @@
namespace CreatureLib::Battling { namespace CreatureLib::Battling {
class LearnedAttack { class LearnedAttack {
ArbUt::BorrowedPtr<const Library::AttackData> _attack; ArbUt::BorrowedPtr<const Library::AttackData> _attack;
uint8_t _maxUses; u8 _maxUses;
uint8_t _remainingUses; u8 _remainingUses;
AttackLearnMethod _learnMethod; AttackLearnMethod _learnMethod;
public: public:
LearnedAttack(const ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData>& attack, uint8_t maxUses, LearnedAttack(const ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData>& attack, u8 maxUses,
AttackLearnMethod learnMethod); AttackLearnMethod learnMethod);
LearnedAttack(const ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData>& attack, LearnedAttack(const ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData>& attack,
AttackLearnMethod learnMethod); AttackLearnMethod learnMethod);
@ -21,13 +21,13 @@ namespace CreatureLib::Battling {
virtual ~LearnedAttack() = default; virtual ~LearnedAttack() = default;
const ArbUt::BorrowedPtr<const Library::AttackData>& GetAttack() const noexcept; const ArbUt::BorrowedPtr<const Library::AttackData>& GetAttack() const noexcept;
uint8_t GetMaxUses() const noexcept; u8 GetMaxUses() const noexcept;
uint8_t GetRemainingUses() const noexcept; u8 GetRemainingUses() const noexcept;
AttackLearnMethod GetLearnMethod() const noexcept; AttackLearnMethod GetLearnMethod() const noexcept;
virtual bool TryUse(uint8_t uses) noexcept; virtual bool TryUse(u8 uses) noexcept;
virtual void DecreaseUses(uint8_t amount) noexcept; virtual void DecreaseUses(u8 amount) noexcept;
virtual void RestoreUses(uint8_t amount) noexcept; virtual void RestoreUses(u8 amount) noexcept;
virtual void RestoreAllUses() noexcept; virtual void RestoreAllUses() noexcept;
virtual LearnedAttack* Clone() const { virtual LearnedAttack* Clone() const {

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

@ -49,8 +49,8 @@ namespace CreatureLib::Battling {
_par_ const ArbUt::List<CreatureLib::Library::EffectParameter*>& parameters){}; _par_ const ArbUt::List<CreatureLib::Library::EffectParameter*>& parameters){};
virtual void OnBeforeTurn(_par_ const BaseTurnChoice* choice){}; virtual void OnBeforeTurn(_par_ const BaseTurnChoice* choice){};
virtual void ChangeSpeed(_par_ BaseTurnChoice* choice, _par_ uint32_t* speed){}; virtual void ChangeSpeed(_par_ BaseTurnChoice* choice, _par_ u32* speed){};
virtual void ChangePriority(_par_ AttackTurnChoice* choice, _par_ int8_t* priority){}; virtual void ChangePriority(_par_ AttackTurnChoice* choice, _par_ i8* priority){};
virtual void ChangeAttack(_par_ AttackTurnChoice* choice, _par_ ArbUt::StringView* outAttack){}; virtual void ChangeAttack(_par_ AttackTurnChoice* choice, _par_ ArbUt::StringView* outAttack){};
virtual void ModifyNumberOfHits(_par_ AttackTurnChoice* choice, _par_ u8* numberOfHits){}; virtual void ModifyNumberOfHits(_par_ AttackTurnChoice* choice, _par_ u8* numberOfHits){};
virtual void PreventAttack(_par_ ExecutingAttack* attack, _par_ bool* outResult){}; virtual void PreventAttack(_par_ ExecutingAttack* attack, _par_ bool* outResult){};
@ -90,10 +90,10 @@ namespace CreatureLib::Battling {
virtual void OnFaintingOpponent(_par_ const ExecutingAttack* attack, _par_ Creature* target, virtual void OnFaintingOpponent(_par_ const ExecutingAttack* attack, _par_ Creature* target,
_par_ u8 hitNumber){}; _par_ u8 hitNumber){};
virtual void PreventStatBoostChange(_par_ Creature* target, _par_ Library::Statistic stat, virtual void PreventStatBoostChange(_par_ Creature* target, _par_ Library::Statistic stat, _par_ i8 diffAmount,
_par_ int8_t diffAmount, _par_ bool selfInflicted, _par_ bool* prevent){}; _par_ bool selfInflicted, _par_ bool* prevent){};
virtual void ModifyStatBoostChange(_par_ Creature* target, _par_ Library::Statistic stat, virtual void ModifyStatBoostChange(_par_ Creature* target, _par_ Library::Statistic stat,
_par_ int8_t* diffAmount){}; _par_ i8* diffAmount){};
virtual void PreventSecondaryEffects(_par_ const ExecutingAttack* attack, _par_ Creature* target, virtual void PreventSecondaryEffects(_par_ const ExecutingAttack* attack, _par_ Creature* target,
_par_ u8 hitNumber, _par_ bool* outResult){}; _par_ u8 hitNumber, _par_ bool* outResult){};
virtual void OnSecondaryEffect(_par_ const ExecutingAttack* attack, _par_ Creature* target, virtual void OnSecondaryEffect(_par_ const ExecutingAttack* attack, _par_ Creature* target,

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

@ -7,7 +7,7 @@
namespace CreatureLib::Battling { namespace CreatureLib::Battling {
class ScriptAggregator { class ScriptAggregator {
const ScriptWrapper* _scripts; const ScriptWrapper* nullable _scripts;
i32 _size; i32 _size;
i32 _index = -1; i32 _index = -1;
i32 _setIndex = -1; i32 _setIndex = -1;

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

@ -2,6 +2,6 @@
#define CREATURELIB_SCRIPTCATEGORY_HPP #define CREATURELIB_SCRIPTCATEGORY_HPP
#include <Arbutils/Enum.hpp> #include <Arbutils/Enum.hpp>
ENUM(ScriptCategory, uint8_t, Attack, Talent, Status, Creature, Battle, Side, ItemBattleTrigger) ENUM(ScriptCategory, u8, Attack, Talent, Status, Creature, Battle, Side, ItemBattleTrigger)
#endif // CREATURELIB_SCRIPTCATEGORY_HPP #endif // CREATURELIB_SCRIPTCATEGORY_HPP

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

@ -8,7 +8,7 @@
namespace CreatureLib::Battling { namespace CreatureLib::Battling {
class ScriptSet { class ScriptSet {
ArbUt::UniquePtrList<BattleScript> _scripts; ArbUt::UniquePtrList<BattleScript> _scripts;
ArbUt::Dictionary<uint32_t, size_t> _lookup; ArbUt::Dictionary<u32, size_t> _lookup;
public: public:
~ScriptSet() = default; ~ScriptSet() = default;
@ -39,7 +39,7 @@ namespace CreatureLib::Battling {
return Get(key.GetHash()); return Get(key.GetHash());
} }
ArbUt::OptionalBorrowedPtr<BattleScript> Get(uint32_t keyHash) const noexcept { ArbUt::OptionalBorrowedPtr<BattleScript> Get(u32 keyHash) const noexcept {
auto v = _lookup.TryGet(keyHash); auto v = _lookup.TryGet(keyHash);
if (v.has_value()) { if (v.has_value()) {
return _scripts[v.value()].GetRaw(); return _scripts[v.value()].GetRaw();
@ -49,7 +49,7 @@ namespace CreatureLib::Battling {
void Remove(const ArbUt::BasicStringView& key) { Remove(key.GetHash()); } void Remove(const ArbUt::BasicStringView& key) { Remove(key.GetHash()); }
void Remove(uint32_t keyHash) { void Remove(u32 keyHash) {
auto v = _lookup.TryGet(keyHash); auto v = _lookup.TryGet(keyHash);
if (v.has_value()) { if (v.has_value()) {
auto script = _scripts[v.value()]; auto script = _scripts[v.value()];
@ -69,7 +69,7 @@ namespace CreatureLib::Battling {
bool Has(const ArbUt::BasicStringView& key) const { return _lookup.Has(key); } bool Has(const ArbUt::BasicStringView& key) const { return _lookup.Has(key); }
bool Has(uint32_t keyHash) const { return _lookup.Has(keyHash); } bool Has(u32 keyHash) const { return _lookup.Has(keyHash); }
inline size_t Count() const { return _scripts.Count(); } inline size_t Count() const { return _scripts.Count(); }

6
src/Battling/TurnChoices/AttackTurnChoice.hpp
View File

@ -13,7 +13,7 @@ namespace CreatureLib::Battling {
ArbUt::BorrowedPtr<LearnedAttack> _attack; ArbUt::BorrowedPtr<LearnedAttack> _attack;
CreatureIndex _target; CreatureIndex _target;
std::unique_ptr<BattleScript> _attackScript = nullptr; std::unique_ptr<BattleScript> _attackScript = nullptr;
int8_t _priority = 0; i8 _priority = 0;
bool _hasFailed = false; bool _hasFailed = false;
void ResolveScript(ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData> attack) { void ResolveScript(ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData> attack) {
@ -59,8 +59,8 @@ namespace CreatureLib::Battling {
TurnChoiceKind GetKind() const noexcept override { return TurnChoiceKind ::Attack; } TurnChoiceKind GetKind() const noexcept override { return TurnChoiceKind ::Attack; }
inline int8_t GetPriority() const noexcept { return _priority; } inline i8 GetPriority() const noexcept { return _priority; }
inline void SetPriority(int8_t priority) noexcept { _priority = priority; } inline void SetPriority(i8 priority) noexcept { _priority = priority; }
const CreatureIndex& GetTarget() const noexcept { return _target; } const CreatureIndex& GetTarget() const noexcept { return _target; }

12
src/Battling/TurnChoices/BaseTurnChoice.hpp
View File

@ -8,8 +8,8 @@ namespace CreatureLib::Battling {
class Creature; class Creature;
class BaseTurnChoice : public ScriptSource { class BaseTurnChoice : public ScriptSource {
int32_t _randomValue; i32 _randomValue;
uint32_t _speed; u32 _speed;
protected: protected:
ArbUt::BorrowedPtr<Creature> _user; ArbUt::BorrowedPtr<Creature> _user;
@ -20,11 +20,11 @@ namespace CreatureLib::Battling {
[[nodiscard]] virtual TurnChoiceKind GetKind() const noexcept = 0; [[nodiscard]] virtual TurnChoiceKind GetKind() const noexcept = 0;
[[nodiscard]] inline const ArbUt::BorrowedPtr<Creature>& GetUser() const noexcept { return _user; } [[nodiscard]] inline const ArbUt::BorrowedPtr<Creature>& GetUser() const noexcept { return _user; }
inline void __SetRandomValue(int32_t val) noexcept { _randomValue = val; } inline void __SetRandomValue(i32 val) noexcept { _randomValue = val; }
inline int32_t __GetRandomValue() const noexcept { return _randomValue; } inline i32 __GetRandomValue() const noexcept { return _randomValue; }
inline void __SetSpeed(uint32_t val) noexcept { _speed = val; } inline void __SetSpeed(u32 val) noexcept { _speed = val; }
inline uint32_t __GetSpeed() const noexcept { return _speed; } inline u32 __GetSpeed() const noexcept { return _speed; }
}; };
} }

2
src/Battling/TurnChoices/TurnChoiceKind.hpp
View File

@ -2,6 +2,6 @@
#define CREATURELIB_TURNCHOICEKIND_HPP #define CREATURELIB_TURNCHOICEKIND_HPP
namespace CreatureLib::Battling { namespace CreatureLib::Battling {
ENUM(TurnChoiceKind, uint8_t, Pass, Attack, Item, Switch, Flee); ENUM(TurnChoiceKind, u8, Pass, Attack, Item, Switch, Flee);
} }
#endif // CREATURELIB_TURNCHOICEKIND_HPP #endif // CREATURELIB_TURNCHOICEKIND_HPP

21
src/Defines.hpp
View File

@ -1,6 +1,6 @@
#ifndef CREATURELIB_DEFINES_HPP #ifndef CREATURELIB_DEFINES_HPP
#define CREATURELIB_DEFINES_HPP #define CREATURELIB_DEFINES_HPP
#include <cstdint> #include <Arbutils/Defines.hpp>
#if LEVEL_U8 #if LEVEL_U8
using level_int_t = uint8_t; using level_int_t = uint8_t;
@ -15,17 +15,14 @@ using level_int_t = uint64_t;
using level_int_t = uint8_t; using level_int_t = uint8_t;
#endif #endif
using u8 = uint8_t; [[deprecated]] typedef uint8_t uint8_t;
using u16 = uint16_t; [[deprecated]] typedef uint16_t uint16_t;
using u32 = uint32_t; [[deprecated]] typedef uint32_t uint32_t;
using u64 = uint64_t; [[deprecated]] typedef uint64_t uint64_t;
using i8 = int8_t; [[deprecated]] typedef int8_t int8_t;
using i16 = int16_t; [[deprecated]] typedef int16_t int16_t;
using i32 = int32_t; [[deprecated]] typedef int32_t int32_t;
using i64 = int64_t; [[deprecated]] typedef int64_t int64_t;
using f32 = float;
using f64 = double;
#endif // CREATURELIB_DEFINES_HPP #endif // CREATURELIB_DEFINES_HPP

2
src/Library/Attacks/AttackCategory.hpp
View File

@ -3,7 +3,7 @@
#include <Arbutils/Enum.hpp> #include <Arbutils/Enum.hpp>
namespace CreatureLib::Library { namespace CreatureLib::Library {
ENUM(AttackCategory, uint8_t, Physical, Magical, Status) ENUM(AttackCategory, u8, Physical, Magical, Status)
} }
#endif // CREATURELIB_ATTACKCATEGORY_HPP #endif // CREATURELIB_ATTACKCATEGORY_HPP

9
src/Library/Attacks/AttackData.cpp
View File

@ -1,9 +1,8 @@
#include "AttackData.hpp" #include "AttackData.hpp"
CreatureLib::Library::AttackData::AttackData(const ArbUt::StringView& name, uint8_t type, CreatureLib::Library::AttackData::AttackData(const ArbUt::StringView& name, u8 type,
CreatureLib::Library::AttackCategory category, uint8_t power, CreatureLib::Library::AttackCategory category, u8 power, u8 accuracy,
uint8_t accuracy, uint8_t baseUsage, u8 baseUsage, CreatureLib::Library::AttackTarget target, i8 priority,
CreatureLib::Library::AttackTarget target, int8_t priority, const SecondaryEffect* effect, std::unordered_set<u32> flags)
const SecondaryEffect* effect, std::unordered_set<uint32_t> flags)
: _name(name), _type(type), _category(category), _basePower(power), _accuracy(accuracy), _baseUsages(baseUsage), : _name(name), _type(type), _category(category), _basePower(power), _accuracy(accuracy), _baseUsages(baseUsage),
_target(target), _priority(priority), _effect(effect), _flags(std::move(flags)) {} _target(target), _priority(priority), _effect(effect), _flags(std::move(flags)) {}

31
src/Library/Attacks/AttackData.hpp
View File

@ -10,30 +10,29 @@ namespace CreatureLib::Library {
class AttackData { class AttackData {
protected: protected:
ArbUt::StringView _name; ArbUt::StringView _name;
uint8_t _type; u8 _type;
AttackCategory _category; AttackCategory _category;
uint8_t _basePower; u8 _basePower;
uint8_t _accuracy; u8 _accuracy;
uint8_t _baseUsages; u8 _baseUsages;
AttackTarget _target; AttackTarget _target;
int8_t _priority; i8 _priority;
std::unique_ptr<const SecondaryEffect> _effect = nullptr; std::unique_ptr<const SecondaryEffect> _effect = nullptr;
std::unordered_set<uint32_t> _flags; std::unordered_set<u32> _flags;
public: public:
AttackData(const ArbUt::StringView& name, uint8_t type, AttackCategory category, uint8_t power, AttackData(const ArbUt::StringView& name, u8 type, AttackCategory category, u8 power, u8 accuracy, u8 baseUsage,
uint8_t accuracy, uint8_t baseUsage, AttackTarget target, int8_t priority, AttackTarget target, i8 priority, const SecondaryEffect* effect, std::unordered_set<u32> flags);
const SecondaryEffect* effect, std::unordered_set<uint32_t> flags);
virtual ~AttackData() = default; virtual ~AttackData() = default;
inline const ArbUt::StringView& GetName() const noexcept { return _name; } inline const ArbUt::StringView& GetName() const noexcept { return _name; }
inline uint8_t GetType() const noexcept { return _type; } inline u8 GetType() const noexcept { return _type; }
inline AttackCategory GetCategory() const noexcept { return _category; } inline AttackCategory GetCategory() const noexcept { return _category; }
inline uint8_t GetBasePower() const noexcept { return _basePower; } inline u8 GetBasePower() const noexcept { return _basePower; }
inline uint8_t GetAccuracy() const noexcept { return _accuracy; } inline u8 GetAccuracy() const noexcept { return _accuracy; }
inline uint8_t GetBaseUsages() const noexcept { return _baseUsages; } inline u8 GetBaseUsages() const noexcept { return _baseUsages; }
inline AttackTarget GetTarget() const noexcept { return _target; } inline AttackTarget GetTarget() const noexcept { return _target; }
inline int8_t GetPriority() const noexcept { return _priority; } inline i8 GetPriority() const noexcept { return _priority; }
inline bool HasSecondaryEffect() const noexcept { inline bool HasSecondaryEffect() const noexcept {
return _effect != nullptr && !_effect->GetEffectName().IsEmpty(); return _effect != nullptr && !_effect->GetEffectName().IsEmpty();
} }
@ -42,9 +41,7 @@ namespace CreatureLib::Library {
inline bool HasFlag(const ArbUt::StringView& key) const noexcept { inline bool HasFlag(const ArbUt::StringView& key) const noexcept {
return this->_flags.find(key) != this->_flags.end(); return this->_flags.find(key) != this->_flags.end();
} }
inline bool HasFlag(uint32_t keyHash) const noexcept { inline bool HasFlag(u32 keyHash) const noexcept { return this->_flags.find(keyHash) != this->_flags.end(); }
return this->_flags.find(keyHash) != this->_flags.end();
}
}; };
} }

2
src/Library/Attacks/AttackTarget.hpp
View File

@ -4,7 +4,7 @@
#include <Arbutils/Enum.hpp> #include <Arbutils/Enum.hpp>
namespace CreatureLib::Library { namespace CreatureLib::Library {
ENUM(AttackTarget, uint8_t, Adjacent, AdjacentAlly, AdjacentAllySelf, AdjacentOpponent, ENUM(AttackTarget, u8, Adjacent, AdjacentAlly, AdjacentAllySelf, AdjacentOpponent,
All, AllAdjacent, AllAdjacentOpponent, AllAlly, AllOpponent, All, AllAdjacent, AllAdjacentOpponent, AllAlly, AllOpponent,

34
src/Library/BaseLibrary.hpp
View File

@ -10,8 +10,8 @@
namespace CreatureLib::Library { namespace CreatureLib::Library {
template <class T> class BaseLibrary { template <class T> class BaseLibrary {
protected: protected:
ArbUt::Dictionary<uint32_t, std::unique_ptr<const T>> _values; ArbUt::Dictionary<u32, std::unique_ptr<const T>> _values;
ArbUt::List<uint32_t> _listValues; ArbUt::List<u32> _listValues;
public: public:
BaseLibrary(size_t initialCapacity = 32) : _values(initialCapacity), _listValues(initialCapacity) {} BaseLibrary(size_t initialCapacity = 32) : _values(initialCapacity), _listValues(initialCapacity) {}
@ -23,7 +23,7 @@ namespace CreatureLib::Library {
_values.GetStdMap().insert({key.GetHash(), std::unique_ptr<const T>(value)}); _values.GetStdMap().insert({key.GetHash(), std::unique_ptr<const T>(value)});
_listValues.Append(key); _listValues.Append(key);
} }
inline virtual void Insert(uint32_t hashedKey, const T* value) { inline virtual void Insert(u32 hashedKey, const T* value) {
EnsureNotNull(value) EnsureNotNull(value)
_values.GetStdMap().insert({hashedKey, std::unique_ptr<const T>(value)}); _values.GetStdMap().insert({hashedKey, std::unique_ptr<const T>(value)});
_listValues.Append(hashedKey); _listValues.Append(hashedKey);
@ -32,18 +32,22 @@ namespace CreatureLib::Library {
inline void Delete(const ArbUt::StringView& key) noexcept { inline void Delete(const ArbUt::StringView& key) noexcept {
_values.erase(key.GetHash()); _values.erase(key.GetHash());
auto k = _listValues.IndexOf(key); auto k = _listValues.IndexOf(key);
_listValues.Remove(k); if (k.has_value()) {
_listValues.Remove(k.value());
}
} }
inline void Delete(uint32_t hashedKey) noexcept { inline void Delete(u32 hashedKey) noexcept {
_values.Remove(hashedKey); _values.Remove(hashedKey);
auto k = _listValues.IndexOf(hashedKey); auto k = _listValues.IndexOf(hashedKey);
_listValues.Remove(k); if (k.has_value()) {
_listValues.Remove(k.value());
}
} }
std::optional<ArbUt::BorrowedPtr<const T>> TryGet(const ArbUt::BasicStringView& name) const noexcept { std::optional<ArbUt::BorrowedPtr<const T>> TryGet(const ArbUt::BasicStringView& name) const noexcept {
return TryGet(name.GetHash()); return TryGet(name.GetHash());
} }
std::optional<ArbUt::BorrowedPtr<const T>> TryGet(uint32_t hashedKey) const noexcept { std::optional<ArbUt::BorrowedPtr<const T>> TryGet(u32 hashedKey) const noexcept {
auto find = _values.GetStdMap().find(hashedKey); auto find = _values.GetStdMap().find(hashedKey);
if (find == _values.GetStdMap().end()) if (find == _values.GetStdMap().end())
return {}; return {};
@ -53,29 +57,25 @@ namespace CreatureLib::Library {
[[nodiscard]] inline ArbUt::BorrowedPtr<const T> Get(const ArbUt::BasicStringView& name) const { [[nodiscard]] inline ArbUt::BorrowedPtr<const T> Get(const ArbUt::BasicStringView& name) const {
return _values.Get(name.GetHash()); return _values.Get(name.GetHash());
} }
[[nodiscard]] inline ArbUt::BorrowedPtr<const T> Get(uint32_t hashedKey) const { [[nodiscard]] inline ArbUt::BorrowedPtr<const T> Get(u32 hashedKey) const { return _values.Get(hashedKey); }
return _values.Get(hashedKey);
}
[[nodiscard]] inline ArbUt::BorrowedPtr<const T> operator[](const ArbUt::BasicStringView& name) const { [[nodiscard]] inline ArbUt::BorrowedPtr<const T> operator[](const ArbUt::BasicStringView& name) const {
return Get(name); return Get(name);
} }
[[nodiscard]] inline ArbUt::BorrowedPtr<const T> operator[](uint32_t hashedKey) const { return Get(hashedKey); } [[nodiscard]] inline ArbUt::BorrowedPtr<const T> operator[](u32 hashedKey) const { return Get(hashedKey); }
[[nodiscard]] inline const ArbUt::Dictionary<uint32_t, const std::unique_ptr<const T>>& [[nodiscard]] inline const ArbUt::Dictionary<u32, const std::unique_ptr<const T>>&
GetIterator() const noexcept { GetIterator() const noexcept {
return _values; return _values;
} }
using const_iterator = typename std::unordered_map<uint32_t, ArbUt::BorrowedPtr<const T>>::const_iterator; using const_iterator = typename std::unordered_map<u32, ArbUt::BorrowedPtr<const T>>::const_iterator;
inline const_iterator begin() const { inline const_iterator begin() const {
return reinterpret_cast<const std::unordered_map<uint32_t, ArbUt::BorrowedPtr<const T>>&>( return reinterpret_cast<const std::unordered_map<u32, ArbUt::BorrowedPtr<const T>>&>(_values.GetStdMap())
_values.GetStdMap())
.begin(); .begin();
} }
inline const_iterator end() const { inline const_iterator end() const {
return reinterpret_cast<const std::unordered_map<uint32_t, ArbUt::BorrowedPtr<const T>>&>( return reinterpret_cast<const std::unordered_map<u32, ArbUt::BorrowedPtr<const T>>&>(_values.GetStdMap())
_values.GetStdMap())
.end(); .end();
} }

44
src/Library/CreatureData/CreatureSpecies.cpp
View File

@ -5,17 +5,17 @@ using namespace CreatureLib::Library;
struct CreatureSpecies::impl { struct CreatureSpecies::impl {
const ArbUt::StringView _name; const ArbUt::StringView _name;
uint16_t _id; u16 _id;
float _genderRate; float _genderRate;
const ArbUt::StringView _growthRate; const ArbUt::StringView _growthRate;
uint8_t _captureRate; u8 _captureRate;
ArbUt::Dictionary<uint32_t, ArbUt::UniquePtr<const SpeciesVariant>> _variantsLookup; ArbUt::Dictionary<u32, ArbUt::UniquePtr<const SpeciesVariant>> _variantsLookup;
ArbUt::List<ArbUt::BorrowedPtr<const SpeciesVariant>> _variantsList; ArbUt::List<ArbUt::BorrowedPtr<const SpeciesVariant>> _variantsList;
std::unordered_set<uint32_t> _flags; std::unordered_set<u32> _flags;
impl(uint16_t id, const ArbUt::StringView& name, const SpeciesVariant* defaultVariant, float genderRatio, impl(u16 id, const ArbUt::StringView& name, const SpeciesVariant* defaultVariant, float genderRatio,
const ArbUt::StringView& growthRate, uint8_t captureRate, std::unordered_set<uint32_t> flags) const ArbUt::StringView& growthRate, u8 captureRate, std::unordered_set<u32> flags)
: _name(name), _id(id), _genderRate(genderRatio), _growthRate(growthRate), _captureRate(captureRate), : _name(name), _id(id), _genderRate(genderRatio), _growthRate(growthRate), _captureRate(captureRate),
_variantsLookup(1), _variantsList(1), _flags(std::move(flags)) { _variantsLookup(1), _variantsList(1), _flags(std::move(flags)) {
EnsureNotNull(defaultVariant) EnsureNotNull(defaultVariant)
@ -24,20 +24,20 @@ struct CreatureSpecies::impl {
~impl() { _variantsLookup.Clear(); } ~impl() { _variantsLookup.Clear(); }
inline uint16_t GetId() const noexcept { return _id; } inline u16 GetId() const noexcept { return _id; }
inline float GetGenderRate() const noexcept { return _genderRate; } inline float GetGenderRate() const noexcept { return _genderRate; }
inline const ArbUt::StringView& GetGrowthRate() const noexcept { return _growthRate; } inline const ArbUt::StringView& GetGrowthRate() const noexcept { return _growthRate; }
inline uint8_t GetCaptureRate() const noexcept { return _captureRate; } inline u8 GetCaptureRate() const noexcept { return _captureRate; }
[[nodiscard]] inline bool HasVariant(const ArbUt::BasicStringView& key) const noexcept { [[nodiscard]] inline bool HasVariant(const ArbUt::BasicStringView& key) const noexcept {
return _variantsLookup.Has(key); return _variantsLookup.Has(key);
} }
[[nodiscard]] inline bool HasVariant(uint32_t hash) const noexcept { return _variantsLookup.Has(hash); } [[nodiscard]] inline bool HasVariant(u32 hash) const noexcept { return _variantsLookup.Has(hash); }
[[nodiscard]] inline std::optional<ArbUt::BorrowedPtr<const SpeciesVariant>> [[nodiscard]] inline std::optional<ArbUt::BorrowedPtr<const SpeciesVariant>>
TryGetVariant(const ArbUt::BasicStringView& name) const noexcept { TryGetVariant(const ArbUt::BasicStringView& name) const noexcept {
return TryGetVariant(name.GetHash()); return TryGetVariant(name.GetHash());
} }
[[nodiscard]] std::optional<ArbUt::BorrowedPtr<const SpeciesVariant>> TryGetVariant(uint32_t hash) const noexcept { [[nodiscard]] std::optional<ArbUt::BorrowedPtr<const SpeciesVariant>> TryGetVariant(u32 hash) const noexcept {
auto find = _variantsLookup.GetStdMap().find(hash); auto find = _variantsLookup.GetStdMap().find(hash);
if (find == _variantsLookup.end()) if (find == _variantsLookup.end())
return {}; return {};
@ -46,7 +46,7 @@ struct CreatureSpecies::impl {
[[nodiscard]] inline ArbUt::BorrowedPtr<const SpeciesVariant> GetVariant(const ArbUt::BasicStringView& key) const { [[nodiscard]] inline ArbUt::BorrowedPtr<const SpeciesVariant> GetVariant(const ArbUt::BasicStringView& key) const {
return _variantsLookup.Get(key).GetRaw(); return _variantsLookup.Get(key).GetRaw();
} }
[[nodiscard]] inline ArbUt::BorrowedPtr<const SpeciesVariant> GetVariant(uint32_t key) const { [[nodiscard]] inline ArbUt::BorrowedPtr<const SpeciesVariant> GetVariant(u32 key) const {
return _variantsLookup.Get(key).GetRaw(); return _variantsLookup.Get(key).GetRaw();
} }
[[nodiscard]] Gender GetRandomGender(ArbUt::Random& rand) const noexcept { [[nodiscard]] Gender GetRandomGender(ArbUt::Random& rand) const noexcept {
@ -73,40 +73,38 @@ struct CreatureSpecies::impl {
inline bool HasFlag(const ArbUt::StringView& key) const noexcept { inline bool HasFlag(const ArbUt::StringView& key) const noexcept {
return this->_flags.find(key) != this->_flags.end(); return this->_flags.find(key) != this->_flags.end();
} }
inline bool HasFlag(uint32_t keyHash) const noexcept { return this->_flags.find(keyHash) != this->_flags.end(); } inline bool HasFlag(u32 keyHash) const noexcept { return this->_flags.find(keyHash) != this->_flags.end(); }
}; };
CreatureSpecies::CreatureSpecies(uint16_t id, const ArbUt::StringView& name, const SpeciesVariant* defaultVariant, CreatureSpecies::CreatureSpecies(u16 id, const ArbUt::StringView& name, const SpeciesVariant* defaultVariant,
float genderRatio, const ArbUt::StringView& growthRate, uint8_t captureRate, float genderRatio, const ArbUt::StringView& growthRate, u8 captureRate,
std::unordered_set<uint32_t> flags) std::unordered_set<u32> flags)
: _impl(new impl(id, name, defaultVariant, genderRatio, growthRate, captureRate, flags)) {} : _impl(new impl(id, name, defaultVariant, genderRatio, growthRate, captureRate, flags)) {}
#define ImplGetter(type, func) \ #define ImplGetter(type, func) \
type CreatureSpecies::func() const noexcept { return _impl->func(); } type CreatureSpecies::func() const noexcept { return _impl->func(); }
CreatureSpecies::~CreatureSpecies() = default; CreatureSpecies::~CreatureSpecies() = default;
ImplGetter(uint16_t, GetId); ImplGetter(u16, GetId);
ImplGetter(float, GetGenderRate); ImplGetter(float, GetGenderRate);
ImplGetter(const ArbUt::StringView&, GetGrowthRate); ImplGetter(const ArbUt::StringView&, GetGrowthRate);
ImplGetter(uint8_t, GetCaptureRate); ImplGetter(u8, GetCaptureRate);
ImplGetter(const ArbUt::StringView&, GetName); ImplGetter(const ArbUt::StringView&, GetName);
bool CreatureSpecies::HasVariant(const ArbUt::BasicStringView& key) const noexcept { return _impl->HasVariant(key); } bool CreatureSpecies::HasVariant(const ArbUt::BasicStringView& key) const noexcept { return _impl->HasVariant(key); }
bool CreatureSpecies::HasVariant(uint32_t hash) const noexcept { return _impl->HasVariant(hash); } bool CreatureSpecies::HasVariant(u32 hash) const noexcept { return _impl->HasVariant(hash); }
std::optional<ArbUt::BorrowedPtr<const SpeciesVariant>> std::optional<ArbUt::BorrowedPtr<const SpeciesVariant>>
CreatureSpecies::TryGetVariant(const ArbUt::BasicStringView& name) const noexcept { CreatureSpecies::TryGetVariant(const ArbUt::BasicStringView& name) const noexcept {
return _impl->TryGetVariant(name); return _impl->TryGetVariant(name);
} }
std::optional<ArbUt::BorrowedPtr<const SpeciesVariant>> CreatureSpecies::TryGetVariant(uint32_t hash) const noexcept { std::optional<ArbUt::BorrowedPtr<const SpeciesVariant>> CreatureSpecies::TryGetVariant(u32 hash) const noexcept {
return _impl->TryGetVariant(hash); return _impl->TryGetVariant(hash);
} }
ArbUt::BorrowedPtr<const SpeciesVariant> CreatureSpecies::GetVariant(const ArbUt::BasicStringView& key) const { ArbUt::BorrowedPtr<const SpeciesVariant> CreatureSpecies::GetVariant(const ArbUt::BasicStringView& key) const {
return _impl->GetVariant(key); return _impl->GetVariant(key);
} }
ArbUt::BorrowedPtr<const SpeciesVariant> CreatureSpecies::GetVariant(uint32_t key) const { ArbUt::BorrowedPtr<const SpeciesVariant> CreatureSpecies::GetVariant(u32 key) const { return _impl->GetVariant(key); }
return _impl->GetVariant(key);
}
Gender CreatureSpecies::GetRandomGender(ArbUt::Random& rand) const noexcept { return _impl->GetRandomGender(rand); } Gender CreatureSpecies::GetRandomGender(ArbUt::Random& rand) const noexcept { return _impl->GetRandomGender(rand); }
void CreatureSpecies::SetVariant(const ArbUt::StringView& name, const SpeciesVariant* variant) { void CreatureSpecies::SetVariant(const ArbUt::StringView& name, const SpeciesVariant* variant) {
_impl->SetVariant(name, variant); _impl->SetVariant(name, variant);
@ -116,4 +114,4 @@ const ArbUt::List<ArbUt::BorrowedPtr<const SpeciesVariant>>& CreatureSpecies::Ge
} }
bool CreatureSpecies::HasFlag(const ArbUt::StringView& key) const noexcept { return _impl->HasFlag(key); } bool CreatureSpecies::HasFlag(const ArbUt::StringView& key) const noexcept { return _impl->HasFlag(key); }
bool CreatureSpecies::HasFlag(uint32_t keyHash) const noexcept { return _impl->HasFlag(keyHash); } bool CreatureSpecies::HasFlag(u32 keyHash) const noexcept { return _impl->HasFlag(keyHash); }

18
src/Library/CreatureData/CreatureSpecies.hpp
View File

@ -23,15 +23,14 @@ namespace CreatureLib::Library {
/// @param captureRate The chance to capture the creature species, between 0 and 255. 255 means instant capture, /// @param captureRate The chance to capture the creature species, between 0 and 255. 255 means instant capture,
/// 0 means impossible to capture. /// 0 means impossible to capture.
/// @param flags A set of flags for use by the developer. These can be used for easy grouping. /// @param flags A set of flags for use by the developer. These can be used for easy grouping.
CreatureSpecies(uint16_t id, const ArbUt::StringView& name, const SpeciesVariant* defaultVariant, CreatureSpecies(u16 id, const ArbUt::StringView& name, const SpeciesVariant* defaultVariant, float genderRatio,
float genderRatio, const ArbUt::StringView& growthRate, uint8_t captureRate, const ArbUt::StringView& growthRate, u8 captureRate, std::unordered_set<u32> flags = {});
std::unordered_set<uint32_t> flags = {});
virtual ~CreatureSpecies(); virtual ~CreatureSpecies();
/// @brief Returns the unique id of the creature species. /// @brief Returns the unique id of the creature species.
/// @return The unique id of the creature species /// @return The unique id of the creature species
uint16_t GetId() const noexcept; u16 GetId() const noexcept;
/// @brief Returns the name of the species. /// @brief Returns the name of the species.
/// @return The name of the species. /// @return The name of the species.
[[nodiscard]] const ArbUt::StringView& GetName() const noexcept; [[nodiscard]] const ArbUt::StringView& GetName() const noexcept;
@ -45,7 +44,7 @@ namespace CreatureLib::Library {
/// @brief Returns the capture rate of the creature species. /// @brief Returns the capture rate of the creature species.
/// @return The base capture rate of the creature species. 255 means instant capture, 0 means impossible to /// @return The base capture rate of the creature species. 255 means instant capture, 0 means impossible to
/// capture. /// capture.
uint8_t GetCaptureRate() const noexcept; u8 GetCaptureRate() const noexcept;
/// @brief Checks whether the species contains a variant with a specific name. /// @brief Checks whether the species contains a variant with a specific name.
/// @param key The name of the variant that's being looked for. /// @param key The name of the variant that's being looked for.
@ -55,7 +54,7 @@ namespace CreatureLib::Library {
/// @param hash The string hash of the variant that's being looked for. This hash can be retrieved from the /// @param hash The string hash of the variant that's being looked for. This hash can be retrieved from the
/// StringView class. /// StringView class.
/// @return True if the species contains the variant, false otherwise. /// @return True if the species contains the variant, false otherwise.
[[nodiscard]] bool HasVariant(uint32_t hash) const noexcept; [[nodiscard]] bool HasVariant(u32 hash) const noexcept;
/// @brief Try to get a variant of the species with a specific name. /// @brief Try to get a variant of the species with a specific name.
/// @param name The name of the variant that's being looked for. /// @param name The name of the variant that's being looked for.
/// @param out If a variant is found, it will be put in this variable. If not, this will remain unchanged. /// @param out If a variant is found, it will be put in this variable. If not, this will remain unchanged.
@ -67,8 +66,7 @@ namespace CreatureLib::Library {
/// StringView class. /// StringView class.
/// @param out If a variant is found, it will be put in this variable. If not, this will remain unchanged. /// @param out If a variant is found, it will be put in this variable. If not, this will remain unchanged.
/// @return True if the species contains the variant, false otherwise. /// @return True if the species contains the variant, false otherwise.
[[nodiscard]] std::optional<ArbUt::BorrowedPtr<const SpeciesVariant>> [[nodiscard]] std::optional<ArbUt::BorrowedPtr<const SpeciesVariant>> TryGetVariant(u32 hash) const noexcept;
TryGetVariant(uint32_t hash) const noexcept;
/// @brief Returns a variant with a specific name. Throws if no variant with the name exists. /// @brief Returns a variant with a specific name. Throws if no variant with the name exists.
/// @param key The name of the variant that's being looked for. /// @param key The name of the variant that's being looked for.
/// @return The specified variant. /// @return The specified variant.
@ -76,7 +74,7 @@ namespace CreatureLib::Library {
/// @brief Returns a variant with a specific name. Throws if no variant with the name exists. /// @brief Returns a variant with a specific name. Throws if no variant with the name exists.
/// @param key The string hash of the variant that's being looked for. /// @param key The string hash of the variant that's being looked for.
/// @return The specified variant. /// @return The specified variant.
[[nodiscard]] ArbUt::BorrowedPtr<const SpeciesVariant> GetVariant(uint32_t key) const; [[nodiscard]] ArbUt::BorrowedPtr<const SpeciesVariant> GetVariant(u32 key) const;
/// @brief Returns a random gender based on the gender ratio of the species. /// @brief Returns a random gender based on the gender ratio of the species.
/// @param rand A random number generator class. /// @param rand A random number generator class.
/// @return A random gender. If gender ratio is -1 this will return Genderless, otherwise it will be either male /// @return A random gender. If gender ratio is -1 this will return Genderless, otherwise it will be either male
@ -99,7 +97,7 @@ namespace CreatureLib::Library {
/// @brief Checks whether the species has a specific flag. /// @brief Checks whether the species has a specific flag.
/// @param keyHash The flag to check for. /// @param keyHash The flag to check for.
/// @return True if the species has the flag, false otherwise. /// @return True if the species has the flag, false otherwise.
bool HasFlag(uint32_t keyHash) const noexcept; bool HasFlag(u32 keyHash) const noexcept;
}; };
} }

2
src/Library/CreatureData/LearnableAttacks.cpp
View File

@ -28,7 +28,7 @@ namespace CreatureLib::Library {
inline bool HasAttacksForLevel(level_int_t level) const noexcept { return _learnedByLevel.Has(level); } inline bool HasAttacksForLevel(level_int_t level) const noexcept { return _learnedByLevel.Has(level); }
inline const ArbUt::List<ArbUt::BorrowedPtr<const AttackData>>& GetAttacksForLevel(level_int_t level) const { inline const ArbUt::List<ArbUt::BorrowedPtr<const AttackData>>& GetAttacksForLevel(level_int_t level) const {
if (!_learnedByLevel.Has(level)) { if (!_learnedByLevel.Has(level)) {
THROW("No attacks found for level ", (uint32_t)level, "."); THROW("No attacks found for level ", (u32)level, ".");
} }
return _learnedByLevel.Get(level); return _learnedByLevel.Get(level);
} }

45
src/Library/CreatureData/SpeciesVariant.cpp
View File

@ -6,20 +6,19 @@ namespace CreatureLib::Library {
ArbUt::StringView _name; ArbUt::StringView _name;
float _height; float _height;
float _weight; float _weight;
uint32_t _baseExperience; u32 _baseExperience;
ArbUt::List<uint8_t> _types; ArbUt::List<u8> _types;
Library::StatisticSet<uint16_t> _baseStatistics; Library::StatisticSet<u16> _baseStatistics;
ArbUt::List<ArbUt::BorrowedPtr<const Talent>> _talents; ArbUt::List<ArbUt::BorrowedPtr<const Talent>> _talents;
ArbUt::List<ArbUt::BorrowedPtr<const Talent>> _secretTalents; ArbUt::List<ArbUt::BorrowedPtr<const Talent>> _secretTalents;
std::unique_ptr<const LearnableAttacks> _attacks; std::unique_ptr<const LearnableAttacks> _attacks;
std::unordered_set<uint32_t> _flags; std::unordered_set<u32> _flags;
public: public:
impl(const ArbUt::StringView& name, float height, float weight, uint32_t baseExperience, impl(const ArbUt::StringView& name, float height, float weight, u32 baseExperience, ArbUt::List<u8> types,
ArbUt::List<uint8_t> types, Library::StatisticSet<uint16_t> baseStats, Library::StatisticSet<u16> baseStats, ArbUt::List<ArbUt::BorrowedPtr<const Talent>> talents,
ArbUt::List<ArbUt::BorrowedPtr<const Talent>> talents,
ArbUt::List<ArbUt::BorrowedPtr<const Talent>> secretTalents, const LearnableAttacks* attacks, ArbUt::List<ArbUt::BorrowedPtr<const Talent>> secretTalents, const LearnableAttacks* attacks,
std::unordered_set<uint32_t> flags) std::unordered_set<u32> flags)
: _name(name), _height(height), _weight(weight), _baseExperience(baseExperience), : _name(name), _height(height), _weight(weight), _baseExperience(baseExperience),
_types(std::move((types))), _baseStatistics(baseStats), _talents(std::move(talents)), _types(std::move((types))), _baseStatistics(baseStats), _talents(std::move(talents)),
_secretTalents(std::move(secretTalents)), _attacks(attacks), _flags(std::move(flags)){}; _secretTalents(std::move(secretTalents)), _attacks(attacks), _flags(std::move(flags)){};
@ -27,14 +26,12 @@ namespace CreatureLib::Library {
inline const ArbUt::StringView& GetName() const { return _name; } inline const ArbUt::StringView& GetName() const { return _name; }
inline float GetHeight() const { return _height; } inline float GetHeight() const { return _height; }
inline float GetWeight() const { return _weight; } inline float GetWeight() const { return _weight; }
inline uint32_t GetBaseExperience() const { return _baseExperience; } inline u32 GetBaseExperience() const { return _baseExperience; }
[[nodiscard]] inline size_t GetTypeCount() const { return _types.Count(); } [[nodiscard]] inline size_t GetTypeCount() const { return _types.Count(); }
[[nodiscard]] inline uint8_t GetType(size_t index) const { return _types[index]; } [[nodiscard]] inline u8 GetType(size_t index) const { return _types[index]; }
[[nodiscard]] inline const ArbUt::List<uint8_t>& GetTypes() const { return _types; } [[nodiscard]] inline const ArbUt::List<u8>& GetTypes() const { return _types; }
[[nodiscard]] inline uint16_t GetStatistic(Library::Statistic stat) const { [[nodiscard]] inline u16 GetStatistic(Library::Statistic stat) const { return _baseStatistics.GetStat(stat); }
return _baseStatistics.GetStat(stat);
}
[[nodiscard]] inline size_t GetTalentCount() const noexcept { return _talents.Count(); } [[nodiscard]] inline size_t GetTalentCount() const noexcept { return _talents.Count(); }
[[nodiscard]] inline size_t GetSecretTalentCount() const noexcept { return _secretTalents.Count(); } [[nodiscard]] inline size_t GetSecretTalentCount() const noexcept { return _secretTalents.Count(); }
[[nodiscard]] const ArbUt::BorrowedPtr<const Talent>& GetTalent(const TalentIndex& index) const { [[nodiscard]] const ArbUt::BorrowedPtr<const Talent>& GetTalent(const TalentIndex& index) const {
@ -95,16 +92,14 @@ namespace CreatureLib::Library {
inline bool HasFlag(const ArbUt::StringView& key) const noexcept { inline bool HasFlag(const ArbUt::StringView& key) const noexcept {
return this->_flags.find(key) != this->_flags.end(); return this->_flags.find(key) != this->_flags.end();
} }
inline bool HasFlag(uint32_t keyHash) const noexcept { inline bool HasFlag(u32 keyHash) const noexcept { return this->_flags.find(keyHash) != this->_flags.end(); }
return this->_flags.find(keyHash) != this->_flags.end();
}
}; };
SpeciesVariant::SpeciesVariant(const ArbUt::StringView& name, float height, float weight, uint32_t baseExperience, SpeciesVariant::SpeciesVariant(const ArbUt::StringView& name, float height, float weight, u32 baseExperience,
const ArbUt::List<uint8_t>& types, StatisticSet<uint16_t> baseStats, const ArbUt::List<u8>& types, StatisticSet<u16> baseStats,
const ArbUt::List<ArbUt::BorrowedPtr<const Talent>>& talents, const ArbUt::List<ArbUt::BorrowedPtr<const Talent>>& talents,
const ArbUt::List<ArbUt::BorrowedPtr<const Talent>>& secretTalents, const ArbUt::List<ArbUt::BorrowedPtr<const Talent>>& secretTalents,
const LearnableAttacks* attacks, const std::unordered_set<uint32_t>& flags) const LearnableAttacks* attacks, const std::unordered_set<u32>& flags)
: _impl(new impl(name, height, weight, baseExperience, types, baseStats, talents, secretTalents, attacks, : _impl(new impl(name, height, weight, baseExperience, types, baseStats, talents, secretTalents, attacks,
flags)) {} flags)) {}
SpeciesVariant::~SpeciesVariant() = default; SpeciesVariant::~SpeciesVariant() = default;
@ -115,11 +110,11 @@ namespace CreatureLib::Library {
ImplGetter(const ArbUt::StringView&, GetName); ImplGetter(const ArbUt::StringView&, GetName);
ImplGetter(float, GetHeight); ImplGetter(float, GetHeight);
ImplGetter(float, GetWeight); ImplGetter(float, GetWeight);
ImplGetter(uint32_t, GetBaseExperience); ImplGetter(u32, GetBaseExperience);
ImplGetter(size_t, GetTypeCount); ImplGetter(size_t, GetTypeCount);
uint8_t SpeciesVariant::GetType(size_t index) const { return _impl->GetType(index); } u8 SpeciesVariant::GetType(size_t index) const { return _impl->GetType(index); }
ImplGetter(const ArbUt::List<uint8_t>&, GetTypes); ImplGetter(const ArbUt::List<u8>&, GetTypes);
uint16_t SpeciesVariant::GetStatistic(Library::Statistic stat) const noexcept { return _impl->GetStatistic(stat); } u16 SpeciesVariant::GetStatistic(Library::Statistic stat) const noexcept { return _impl->GetStatistic(stat); }
ImplGetter(size_t, GetTalentCount); ImplGetter(size_t, GetTalentCount);
ImplGetter(size_t, GetSecretTalentCount); ImplGetter(size_t, GetSecretTalentCount);
@ -140,5 +135,5 @@ namespace CreatureLib::Library {
ImplGetter(const ArbUt::List<ArbUt::BorrowedPtr<const Talent>>&, GetSecretTalents); ImplGetter(const ArbUt::List<ArbUt::BorrowedPtr<const Talent>>&, GetSecretTalents);
bool SpeciesVariant::HasFlag(const ArbUt::StringView& key) const noexcept { return _impl->HasFlag(key); } bool SpeciesVariant::HasFlag(const ArbUt::StringView& key) const noexcept { return _impl->HasFlag(key); }
bool SpeciesVariant::HasFlag(uint32_t keyHash) const noexcept { return _impl->HasFlag(keyHash); } bool SpeciesVariant::HasFlag(u32 keyHash) const noexcept { return _impl->HasFlag(keyHash); }
} }

16
src/Library/CreatureData/SpeciesVariant.hpp
View File

@ -27,11 +27,11 @@ namespace CreatureLib::Library {
/// scripts when battling. /// scripts when battling.
/// @param attacks The attacks that this variant can learn. /// @param attacks The attacks that this variant can learn.
/// @param flags A set of flags for use by the developer. These can be used for easy grouping. /// @param flags A set of flags for use by the developer. These can be used for easy grouping.
SpeciesVariant(const ArbUt::StringView& name, float height, float weight, uint32_t baseExperience, SpeciesVariant(const ArbUt::StringView& name, float height, float weight, u32 baseExperience,
const ArbUt::List<uint8_t>& types, Library::StatisticSet<uint16_t> baseStats, const ArbUt::List<u8>& types, Library::StatisticSet<u16> baseStats,
const ArbUt::List<ArbUt::BorrowedPtr<const Talent>>& talents, const ArbUt::List<ArbUt::BorrowedPtr<const Talent>>& talents,
const ArbUt::List<ArbUt::BorrowedPtr<const Talent>>& secretTalents, const ArbUt::List<ArbUt::BorrowedPtr<const Talent>>& secretTalents,
const LearnableAttacks* attacks, const std::unordered_set<uint32_t>& flags = {}); const LearnableAttacks* attacks, const std::unordered_set<u32>& flags = {});
virtual ~SpeciesVariant(); virtual ~SpeciesVariant();
/// @brief Returns the unique name of the variant. /// @brief Returns the unique name of the variant.
@ -45,7 +45,7 @@ namespace CreatureLib::Library {
float GetWeight() const noexcept; float GetWeight() const noexcept;
/// @brief Returns the amount of base experience gained when defeating a creature with this variant. /// @brief Returns the amount of base experience gained when defeating a creature with this variant.
/// @return The amount of base experience gained when defeating a creature with this variant. /// @return The amount of base experience gained when defeating a creature with this variant.
uint32_t GetBaseExperience() const noexcept; u32 GetBaseExperience() const noexcept;
/// @brief Returns the amount of types this variant has. /// @brief Returns the amount of types this variant has.
/// @return The amount of types this variant has. /// @return The amount of types this variant has.
@ -53,14 +53,14 @@ namespace CreatureLib::Library {
/// @brief Returns a type index at a specified index. /// @brief Returns a type index at a specified index.
/// @param index The index of the type requested. /// @param index The index of the type requested.
/// @return A type index, as defined in TypeLibrary. /// @return A type index, as defined in TypeLibrary.
[[nodiscard]] uint8_t GetType(size_t index) const; [[nodiscard]] u8 GetType(size_t index) const;
/// @brief Returns a list of the types on this variant. /// @brief Returns a list of the types on this variant.
/// @return A list of types on the variant, /// @return A list of types on the variant,
[[nodiscard]] const ArbUt::List<uint8_t>& GetTypes() const noexcept; [[nodiscard]] const ArbUt::List<u8>& GetTypes() const noexcept;
/// @brief Returns the value of a base statistic. /// @brief Returns the value of a base statistic.
/// @param stat The desired statistic. /// @param stat The desired statistic.
/// @return The base statistic value. /// @return The base statistic value.
[[nodiscard]] uint16_t GetStatistic(Library::Statistic stat) const noexcept; [[nodiscard]] u16 GetStatistic(Library::Statistic stat) const noexcept;
/// @brief Returns the amount of talents this variant has. /// @brief Returns the amount of talents this variant has.
/// @return The amount of talents this variant has. /// @return The amount of talents this variant has.
@ -102,7 +102,7 @@ namespace CreatureLib::Library {
/// @brief Checks whether the species has a specific flag. /// @brief Checks whether the species has a specific flag.
/// @param keyHash The flag to check for. /// @param keyHash The flag to check for.
/// @return True if the species has the flag, false otherwise. /// @return True if the species has the flag, false otherwise.
bool HasFlag(uint32_t keyHash) const noexcept; bool HasFlag(u32 keyHash) const noexcept;
}; };
} }

6
src/Library/CreatureData/TalentIndex.hpp
View File

@ -10,17 +10,17 @@ namespace CreatureLib::Library {
/// @brief Initialises a Talent Index from whether or not this is a secret talent, and it's index. /// @brief Initialises a Talent Index from whether or not this is a secret talent, and it's index.
/// @param secret Whether or not this is a secret talent. /// @param secret Whether or not this is a secret talent.
/// @param index The index of the talent on the species variant. /// @param index The index of the talent on the species variant.
inline TalentIndex(bool secret, uint8_t index) noexcept : _secret(secret), _index(index) {} inline TalentIndex(bool secret, u8 index) noexcept : _secret(secret), _index(index) {}
/// @brief Returns whether or not this is a secret talent. /// @brief Returns whether or not this is a secret talent.
/// @return Whether or not this is a secret talent. /// @return Whether or not this is a secret talent.
[[nodiscard]] constexpr inline bool IsSecret() const noexcept { return _secret; } [[nodiscard]] constexpr inline bool IsSecret() const noexcept { return _secret; }
/// @brief Returns the index of the talent on the species variant. /// @brief Returns the index of the talent on the species variant.
/// @return The index of the talent on the species variant. /// @return The index of the talent on the species variant.
[[nodiscard]] constexpr inline uint8_t GetIndex() const noexcept { return _index; } [[nodiscard]] constexpr inline u8 GetIndex() const noexcept { return _index; }
private: private:
bool _secret = false; bool _secret = false;
uint8_t _index; u8 _index;
}; };
} }

12
src/Library/EffectParameter.hpp
View File

@ -12,12 +12,12 @@ namespace CreatureLib::Library {
class EffectParameter { class EffectParameter {
private: private:
EffectParameterType _type = EffectParameterType::None; EffectParameterType _type = EffectParameterType::None;
std::variant<bool, int64_t, float, ArbUt::StringView> _value; std::variant<bool, i64, float, ArbUt::StringView> _value;
public: public:
inline EffectParameter() : _type(EffectParameterType::None){}; inline EffectParameter() : _type(EffectParameterType::None){};
inline explicit EffectParameter(bool b) : _type(EffectParameterType::Bool), _value(b){}; inline explicit EffectParameter(bool b) : _type(EffectParameterType::Bool), _value(b){};
inline explicit EffectParameter(int64_t i) : _type(EffectParameterType::Int), _value(i){}; inline explicit EffectParameter(i64 i) : _type(EffectParameterType::Int), _value(i){};
inline explicit EffectParameter(float f) : _type(EffectParameterType::Float), _value(f){}; inline explicit EffectParameter(float f) : _type(EffectParameterType::Float), _value(f){};
inline explicit EffectParameter(const ArbUt::StringView& s) : _type(EffectParameterType::String), _value(s){}; inline explicit EffectParameter(const ArbUt::StringView& s) : _type(EffectParameterType::String), _value(s){};
EffectParameter(const EffectParameter& other) = delete; EffectParameter(const EffectParameter& other) = delete;
@ -30,19 +30,19 @@ namespace CreatureLib::Library {
} }
return std::get<bool>(_value); return std::get<bool>(_value);
} }
int64_t AsInt() const { i64 AsInt() const {
if (_type != EffectParameterType::Int) { if (_type != EffectParameterType::Int) {
if (_type == EffectParameterType::Float) { if (_type == EffectParameterType::Float) {
return static_cast<int64_t>(std::get<float>(_value)); return static_cast<i64>(std::get<float>(_value));
} }
THROW("Cast effect parameter to int, but was ", EffectParameterTypeHelper::ToString(_type)); THROW("Cast effect parameter to int, but was ", EffectParameterTypeHelper::ToString(_type));
} }
return std::get<int64_t>(_value); return std::get<i64>(_value);
} }
float AsFloat() const { float AsFloat() const {
if (_type != EffectParameterType::Float) { if (_type != EffectParameterType::Float) {
if (_type == EffectParameterType::Int) { if (_type == EffectParameterType::Int) {
return static_cast<float>(std::get<int64_t>(_value)); return static_cast<float>(std::get<i64>(_value));
} }
THROW("Cast effect parameter to float, but was ", EffectParameterTypeHelper::ToString(_type)); THROW("Cast effect parameter to float, but was ", EffectParameterTypeHelper::ToString(_type));
} }

2
src/Library/Gender.hpp
View File

@ -7,7 +7,7 @@ namespace CreatureLib::Library {
\brief Might be somewhat controversial nowadays, but as many creature battling games only have two genders, we'll \brief Might be somewhat controversial nowadays, but as many creature battling games only have two genders, we'll
hardcode those. hardcode those.
*/ */
ENUM(Gender, uint8_t, Male, Female, Genderless) ENUM(Gender, u8, Male, Female, Genderless)
} }
#endif // CREATURELIB_GENDER_HPP #endif // CREATURELIB_GENDER_HPP

10
src/Library/GrowthRates/ExternGrowthRate.hpp
View File

@ -7,18 +7,18 @@
namespace CreatureLib::Library { namespace CreatureLib::Library {
class ExternGrowthRate : public GrowthRate { class ExternGrowthRate : public GrowthRate {
level_int_t (*_calcLevel)(uint32_t experience); level_int_t (*_calcLevel)(u32 experience);
uint32_t (*_calcExperience)(level_int_t level); u32 (*_calcExperience)(level_int_t level);
public: public:
inline ExternGrowthRate(level_int_t (*calcLevel)(uint32_t), uint32_t (*calcExperience)(level_int_t level)) inline ExternGrowthRate(level_int_t (*calcLevel)(u32), u32 (*calcExperience)(level_int_t level))
: _calcLevel(calcLevel), _calcExperience(calcExperience) { : _calcLevel(calcLevel), _calcExperience(calcExperience) {
EnsureNotNull(calcLevel) EnsureNotNull(calcLevel)
EnsureNotNull(calcExperience) EnsureNotNull(calcExperience)
} }
level_int_t CalculateLevel(uint32_t experience) const override { return _calcLevel(experience); } level_int_t CalculateLevel(u32 experience) const override { return _calcLevel(experience); }
uint32_t CalculateExperience(level_int_t level) const override { return _calcExperience(level); } u32 CalculateExperience(level_int_t level) const override { return _calcExperience(level); }
}; };
} }

4
src/Library/GrowthRates/GrowthRate.hpp
View File

@ -9,8 +9,8 @@ namespace CreatureLib::Library {
public: public:
virtual ~GrowthRate() = default; virtual ~GrowthRate() = default;
[[nodiscard]] virtual level_int_t CalculateLevel(uint32_t experience) const = 0; [[nodiscard]] virtual level_int_t CalculateLevel(u32 experience) const = 0;
[[nodiscard]] virtual uint32_t CalculateExperience(level_int_t level) const = 0; [[nodiscard]] virtual u32 CalculateExperience(level_int_t level) const = 0;
}; };
} }

14
src/Library/GrowthRates/GrowthRateLibrary.cpp
View File

@ -2,8 +2,8 @@
#include <Arbutils/Exception.hpp> #include <Arbutils/Exception.hpp>
#include "../Exceptions/CreatureException.hpp" #include "../Exceptions/CreatureException.hpp"
uint8_t CreatureLib::Library::GrowthRateLibrary::CalculateLevel(const ArbUt::BasicStringView& growthRate, u8 CreatureLib::Library::GrowthRateLibrary::CalculateLevel(const ArbUt::BasicStringView& growthRate,
uint32_t experience) const { u32 experience) const {
auto find = _growthRates.find(growthRate); auto find = _growthRates.find(growthRate);
if (find == _growthRates.end()) { if (find == _growthRates.end()) {
THROW("Invalid growth rate was requested."); THROW("Invalid growth rate was requested.");
@ -11,7 +11,7 @@ uint8_t CreatureLib::Library::GrowthRateLibrary::CalculateLevel(const ArbUt::Bas
return find->second->CalculateLevel(experience); return find->second->CalculateLevel(experience);
} }
uint8_t CreatureLib::Library::GrowthRateLibrary::CalculateLevel(uint32_t hash, uint32_t experience) const { u8 CreatureLib::Library::GrowthRateLibrary::CalculateLevel(u32 hash, u32 experience) const {
auto find = _growthRates.find(hash); auto find = _growthRates.find(hash);
if (find == _growthRates.end()) { if (find == _growthRates.end()) {
THROW("Invalid growth rate was requested."); THROW("Invalid growth rate was requested.");
@ -19,8 +19,8 @@ uint8_t CreatureLib::Library::GrowthRateLibrary::CalculateLevel(uint32_t hash, u
return find->second->CalculateLevel(experience); return find->second->CalculateLevel(experience);
} }
uint32_t CreatureLib::Library::GrowthRateLibrary::CalculateExperience(const ArbUt::BasicStringView& growthRate, u32 CreatureLib::Library::GrowthRateLibrary::CalculateExperience(const ArbUt::BasicStringView& growthRate,
level_int_t level) const { level_int_t level) const {
auto find = _growthRates.find(growthRate); auto find = _growthRates.find(growthRate);
if (find == _growthRates.end()) { if (find == _growthRates.end()) {
THROW("Invalid growth rate was requested."); THROW("Invalid growth rate was requested.");
@ -28,7 +28,7 @@ uint32_t CreatureLib::Library::GrowthRateLibrary::CalculateExperience(const ArbU
return find->second->CalculateExperience(level); return find->second->CalculateExperience(level);
} }
uint32_t CreatureLib::Library::GrowthRateLibrary::CalculateExperience(uint32_t hash, level_int_t level) const { u32 CreatureLib::Library::GrowthRateLibrary::CalculateExperience(u32 hash, level_int_t level) const {
auto find = _growthRates.find(hash); auto find = _growthRates.find(hash);
if (find == _growthRates.end()) { if (find == _growthRates.end()) {
THROW("Invalid growth rate was requested."); THROW("Invalid growth rate was requested.");
@ -41,6 +41,6 @@ void CreatureLib::Library::GrowthRateLibrary::AddGrowthRate(const ArbUt::StringV
_growthRates.insert({name, std::unique_ptr<const GrowthRate>(rate)}); _growthRates.insert({name, std::unique_ptr<const GrowthRate>(rate)});
} }
void CreatureLib::Library::GrowthRateLibrary::AddGrowthRate(uint32_t hash, CreatureLib::Library::GrowthRate* rate) { void CreatureLib::Library::GrowthRateLibrary::AddGrowthRate(u32 hash, CreatureLib::Library::GrowthRate* rate) {
_growthRates.insert({hash, std::unique_ptr<const GrowthRate>(rate)}); _growthRates.insert({hash, std::unique_ptr<const GrowthRate>(rate)});
} }

14
src/Library/GrowthRates/GrowthRateLibrary.hpp
View File

@ -8,20 +8,20 @@
namespace CreatureLib::Library { namespace CreatureLib::Library {
class GrowthRateLibrary { class GrowthRateLibrary {
private: private:
std::unordered_map<uint32_t, std::unique_ptr<const GrowthRate>> _growthRates; std::unordered_map<u32, std::unique_ptr<const GrowthRate>> _growthRates;
public: public:
GrowthRateLibrary(size_t initialCapacity = 10) GrowthRateLibrary(size_t initialCapacity = 10)
: _growthRates(std::unordered_map<uint32_t, std::unique_ptr<const GrowthRate>>(initialCapacity)) {} : _growthRates(std::unordered_map<u32, std::unique_ptr<const GrowthRate>>(initialCapacity)) {}
virtual ~GrowthRateLibrary() = default; virtual ~GrowthRateLibrary() = default;
[[nodiscard]] level_int_t CalculateLevel(const ArbUt::BasicStringView& growthRate, uint32_t experience) const; [[nodiscard]] level_int_t CalculateLevel(const ArbUt::BasicStringView& growthRate, u32 experience) const;
[[nodiscard]] level_int_t CalculateLevel(uint32_t hash, uint32_t experience) const; [[nodiscard]] level_int_t CalculateLevel(u32 hash, u32 experience) const;
[[nodiscard]] uint32_t CalculateExperience(const ArbUt::BasicStringView& growthRate, level_int_t level) const; [[nodiscard]] u32 CalculateExperience(const ArbUt::BasicStringView& growthRate, level_int_t level) const;
[[nodiscard]] uint32_t CalculateExperience(uint32_t hash, level_int_t level) const; [[nodiscard]] u32 CalculateExperience(u32 hash, level_int_t level) const;
void AddGrowthRate(uint32_t hash, GrowthRate* rate); void AddGrowthRate(u32 hash, GrowthRate* rate);
void AddGrowthRate(const ArbUt::StringView& name, GrowthRate* rate); void AddGrowthRate(const ArbUt::StringView& name, GrowthRate* rate);
}; };
} }

8
src/Library/GrowthRates/LookupGrowthRate.hpp
View File

@ -7,12 +7,12 @@
namespace CreatureLib::Library { namespace CreatureLib::Library {
class LookupGrowthRate : public GrowthRate { class LookupGrowthRate : public GrowthRate {
protected: protected:
ArbUt::List<uint32_t> _experience; ArbUt::List<u32> _experience;
public: public:
LookupGrowthRate(const ArbUt::List<uint32_t>& experience) : _experience(experience) {} LookupGrowthRate(const ArbUt::List<u32>& experience) : _experience(experience) {}
level_int_t CalculateLevel(uint32_t experience) const override { level_int_t CalculateLevel(u32 experience) const override {
for (level_int_t i = 0; i < (level_int_t)_experience.Count(); i++) { for (level_int_t i = 0; i < (level_int_t)_experience.Count(); i++) {
if (_experience[i] > experience) { if (_experience[i] > experience) {
return i; return i;
@ -21,7 +21,7 @@ namespace CreatureLib::Library {
return _experience.Count() - 1; return _experience.Count() - 1;
} }
uint32_t CalculateExperience(level_int_t level) const override { return _experience[level - 1]; } u32 CalculateExperience(level_int_t level) const override { return _experience[level - 1]; }
}; };
} }

2
src/Library/Items/BattleItemCategory.hpp
View File

@ -2,7 +2,7 @@
#define CREATURELIB_BATTLEITEMCATEGORY_HPP #define CREATURELIB_BATTLEITEMCATEGORY_HPP
namespace CreatureLib::Library { namespace CreatureLib::Library {
ENUM(BattleItemCategory, uint8_t, None, Healing, StatusHealing, CaptureDevice, MiscBattleItem) ENUM(BattleItemCategory, u8, None, Healing, StatusHealing, CaptureDevice, MiscBattleItem)
} }
#endif // CREATURELIB_BATTLEITEMCATEGORY_HPP #endif // CREATURELIB_BATTLEITEMCATEGORY_HPP

22
src/Library/Items/Item.cpp
View File

@ -5,41 +5,41 @@ namespace CreatureLib::Library {
ArbUt::StringView _name; ArbUt::StringView _name;
ItemCategory _category; ItemCategory _category;
BattleItemCategory _battleCategory; BattleItemCategory _battleCategory;
int32_t _price; i32 _price;
ArbUt::OptionalUniquePtr<const SecondaryEffect> _effect = nullptr; ArbUt::OptionalUniquePtr<const SecondaryEffect> _effect = nullptr;
ArbUt::OptionalUniquePtr<const SecondaryEffect> _battleTriggerEffect = nullptr; ArbUt::OptionalUniquePtr<const SecondaryEffect> _battleTriggerEffect = nullptr;
std::unordered_set<uint32_t> _flags; std::unordered_set<u32> _flags;
public: public:
inline impl(const ArbUt::StringView& name, ItemCategory category, BattleItemCategory battleCategory, inline impl(const ArbUt::StringView& name, ItemCategory category, BattleItemCategory battleCategory, i32 price,
int32_t price, const SecondaryEffect* effect, const SecondaryEffect* battleTriggerEffect, const SecondaryEffect* effect, const SecondaryEffect* battleTriggerEffect,
const std::unordered_set<uint32_t>& flags) noexcept const std::unordered_set<u32>& flags) noexcept
: _name(name), _category(category), _battleCategory(battleCategory), _price(price), _effect(effect), : _name(name), _category(category), _battleCategory(battleCategory), _price(price), _effect(effect),
_battleTriggerEffect(battleTriggerEffect), _flags(flags) {} _battleTriggerEffect(battleTriggerEffect), _flags(flags) {}
inline const ArbUt::StringView& GetName() const noexcept { return _name; } inline const ArbUt::StringView& GetName() const noexcept { return _name; }
inline ItemCategory GetCategory() const noexcept { return _category; } inline ItemCategory GetCategory() const noexcept { return _category; }
inline BattleItemCategory GetBattleCategory() const noexcept { return _battleCategory; } inline BattleItemCategory GetBattleCategory() const noexcept { return _battleCategory; }
inline int32_t GetPrice() const noexcept { return _price; } inline i32 GetPrice() const noexcept { return _price; }
inline const ArbUt::OptionalUniquePtr<const SecondaryEffect>& GetEffect() const noexcept { return _effect; } inline const ArbUt::OptionalUniquePtr<const SecondaryEffect>& GetEffect() const noexcept { return _effect; }
inline const ArbUt::OptionalUniquePtr<const SecondaryEffect>& GetBattleTriggerEffect() const noexcept { inline const ArbUt::OptionalUniquePtr<const SecondaryEffect>& GetBattleTriggerEffect() const noexcept {
return _battleTriggerEffect; return _battleTriggerEffect;
} }
inline bool HasFlag(const ArbUt::BasicStringView& flag) const noexcept { return this->_flags.contains(flag); } inline bool HasFlag(const ArbUt::BasicStringView& flag) const noexcept { return this->_flags.contains(flag); }
inline bool HasFlag(uint32_t flag) const noexcept { return this->_flags.contains(flag); } inline bool HasFlag(u32 flag) const noexcept { return this->_flags.contains(flag); }
}; };
Item::Item(const ArbUt::StringView& name, ItemCategory category, BattleItemCategory battleCategory, int32_t price, Item::Item(const ArbUt::StringView& name, ItemCategory category, BattleItemCategory battleCategory, i32 price,
const SecondaryEffect* effect, const SecondaryEffect* battleTriggerEffect, const SecondaryEffect* effect, const SecondaryEffect* battleTriggerEffect,
const std::unordered_set<uint32_t>& flags) noexcept const std::unordered_set<u32>& flags) noexcept
: _impl(new impl(name, category, battleCategory, price, effect, battleTriggerEffect, flags)) {} : _impl(new impl(name, category, battleCategory, price, effect, battleTriggerEffect, flags)) {}
Item::~Item() = default; Item::~Item() = default;
const ArbUt::StringView& Item::GetName() const noexcept { return _impl->GetName(); } const ArbUt::StringView& Item::GetName() const noexcept { return _impl->GetName(); }
ItemCategory Item::GetCategory() const noexcept { return _impl->GetCategory(); } ItemCategory Item::GetCategory() const noexcept { return _impl->GetCategory(); }
BattleItemCategory Item::GetBattleCategory() const noexcept { return _impl->GetBattleCategory(); } BattleItemCategory Item::GetBattleCategory() const noexcept { return _impl->GetBattleCategory(); }
int32_t Item::GetPrice() const noexcept { return _impl->GetPrice(); } i32 Item::GetPrice() const noexcept { return _impl->GetPrice(); }
const ArbUt::OptionalUniquePtr<const SecondaryEffect>& Item::GetEffect() const noexcept { const ArbUt::OptionalUniquePtr<const SecondaryEffect>& Item::GetEffect() const noexcept {
return _impl->GetEffect(); return _impl->GetEffect();
} }
@ -48,6 +48,6 @@ namespace CreatureLib::Library {
} }
bool Item::HasFlag(const ArbUt::BasicStringView& flag) const noexcept { return _impl->HasFlag(flag); } bool Item::HasFlag(const ArbUt::BasicStringView& flag) const noexcept { return _impl->HasFlag(flag); }
bool Item::HasFlag(uint32_t flag) const noexcept { return _impl->HasFlag(flag); } bool Item::HasFlag(u32 flag) const noexcept { return _impl->HasFlag(flag); }
} }

8
src/Library/Items/Item.hpp
View File

@ -15,9 +15,9 @@ namespace CreatureLib::Library {
std::unique_ptr<impl> _impl; std::unique_ptr<impl> _impl;
public: public:
Item(const ArbUt::StringView& name, ItemCategory category, BattleItemCategory battleCategory, int32_t price, Item(const ArbUt::StringView& name, ItemCategory category, BattleItemCategory battleCategory, i32 price,
const SecondaryEffect* effect, const SecondaryEffect* battleTriggerEffect, const SecondaryEffect* effect, const SecondaryEffect* battleTriggerEffect,
const std::unordered_set<uint32_t>& flags) noexcept; const std::unordered_set<u32>& flags) noexcept;
NO_COPY_OR_MOVE(Item) NO_COPY_OR_MOVE(Item)
virtual ~Item(); virtual ~Item();
@ -25,12 +25,12 @@ namespace CreatureLib::Library {
const ArbUt::StringView& GetName() const noexcept; const ArbUt::StringView& GetName() const noexcept;
ItemCategory GetCategory() const noexcept; ItemCategory GetCategory() const noexcept;
BattleItemCategory GetBattleCategory() const noexcept; BattleItemCategory GetBattleCategory() const noexcept;
int32_t GetPrice() const noexcept; i32 GetPrice() const noexcept;
const ArbUt::OptionalUniquePtr<const SecondaryEffect>& GetEffect() const noexcept; const ArbUt::OptionalUniquePtr<const SecondaryEffect>& GetEffect() const noexcept;
const ArbUt::OptionalUniquePtr<const SecondaryEffect>& GetBattleTriggerEffect() const noexcept; const ArbUt::OptionalUniquePtr<const SecondaryEffect>& GetBattleTriggerEffect() const noexcept;
bool HasFlag(const ArbUt::BasicStringView& flag) const noexcept; bool HasFlag(const ArbUt::BasicStringView& flag) const noexcept;
bool HasFlag(uint32_t flag) const noexcept; bool HasFlag(u32 flag) const noexcept;
}; };
} }

2
src/Library/Items/ItemCategory.hpp
View File

@ -2,7 +2,7 @@
#define CREATURELIB_ITEMCATEGORY_HPP #define CREATURELIB_ITEMCATEGORY_HPP
namespace CreatureLib::Library { namespace CreatureLib::Library {
ENUM(ItemCategory, uint8_t, MiscItem, CaptureDevice, Medicine, Berry, MoveLearner, VariantChanger, KeyItem, Mail) ENUM(ItemCategory, u8, MiscItem, CaptureDevice, Medicine, Berry, MoveLearner, VariantChanger, KeyItem, Mail)
} }
#endif // CREATURELIB_ITEMCATEGORY_HPP #endif // CREATURELIB_ITEMCATEGORY_HPP

10
src/Library/LibrarySettings.cpp
View File

@ -3,20 +3,20 @@
namespace CreatureLib::Library { namespace CreatureLib::Library {
struct LibrarySettings::impl { struct LibrarySettings::impl {
level_int_t _maximalLevel; level_int_t _maximalLevel;
uint8_t _maximalAttacks; u8 _maximalAttacks;
public: public:
impl(level_int_t maximalLevel, uint8_t maximalAttacks) impl(level_int_t maximalLevel, u8 maximalAttacks)
: _maximalLevel(maximalLevel), _maximalAttacks(maximalAttacks) {} : _maximalLevel(maximalLevel), _maximalAttacks(maximalAttacks) {}
[[nodiscard]] inline level_int_t GetMaximalLevel() const noexcept { return _maximalLevel; } [[nodiscard]] inline level_int_t GetMaximalLevel() const noexcept { return _maximalLevel; }
[[nodiscard]] inline uint8_t GetMaximalAttacks() const noexcept { return _maximalAttacks; } [[nodiscard]] inline u8 GetMaximalAttacks() const noexcept { return _maximalAttacks; }
}; };
LibrarySettings::LibrarySettings(level_int_t maximalLevel, uint8_t maximalAttacks) LibrarySettings::LibrarySettings(level_int_t maximalLevel, u8 maximalAttacks)
: _impl(new impl(maximalLevel, maximalAttacks)) {} : _impl(new impl(maximalLevel, maximalAttacks)) {}
LibrarySettings::~LibrarySettings() = default; LibrarySettings::~LibrarySettings() = default;
level_int_t LibrarySettings::GetMaximalLevel() const noexcept { return _impl->GetMaximalLevel(); } level_int_t LibrarySettings::GetMaximalLevel() const noexcept { return _impl->GetMaximalLevel(); }
uint8_t LibrarySettings::GetMaximalAttacks() const noexcept { return _impl->GetMaximalAttacks(); } u8 LibrarySettings::GetMaximalAttacks() const noexcept { return _impl->GetMaximalAttacks(); }
} }

4
src/Library/LibrarySettings.hpp
View File

@ -14,7 +14,7 @@ namespace CreatureLib::Library {
/// @brief Initialises LibrarySettings. /// @brief Initialises LibrarySettings.
/// @param maximalLevel The maximal level a creature can be. /// @param maximalLevel The maximal level a creature can be.
/// @param maximalAttacks The maximal number of attacks a creature can have. /// @param maximalAttacks The maximal number of attacks a creature can have.
LibrarySettings(level_int_t maximalLevel, uint8_t maximalAttacks); LibrarySettings(level_int_t maximalLevel, u8 maximalAttacks);
virtual ~LibrarySettings(); virtual ~LibrarySettings();
/// @brief Returns the maximal level a creature can be in the current library. /// @brief Returns the maximal level a creature can be in the current library.
@ -22,7 +22,7 @@ namespace CreatureLib::Library {
[[nodiscard]] level_int_t GetMaximalLevel() const noexcept; [[nodiscard]] level_int_t GetMaximalLevel() const noexcept;
/// @brief Returns the maximal number of attacks a creature can have. /// @brief Returns the maximal number of attacks a creature can have.
/// @return The maximal number of attacks a creature can have. /// @return The maximal number of attacks a creature can have.
[[nodiscard]] uint8_t GetMaximalAttacks() const noexcept; [[nodiscard]] u8 GetMaximalAttacks() const noexcept;
}; };
} }

6
src/Library/SpeciesLibrary.hpp
View File

@ -7,7 +7,7 @@
namespace CreatureLib::Library { namespace CreatureLib::Library {
class SpeciesLibrary : public BaseLibrary<CreatureSpecies> { class SpeciesLibrary : public BaseLibrary<CreatureSpecies> {
private: private:
ArbUt::Dictionary<uint16_t, ArbUt::BorrowedPtr<const CreatureSpecies>> _valuesById; ArbUt::Dictionary<u16, ArbUt::BorrowedPtr<const CreatureSpecies>> _valuesById;
public: public:
SpeciesLibrary(size_t initialCapacity = 32) : BaseLibrary(initialCapacity){}; SpeciesLibrary(size_t initialCapacity = 32) : BaseLibrary(initialCapacity){};
@ -16,12 +16,12 @@ namespace CreatureLib::Library {
BaseLibrary::Insert(key, value); BaseLibrary::Insert(key, value);
_valuesById.Insert(value->GetId(), value); _valuesById.Insert(value->GetId(), value);
} }
void Insert(uint32_t hashedKey, const CreatureSpecies* value) override { void Insert(u32 hashedKey, const CreatureSpecies* value) override {
BaseLibrary::Insert(hashedKey, value); BaseLibrary::Insert(hashedKey, value);
_valuesById.Insert(value->GetId(), value); _valuesById.Insert(value->GetId(), value);
} }
const ArbUt::BorrowedPtr<const CreatureSpecies>& GetById(uint16_t id) const { return _valuesById[id]; } const ArbUt::BorrowedPtr<const CreatureSpecies>& GetById(u16 id) const { return _valuesById[id]; }
}; };
} }

2
src/Library/Statistic.hpp
View File

@ -3,7 +3,7 @@
#include <Arbutils/Enum.hpp> #include <Arbutils/Enum.hpp>
namespace CreatureLib::Library { namespace CreatureLib::Library {
ENUM(Statistic, uint8_t, Health, PhysicalAttack, PhysicalDefense, MagicalAttack, MagicalDefense, Speed) ENUM(Statistic, u8, Health, PhysicalAttack, PhysicalDefense, MagicalAttack, MagicalDefense, Speed)
} }
#endif // CREATURELIB_STATISTIC_HPP #endif // CREATURELIB_STATISTIC_HPP

8
src/Library/TypeLibrary.cpp
View File

@ -2,7 +2,7 @@
using namespace CreatureLib::Library; using namespace CreatureLib::Library;
uint8_t TypeLibrary::RegisterType(const ArbUt::StringView& key) { u8 TypeLibrary::RegisterType(const ArbUt::StringView& key) {
_types.Insert(key, _types.Count()); _types.Insert(key, _types.Count());
_effectiveness.Resize(_types.Count()); _effectiveness.Resize(_types.Count());
for (auto& eff : _effectiveness) { for (auto& eff : _effectiveness) {
@ -11,14 +11,14 @@ uint8_t TypeLibrary::RegisterType(const ArbUt::StringView& key) {
return _types.Count() - 1; return _types.Count() - 1;
} }
void TypeLibrary::SetEffectiveness(uint8_t attacking, uint8_t defensive, float effectiveness) { void TypeLibrary::SetEffectiveness(u8 attacking, u8 defensive, float effectiveness) {
_effectiveness[attacking][defensive] = effectiveness; _effectiveness[attacking][defensive] = effectiveness;
} }
const ArbUt::StringView& TypeLibrary::GetTypeName(uint8_t type) const { const ArbUt::StringView& TypeLibrary::GetTypeName(u8 type) const {
for (auto& kv : _types) { for (auto& kv : _types) {
if (kv.second == type) { if (kv.second == type) {
return kv.first; return kv.first;
} }
} }
THROW("Name requested for unknown type: ", (uint32_t)type); THROW("Name requested for unknown type: ", (u32)type);
} }

14
src/Library/TypeLibrary.hpp
View File

@ -16,25 +16,25 @@ namespace CreatureLib::Library {
public: public:
TypeLibrary(size_t initialCapacity = 20) : _types(ArbUt::Dictionary<ArbUt::StringView, u8>(initialCapacity)) {} TypeLibrary(size_t initialCapacity = 20) : _types(ArbUt::Dictionary<ArbUt::StringView, u8>(initialCapacity)) {}
inline uint8_t GetTypeId(const ArbUt::StringView& key) const { return _types.Get(key); } inline u8 GetTypeId(const ArbUt::StringView& key) const { return _types.Get(key); }
[[nodiscard]] inline float GetSingleEffectiveness(u8 attacking, u8 defensive) const { [[nodiscard]] inline float GetSingleEffectiveness(u8 attacking, u8 defensive) const {
try { try {
return _effectiveness[attacking][defensive]; return _effectiveness[attacking][defensive];
} catch (const std::exception& e) { } catch (const std::exception& e) {
THROW("Unknown type indices were requested for effectiveness: ", (uint32_t)attacking, " and ", THROW("Unknown type indices were requested for effectiveness: ", (u32)attacking, " and ",
(uint32_t)defensive); (u32)defensive);
} }
} }
[[nodiscard]] inline float GetEffectiveness(uint8_t attacking, const std::vector<u8>& defensive) const { [[nodiscard]] inline float GetEffectiveness(u8 attacking, const std::vector<u8>& defensive) const {
return std::accumulate(defensive.begin(), defensive.end(), (float)1, return std::accumulate(defensive.begin(), defensive.end(), (float)1,
[this, attacking](float init, uint8_t defense) { [this, attacking](float init, u8 defense) {
return init * GetSingleEffectiveness(attacking, defense); return init * GetSingleEffectiveness(attacking, defense);
}); });
} }
const ArbUt::StringView& GetTypeName(u8 type) const; const ArbUt::StringView& GetTypeName(u8 type) const;
uint8_t RegisterType(const ArbUt::StringView& typeName); u8 RegisterType(const ArbUt::StringView& typeName);
void SetEffectiveness(uint8_t attacking, u8 defensive, float effectiveness); void SetEffectiveness(u8 attacking, u8 defensive, float effectiveness);
}; };
} }

2
tests/LibraryTests/EffectParameterTests.cpp
View File

@ -11,7 +11,7 @@ TEST_CASE("Bool EffectParameter") {
} }
TEST_CASE("Int EffectParameter") { TEST_CASE("Int EffectParameter") {
auto p = EffectParameter((int64_t)684); auto p = EffectParameter((i64)684);
REQUIRE(p.AsInt() == 684); REQUIRE(p.AsInt() == 684);
REQUIRE(p.AsFloat() == 684); REQUIRE(p.AsFloat() == 684);
} }

Some files were not shown because too many files have changed in this diff Show More