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

Rework for C Interfaces to handle exceptions a bit better.
continuous-integration/drone/push Build is passing Details

This commit is contained in:
Deukhoofd 2020-03-25 19:07:36 +01:00
parent 27288563cd
commit 7ce3e6940d
Signed by: Deukhoofd
GPG Key ID: ADF2E9256009EDCE
53 changed files with 7526 additions and 8340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
CInterface/Battling/Battle.cpp
View File

@ -1,39 +1,45 @@
#include "../../src/Battling/Models/Battle.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Battling;
export Battle* CreatureLib_Battle_Construct(const BattleLibrary* library, BattleParty* partyArr[],
export uint8_t CreatureLib_Battle_Construct(Battle*& out, const BattleLibrary* library, BattleParty* partyArr[],
size_t numberOfParties, bool canFlee, uint8_t numberOfSides,
uint8_t creaturesPerSide) {
List<BattleParty*> parties(partyArr, partyArr + numberOfParties);
return new Battle(library, parties, canFlee, numberOfSides, creaturesPerSide);
Try(List<BattleParty*> parties(partyArr, partyArr + numberOfParties);
out = new Battle(library, parties, canFlee, numberOfSides, creaturesPerSide);)
}
export void CreatureLib_Battle_Destruct(const Battle* p) { delete p; }
export const BattleLibrary* CreatureLib_Battle_GetLibrary(const Battle* p) { return p->GetLibrary(); }
export bool CreatureLib_Battle_CanUse(Battle* p, const BaseTurnChoice* turnChoice) { return p->CanUse(turnChoice); }
export bool CreatureLib_Battle_TrySetChoice(Battle* p, BaseTurnChoice* turnChoice) {
return p->TrySetChoice(turnChoice);
export uint8_t CreatureLib_Battle_CanUse(bool& out, Battle* p, const BaseTurnChoice* turnChoice) {
Try(out = p->CanUse(turnChoice);)
}
export uint8_t CreatureLib_Battle_TrySetChoice(bool& out, Battle* p, BaseTurnChoice* turnChoice) {
Try(out = p->TrySetChoice(turnChoice);)
}
export bool CreatureLib_Battle_CanFlee(const Battle* p) { return p->CanFlee(); }
export void CreatureLib_Battle_CheckChoicesSetAndRun(Battle* p) { p->CheckChoicesSetAndRun(); }
export uint8_t CreatureLib_Battle_CheckChoicesSetAndRun(Battle* p) { Try(p->CheckChoicesSetAndRun();) }
export ChoiceQueue* CreatureLib_Battle_GetCurrentTurnQueue(const Battle* p) { return p->GetCurrentTurnQueue(); }
export BattleRandom* CreatureLib_Battle_GetRandom(Battle* p) { return p->GetRandom(); }
export bool CreatureLib_Battle_CreatureInField(const Battle* p, Creature* c) { return p->CreatureInField(c); }
export Creature* CreatureLib_Battle_GetCreature(const Battle* p, uint8_t side, uint8_t target) {
return p->GetCreature(side, target);
export uint8_t CreatureLib_Battle_CreatureInField(bool& out, const Battle* p, Creature* c) {
Try(out = p->CreatureInField(c);)
}
export uint8_t CreatureLib_Battle_GetCreature(Creature*& out, const Battle* p, uint8_t side, uint8_t target) {
Try(out = p->GetCreature(side, target);)
}
export void CreatureLib_Battle_ForceRecall(Battle* p, uint8_t side, uint8_t target) { p->ForceRecall(side, target); }
export void CreatureLib_Battle_SwitchCreature(Battle* p, uint8_t side, uint8_t target, Creature* c) {
p->SwitchCreature(side, target, c);
export uint8_t CreatureLib_Battle_ForceRecall(Battle* p, uint8_t side, uint8_t target) {
Try(p->ForceRecall(side, target);)
}
export bool CreatureLib_Battle_CanSlotBeFilled(const Battle* p, uint8_t side, uint8_t target) {
return p->CanSlotBeFilled(side, target);
export uint8_t CreatureLib_Battle_SwitchCreature(Battle* p, uint8_t side, uint8_t target, Creature* c) {
Try(p->SwitchCreature(side, target, c);)
}
export void CreatureLib_Battle_ValidateBattleState(Battle* p) { p->ValidateBattleState(); }
export uint8_t CreatureLib_Battle_CanSlotBeFilled(bool& out, const Battle* p, uint8_t side, uint8_t target) {
Try(out = p->CanSlotBeFilled(side, target);)
}
export uint8_t CreatureLib_Battle_ValidateBattleState(Battle* p) { Try(p->ValidateBattleState();) }
export bool CreatureLib_Battle_HasEnded(const Battle* p) { return p->HasEnded(); }
export bool CreatureLib_Battle_HasConclusiveResult(const Battle* p) { return p->GetResult().IsConclusiveResult(); }
@ -45,22 +51,24 @@ export BattleSide* const* CreatureLib_Battle_GetSides(const Battle* p) { return
export Script* CreatureLib_Battle_GetVolatileScript(Battle* p, const char* key) {
return p->GetVolatileScript(ConstString::GetHash(key));
}
export void CreatureLib_Battle_AddVolatileScriptByName(Battle* p, const char* key) {
p->AddVolatileScript(ConstString(key));
export uint8_t CreatureLib_Battle_AddVolatileScriptByName(Battle* p, const char* key) {
Try(p->AddVolatileScript(ConstString(key));)
}
export void CreatureLib_Battle_AddVolatileScript(Battle* p, Script* script) { p->AddVolatileScript(script); }
export uint8_t CreatureLib_Battle_AddVolatileScript(Battle* p, Script* script) { Try(p->AddVolatileScript(script);) }
export void CreatureLib_Battle_RemoveVolatileScript(Battle* p, const char* key) {
p->RemoveVolatileScript(ConstString::GetHash(key));
export uint8_t CreatureLib_Battle_RemoveVolatileScript(Battle* p, const char* key) {
Try(p->RemoveVolatileScript(ConstString::GetHash(key));)
}
export void CreatureLib_Battle_RemoveVolatileScriptWithScript(Battle* p, Script* script) {
p->RemoveVolatileScript(script);
export uint8_t CreatureLib_Battle_RemoveVolatileScriptWithScript(Battle* p, Script* script) {
Try(p->RemoveVolatileScript(script);)
}
export bool CreatureLib_Battle_HasVolatileScript(Battle* p, const char* key) {
return p->HasVolatileScript(ConstString::GetHash(key));
}
export void CreatureLib_Battle_RegisterEventListener(Battle* p, void (*func)(const EventData*)) {
p->RegisterEventListener(func);
export uint8_t CreatureLib_Battle_RegisterEventListener(Battle* p, void (*func)(const EventData*)) {
Try(p->RegisterEventListener(func);)
}
export uint8_t CreatureLib_Battle_TriggerEventListener(Battle* p, EventData* data) {
Try(p->TriggerEventListener(data);)
}
export void CreatureLib_Battle_TriggerEventListener(Battle* p, EventData* data) { p->TriggerEventListener(data); }

2
CInterface/Battling/BattleLibrary.cpp
View File

@ -1,5 +1,5 @@
#include "../../src/Battling/Library/BattleLibrary.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Battling;
export const BattleLibrary* CreatureLib_BattleLibrary_Construct(const CreatureLib::Library::DataLibrary* staticLib,

20
CInterface/Battling/BattleParty.cpp
View File

@ -1,22 +1,22 @@
#include "../../src/Battling/Models/BattleParty.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Battling;
// Note that creatureIndices should be twice the size of numberOfIndices, and have index of side, index of creature on
// side, one after the other.
export BattleParty* CreatureLib_BattleParty_Construct(CreatureParty* p, uint8_t creatureIndices[],
size_t numberOfIndices) {
Arbutils::Collections::List<CreatureIndex> indices(numberOfIndices);
for (size_t i = 0; i < numberOfIndices; i++) {
indices[i] = CreatureIndex(creatureIndices[i * 2], creatureIndices[i * 2 + 1]);
}
return new BattleParty(p, indices);
export uint8_t CreatureLib_BattleParty_Construct(BattleParty*& out, CreatureParty* p, uint8_t creatureIndices[],
size_t numberOfIndices) {
Try(Arbutils::Collections::List<CreatureIndex> indices(numberOfIndices);
for (size_t i = 0; i < numberOfIndices; i++) {
indices[i] = CreatureIndex(creatureIndices[i * 2], creatureIndices[i * 2 + 1]);
} out = new BattleParty(p, indices);)
}
export void CreatureLib_BattleParty_Destruct(const BattleParty* p) { delete p; }
export bool CreatureLib_BattleParty_IsResponsibleForIndex(const BattleParty* p, uint8_t side, uint8_t creature) {
return p->IsResponsibleForIndex(side, creature);
export uint8_t CreatureLib_BattleParty_IsResponsibleForIndex(bool& out, const BattleParty* p, uint8_t side,
uint8_t creature) {
Try(out = p->IsResponsibleForIndex(side, creature);)
}
export bool CreatureLib_BattleParty_HasCreaturesNotInField(const BattleParty* p) { return p->HasCreaturesNotInField(); }

16
CInterface/Battling/BattleStatCalculator.cpp
View File

@ -1,16 +1,18 @@
#include "../../src/Battling/Library/BattleStatCalculator.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Battling;
export const BattleStatCalculator* CreatureLib_BattleStatCalculator_Construct() { return new BattleStatCalculator(); }
export void CreatureLib_BattleStatCalculator_Destruct(const BattleStatCalculator* p) { delete p; }
export uint32_t CreatureLib_BattleStatCalculator_CalculateFlatStat(const BattleStatCalculator* p, Creature* creature,
CreatureLib::Library::Statistic stat) {
return p->CalculateFlatStat(creature, stat);
export uint8_t CreatureLib_BattleStatCalculator_CalculateFlatStat(uint32_t& out, const BattleStatCalculator* p,
Creature* creature,
CreatureLib::Library::Statistic stat) {
Try(out = p->CalculateFlatStat(creature, stat);)
}
export uint32_t CreatureLib_BattleStatCalculator_CalculateBoostedStat(const BattleStatCalculator* p, Creature* creature,
CreatureLib::Library::Statistic stat) {
return p->CalculateBoostedStat(creature, stat);
export uint8_t CreatureLib_BattleStatCalculator_CalculateBoostedStat(uint32_t& out, const BattleStatCalculator* p,
Creature* creature,
CreatureLib::Library::Statistic stat) {
Try(out = p->CalculateBoostedStat(creature, stat);)
}

65
CInterface/Battling/Creature.cpp
View File

@ -1,18 +1,18 @@
#include "../../src/Battling/Models/Creature.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Battling;
using ConstString = Arbutils::CaseInsensitiveConstString;
export Creature* CreatureLib_Creature_Construct(const BattleLibrary* library,
const CreatureLib::Library::CreatureSpecies* species,
const CreatureLib::Library::SpeciesVariant* variant, uint8_t level,
uint32_t experience, uint32_t uid, CreatureLib::Library::Gender gender,
uint8_t coloring, const CreatureLib::Library::Item* heldItem,
std::string nickname, bool secretTalent, const uint8_t talent,
LearnedAttack* attacks[], size_t attacksNum) {
auto attacksVec = List<LearnedAttack*>(attacks, attacks + attacksNum);
return new Creature(library, species, variant, level, experience, uid, gender, coloring, heldItem, nickname,
CreatureLib::Library::TalentIndex(secretTalent, talent), attacksVec);
export uint8_t CreatureLib_Creature_Construct(Creature*& out, const BattleLibrary* library,
const CreatureLib::Library::CreatureSpecies* species,
const CreatureLib::Library::SpeciesVariant* variant, uint8_t level,
uint32_t experience, uint32_t uid, CreatureLib::Library::Gender gender,
uint8_t coloring, const CreatureLib::Library::Item* heldItem,
std::string nickname, bool secretTalent, const uint8_t talent,
LearnedAttack* attacks[], size_t attacksNum) {
Try(auto attacksVec = List<LearnedAttack*>(attacks, attacks + attacksNum);
out = new Creature(library, species, variant, level, experience, uid, gender, coloring, heldItem, nickname,
CreatureLib::Library::TalentIndex(secretTalent, talent), attacksVec);)
};
export void CreatureLib_Creature_Destruct(const Creature* p) { delete p; }
@ -32,10 +32,10 @@ export bool CreatureLib_Creature_HasHeldItem(const Creature* p, const char* name
}
export bool CreatureLib_Creature_HasHeldItemWithHash(const Creature* p, uint32_t hash) { return p->HasHeldItem(hash); }
SIMPLE_GET_FUNC(Creature, GetHeldItem, const CreatureLib::Library::Item*);
export void CreatureLib_Creature_SetHeldItem(Creature* p, const char* name) {
return p->SetHeldItem(ConstString(name));
export uint8_t CreatureLib_Creature_SetHeldItem(Creature* p, const char* name) {
Try(p->SetHeldItem(ConstString(name));)
}
export void CreatureLib_Creature_SetHeldItemWithHash(Creature* p, uint32_t hash) { return p->SetHeldItem(hash); }
export uint8_t CreatureLib_Creature_SetHeldItemWithHash(Creature* p, uint32_t hash) { Try(p->SetHeldItem(hash);) }
export void CreatureLib_Creature_SetHeldItemFromItem(Creature* p, const CreatureLib::Library::Item* item) {
return p->SetHeldItem(item);
}
@ -48,28 +48,31 @@ export size_t CreatureLib_Creature_GetTypesCount(Creature* p) { return p->GetTyp
export const uint8_t* CreatureLib_Creature_GetTypes(Creature* p) { return p->GetTypes().RawData(); }
export bool CreatureLib_Creature_HasType(Creature* p, uint8_t type) { return p->HasType(type); }
SIMPLE_GET_FUNC(Creature, GetMaxHealth, uint32_t);
export void CreatureLib_Creature_ChangeLevelBy(Creature* p, int8_t level) { return p->ChangeLevelBy(level); }
export void CreatureLib_Creature_Damage(Creature* p, uint32_t damage, DamageSource source) {
p->Damage(damage, source);
export uint8_t CreatureLib_Creature_ChangeLevelBy(Creature* p, int8_t level) { Try(p->ChangeLevelBy(level);) }
export uint8_t CreatureLib_Creature_Damage(Creature* p, uint32_t damage, DamageSource source) {
Try(p->Damage(damage, source);)
}
export void CreatureLib_Creature_Heal(Creature* p, uint32_t health, bool canRevive) { p->Heal(health, canRevive); }
export void CreatureLib_Creature_OverrideActiveTalent(Creature* p, const char* talent) {
p->OverrideActiveTalent(ConstString(talent));
export uint8_t CreatureLib_Creature_Heal(Creature* p, uint32_t health, bool canRevive) {
Try(p->Heal(health, canRevive);)
}
export void CreatureLib_Creature_AddExperience(Creature* p, uint32_t experience) {
return p->AddExperience(experience);
export uint8_t CreatureLib_Creature_OverrideActiveTalent(Creature* p, const char* talent) {
Try(p->OverrideActiveTalent(ConstString(talent));)
}
export void CreatureLib_Creature_ClearVolatileScripts(Creature* p) { return p->ClearVolatileScripts(); }
export void CreatureLib_Creature_AddVolatileScriptByName(Creature* p, const char* scriptName) {
return p->AddVolatileScript(ConstString(scriptName));
export uint8_t CreatureLib_Creature_AddExperience(Creature* p, uint32_t experience) {
Try(p->AddExperience(experience);)
}
export void CreatureLib_Creature_AddVolatileScript(Creature* p, Script* script) {
return p->AddVolatileScript(script); }
export void CreatureLib_Creature_RemoveVolatileScriptByName(Creature* p, const char* scriptName) {
return p->RemoveVolatileScript(ConstString(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(ConstString(scriptName));)
}
export void CreatureLib_Creature_RemoveVolatileScript(Creature* p, Script* script) {
return p->RemoveVolatileScript(script);
export uint8_t CreatureLib_Creature_AddVolatileScript(Creature* p, Script* script) {
Try(p->AddVolatileScript(script);)
}
export uint8_t CreatureLib_Creature_RemoveVolatileScriptByName(Creature* p, const char* scriptName) {
Try(p->RemoveVolatileScript(ConstString(scriptName));)
}
export uint8_t CreatureLib_Creature_RemoveVolatileScript(Creature* p, Script* script) {
Try(p->RemoveVolatileScript(script);)
}
export bool CreatureLib_Creature_HasVolatileScript(Creature* p, const char* scriptName) {
return p->HasVolatileScript(ConstString(scriptName));

8
CInterface/Battling/CreatureParty.cpp
View File

@ -1,5 +1,5 @@
#include "../../src/Battling/Models/CreatureParty.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Battling;
export CreatureParty* CreatureLib_CreatureParty_ConstructWithSize(size_t size) { return new CreatureParty(size); }
@ -9,11 +9,11 @@ export CreatureParty* CreatureLib_CreatureParty_ConstructFromArray(Creature* cre
export void CreatureLib_CreatureParty_Destruct(const CreatureParty* p) { delete p; }
export Creature* CreatureLib_CreatureParty_GetAtIndex(const CreatureParty* p, size_t index) {
return p->GetAtIndex(index);
export uint8_t CreatureLib_CreatureParty_GetAtIndex(Creature*& out, const CreatureParty* p, size_t index) {
Try(out = p->GetAtIndex(index);)
}
export void CreatureLib_CreatureParty_Switch(CreatureParty* p, size_t a, size_t b) { p->Switch(a, b); }
export uint8_t CreatureLib_CreatureParty_Switch(CreatureParty* p, size_t a, size_t b) { Try(p->Switch(a, b);) }
export bool CreatureLib_CreatureParty_HasAvailableCreatures(const CreatureParty* p) {
return p->HasAvailableCreatures();

22
CInterface/Battling/DamageLibrary.cpp
View File

@ -1,25 +1,25 @@
#include "../../src/Battling/Library/DamageLibrary.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Battling;
export const DamageLibrary* CreatureLib_DamageLibrary_Construct() { return new DamageLibrary(); }
export void CreatureLib_DamageLibrary_Destruct(const DamageLibrary* p) { delete p; }
export uint32_t CreatureLib_DamageLibrary_GetDamage(const DamageLibrary* p, ExecutingAttack* attack, Creature* target,
uint8_t hitIndex) {
return p->GetDamage(attack, target, hitIndex);
export uint8_t CreatureLib_DamageLibrary_GetDamage(uint32_t& out, const DamageLibrary* p, ExecutingAttack* attack,
Creature* target, uint8_t hitIndex) {
Try(out = p->GetDamage(attack, target, hitIndex);)
}
export uint8_t CreatureLib_DamageLibrary_GetBasePower(const DamageLibrary* p, ExecutingAttack* attack, Creature* target,
uint8_t hitIndex) {
return p->GetBasePower(attack, target, hitIndex);
export uint8_t CreatureLib_DamageLibrary_GetBasePower(uint8_t& out, const DamageLibrary* p, ExecutingAttack* attack,
Creature* target, uint8_t hitIndex) {
Try(out = p->GetBasePower(attack, target, hitIndex);)
}
export float CreatureLib_DamageLibrary_GetStatModifier(const DamageLibrary* p, ExecutingAttack* attack,
export float CreatureLib_DamageLibrary_GetStatModifier(float& out, const DamageLibrary* p, ExecutingAttack* attack,
Creature* target, uint8_t hitIndex) {
return p->GetStatModifier(attack, target, hitIndex);
Try(out = p->GetStatModifier(attack, target, hitIndex);)
}
export float CreatureLib_DamageLibrary_GetDamageModifier(const DamageLibrary* p, ExecutingAttack* attack,
export float CreatureLib_DamageLibrary_GetDamageModifier(float& out, const DamageLibrary* p, ExecutingAttack* attack,
Creature* target, uint8_t hitIndex) {
return p->GetDamageModifier(attack, target, hitIndex);
Try(out = p->GetDamageModifier(attack, target, hitIndex);)
}

2
CInterface/Battling/EventData.cpp
View File

@ -1,5 +1,5 @@
#include "../../src/Battling/EventHooks/EventData.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Battling;
export void CreatureLib_EventData_Destruct(const EventData* p) { delete p; }

10
CInterface/Battling/ExperienceLibrary.cpp
View File

@ -1,13 +1,13 @@
#include "../../src/Battling/Library/ExperienceLibrary.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Battling;
export const ExperienceLibrary* CreatureLib_ExperienceLibrary_Construct() { return new ExperienceLibrary(); }
export void CreatureLib_ExperienceLibrary_Destruct(const ExperienceLibrary* p) { delete p; }
export void CreatureLib_ExperienceLibrary_HandleExperienceGain(const ExperienceLibrary* p, Creature* faintedMon,
Creature* opponents[], size_t opponentsCount) {
auto set = std::unordered_set<Creature*>(opponents, opponents + opponentsCount);
p->HandleExperienceGain(faintedMon, set);
export uint8_t CreatureLib_ExperienceLibrary_HandleExperienceGain(const ExperienceLibrary* p, Creature* faintedMon,
Creature* opponents[], size_t opponentsCount) {
Try(auto set = std::unordered_set<Creature*>(opponents, opponents + opponentsCount);
p->HandleExperienceGain(faintedMon, set);)
}

17
CInterface/Battling/MiscLibrary.cpp
View File

@ -1,18 +1,19 @@
#include "../../src/Battling/Library/MiscLibrary.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Battling;
export MiscLibrary* CreatureLib_MiscLibrary_Construct() { return new MiscLibrary(); }
export void CreatureLib_MiscLibrary_Destruct(const MiscLibrary* p) { delete p; }
export bool CreatureLib_MiscLibrary_IsCritical(MiscLibrary* p, ExecutingAttack* attack, Creature* target, uint8_t hit) {
return p->IsCritical(attack, target, hit);
export uint8_t CreatureLib_MiscLibrary_IsCritical(bool& out, MiscLibrary* p, ExecutingAttack* attack, Creature* target,
uint8_t hit) {
Try(out = p->IsCritical(attack, target, hit);)
};
export bool CreatureLib_MiscLibrary_CanFlee(MiscLibrary* p, FleeTurnChoice* switchChoice) {
return p->CanFlee(switchChoice);
export uint8_t CreatureLib_MiscLibrary_CanFlee(bool& out, MiscLibrary* p, FleeTurnChoice* switchChoice) {
Try(out = p->CanFlee(switchChoice);)
};
export BaseTurnChoice* CreatureLib_MiscLibrary_ReplacementAttack(MiscLibrary* p, Creature* user, uint8_t sideTarget,
uint8_t creatureTarget) {
return p->ReplacementAttack(user, CreatureIndex(sideTarget, creatureTarget));
export uint8_t CreatureLib_MiscLibrary_ReplacementAttack(BaseTurnChoice*& out, MiscLibrary* p, Creature* user,
uint8_t sideTarget, uint8_t creatureTarget) {
Try(out = p->ReplacementAttack(user, CreatureIndex(sideTarget, creatureTarget));)
};

10
CInterface/Battling/ScriptResolver.cpp
View File

@ -1,15 +1,15 @@
#include "../../src/Battling/ScriptHandling/ScriptResolver.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Battling;
export ScriptResolver* CreatureLib_ScriptResolver_Construct() { return new ScriptResolver(); }
export void CreatureLib_ScriptResolver_Destruct(const ScriptResolver* p) { delete p; }
export void CreatureLib_ScriptResolver_Initialize(ScriptResolver* p, BattleLibrary* library) {
p->Initialize(library);
export uint8_t CreatureLib_ScriptResolver_Initialize(ScriptResolver* p, BattleLibrary* library) {
Try(p->Initialize(library);)
};
export Script* CreatureLib_ScriptResolver_LoadScript(ScriptResolver* p, ScriptCategory category,
export uint8_t CreatureLib_ScriptResolver_LoadScript(Script*& out, ScriptResolver* p, ScriptCategory category,
const char* scriptName) {
return p->LoadScript(category, ConstString(scriptName));
Try(out = p->LoadScript(category, ConstString(scriptName));)
};

6
CInterface/Battling/TurnChoices.cpp
View File

@ -2,7 +2,7 @@
#include "../../src/Battling/TurnChoices/FleeTurnChoice.hpp"
#include "../../src/Battling/TurnChoices/PassTurnChoice.hpp"
#include "../../src/Battling/TurnChoices/SwitchTurnChoice.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Battling;
export AttackTurnChoice* CreatureLib_AttackTurnChoice_Construct(Creature* user, LearnedAttack* attack,
@ -25,7 +25,9 @@ SIMPLE_GET_FUNC(BaseTurnChoice, GetUser, Creature*)
SIMPLE_GET_FUNC(AttackTurnChoice, GetAttack, LearnedAttack*)
SIMPLE_GET_FUNC(AttackTurnChoice, GetKind, TurnChoiceKind)
SIMPLE_GET_FUNC(AttackTurnChoice, GetPriority, int8_t)
export uint8_t CreatureLib_BaseTurnChoice_GetPriority(int8_t& out, AttackTurnChoice* p) { Try(out = p->GetPriority()); }
SIMPLE_GET_FUNC(AttackTurnChoice, GetAttackScript, Script*)
export uint8_t CreatureLib_BaseTurnChoice_GetTargetSideIndex(const AttackTurnChoice* p) {
return p->GetTarget().GetSideIndex();

4
CInterface/Core.cpp Normal file
View File

@ -0,0 +1,4 @@
#include "Core.hpp"
std::string ExceptionHandler::_lastException = "";
export const char* GetLastException() { return ExceptionHandler::GetLastException(); }

26
CInterface/Core.hpp Normal file
View File

@ -0,0 +1,26 @@
#ifndef CREATURELIB_CORE_HPP
#define CREATURELIB_CORE_HPP
#include <cstring>
#include <exception>
#include <string>
#define export extern "C"
class ExceptionHandler {
static std::string _lastException;
public:
static void SetLastException(const std::exception& e) { _lastException = std::string(e.what()); }
static const char* GetLastException() { return _lastException.c_str(); }
};
#define Try(data) \
try { \
data; \
return 0; \
} catch (const std::exception& e) { \
ExceptionHandler::SetLastException(e); \
return 1; \
}
#endif // CREATURELIB_CORE_HPP

20
CInterface/Library/AttackData.cpp
View File

@ -1,18 +1,16 @@
#include "../../src/Library/Attacks/AttackData.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Library;
export AttackData* CreatureLib_AttackData_Construct(const char* name, uint8_t type, AttackCategory category,
uint8_t power, uint8_t accuracy, uint8_t baseUsage,
AttackTarget target, int8_t priority, const char* flags[],
size_t flagsCount) {
std::unordered_set<uint32_t> conversedFlags(flagsCount);
for (size_t i = 0; i < flagsCount; i++) {
conversedFlags.insert(ConstString::GetHash(flags[i]));
}
export uint8_t CreatureLib_AttackData_Construct(AttackData*& out, const char* name, uint8_t type,
AttackCategory category, uint8_t power, uint8_t accuracy,
uint8_t baseUsage, AttackTarget target, int8_t priority,
const char* flags[], size_t flagsCount) {
Try(std::unordered_set<uint32_t> conversedFlags(flagsCount);
for (size_t i = 0; i < flagsCount; i++) { conversedFlags.insert(ConstString::GetHash(flags[i])); }
return new AttackData(ConstString(name), type, category, power, accuracy, baseUsage, target, priority,
conversedFlags);
out = new AttackData(ConstString(name), type, category, power, accuracy, baseUsage, target, priority,
conversedFlags);)
};
export void CreatureLib_AttackData_Destruct(const AttackData* p) { delete p; }

5
CInterface/Library/AttackLibrary.cpp
View File

@ -1,10 +1,9 @@
#include "../../src/Library/AttackLibrary.hpp"
#include "BaseLibrary.cpp"
#define export extern "C"
using namespace CreatureLib::Library;
export const AttackLibrary* CreatureLib_AttackLibrary_Construct(size_t initialCapacity = 32) {
return new AttackLibrary(initialCapacity);
export uint8_t CreatureLib_AttackLibrary_Construct(AttackLibrary*& library, size_t initialCapacity = 32) {
Try(library = new AttackLibrary(initialCapacity);)
};
export void CreatureLib_AttackLibrary_Destruct(const AttackLibrary* p) { delete p; }

28
CInterface/Library/BaseLibrary.cpp
View File

@ -1,32 +1,34 @@
#define export extern "C"
#include "../Core.hpp"
#define BASELIBRARY(simpleName, fullname, returnType) \
export void simpleName##_Insert(fullname* p, const char* name, returnType* t) { \
p->Insert(Arbutils::CaseInsensitiveConstString::GetHash(name), t); \
export uint8_t simpleName##_Insert(fullname* p, const char* name, returnType* t) { \
Try(p->Insert(Arbutils::CaseInsensitiveConstString::GetHash(name), t);) \
} \
\
export void simpleName##_InsertWithHash(fullname* p, uint32_t hashedKey, returnType* t) { \
p->Insert(hashedKey, t); \
export uint8_t simpleName##_InsertWithHash(fullname* p, uint32_t hashedKey, returnType* t) { \
Try(p->Insert(hashedKey, t);) \
} \
\
export void simpleName##_Delete(fullname* p, const char* name) { \
p->Delete(Arbutils::CaseInsensitiveConstString::GetHash(name)); \
export uint8_t simpleName##_Delete(fullname* p, const char* name) { \
Try(p->Delete(Arbutils::CaseInsensitiveConstString::GetHash(name));) \
} \
\
export void simpleName##_DeleteWithHash(fullname* p, uint32_t hashedKey) { p->Delete(hashedKey); } \
export uint8_t simpleName##_DeleteWithHash(fullname* p, uint32_t 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) { \
return p->TryGet(Arbutils::CaseInsensitiveConstString::GetHash(name), out); \
} \
\
export bool simpleName##_TryGetWithHash(fullname* p, uint32_t hashedKey, const returnType* out) { \
export bool simpleName##_TryGetWithHash(fullname* p, uint32_t hashedKey, const returnType*& out) { \
return p->TryGet(hashedKey, out); \
} \
\
export bool simpleName##_Get(fullname* p, const char* name) { \
return p->Get(Arbutils::CaseInsensitiveConstString::GetHash(name)); \
export uint8_t simpleName##_Get(fullname* p, const char* name, const returnType*& out) { \
Try(out = p->Get(Arbutils::CaseInsensitiveConstString::GetHash(name));) \
} \
\
export bool simpleName##_GetWithHash(fullname* p, uint32_t hashedKey) { return p->Get(hashedKey); } \
export uint8_t simpleName##_GetWithHash(fullname* p, uint32_t hashedKey, const returnType*& out) { \
Try(out = p->Get(hashedKey);) \
} \
\
export size_t simpleName##_GetCount(fullname* p) { return p->GetCount(); }

25
CInterface/Library/CreatureSpecies.cpp
View File

@ -1,12 +1,13 @@
#include "../../src/Library/CreatureData/CreatureSpecies.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Library;
export CreatureSpecies* CreatureLib_CreatureSpecies_Construct(uint16_t id, const char* name,
SpeciesVariant* defaultVariant, float genderRatio,
const char* growthRate, uint8_t captureRate) {
return new CreatureSpecies(id, Arbutils::CaseInsensitiveConstString(name), defaultVariant, genderRatio,
Arbutils::CaseInsensitiveConstString(growthRate), captureRate);
export uint8_t CreatureLib_CreatureSpecies_Construct(CreatureSpecies*& out, uint16_t id, const char* name,
SpeciesVariant* defaultVariant, float genderRatio,
const char* growthRate, uint8_t captureRate) {
Try(out = new CreatureSpecies(id, Arbutils::CaseInsensitiveConstString(name), defaultVariant, genderRatio,
Arbutils::CaseInsensitiveConstString(growthRate), captureRate);)
}
export void CreatureLib_CreatureSpecies_Destruct(const CreatureSpecies* p) { delete p; }
@ -28,7 +29,7 @@ export bool CreatureLib_CreatureSpecies_HasVariantWithHash(const CreatureSpecies
return p->HasVariant(hash);
}
export bool CreatureLib_CreatureSpecies_TryGetVariant(const CreatureSpecies* p, const char* name,
const SpeciesVariant* out) {
const SpeciesVariant*& out) {
return p->TryGetVariant(Arbutils::CaseInsensitiveConstString::GetHash(name), out);
}
export bool CreatureLib_CreatureSpecies_TryGetVariantWithHash(const CreatureSpecies* p, uint32_t hash,
@ -36,11 +37,13 @@ export bool CreatureLib_CreatureSpecies_TryGetVariantWithHash(const CreatureSpec
return p->TryGetVariant(hash, out);
}
export const SpeciesVariant* CreatureLib_CreatureSpecies_GetVariant(const CreatureSpecies* p, const char* name) {
return p->GetVariant(Arbutils::CaseInsensitiveConstString::GetHash(name));
export uint8_t CreatureLib_CreatureSpecies_GetVariant(const SpeciesVariant*& out, const CreatureSpecies* p,
const char* name) {
Try(out = p->GetVariant(Arbutils::CaseInsensitiveConstString::GetHash(name));)
}
export const SpeciesVariant* CreatureLib_CreatureSpecies_GetVariantWithHash(const CreatureSpecies* p, uint32_t hash) {
return p->GetVariant(hash);
export uint8_t CreatureLib_CreatureSpecies_GetVariantWithHash(const SpeciesVariant* out, const CreatureSpecies* p,
uint32_t hash) {
Try(out = p->GetVariant(hash);)
}
#undef SIMPLE_GET_FUNC

10
CInterface/Library/DataLibrary.cpp
View File

@ -1,11 +1,11 @@
#include "../../src/Library/DataLibrary.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Library;
export const DataLibrary* CreatureLib_DataLibrary_Construct(LibrarySettings* settings, SpeciesLibrary* species,
AttackLibrary* attacks, ItemLibrary* items,
GrowthRateLibrary* growthRates, TypeLibrary* typeLibrary) {
return new DataLibrary(settings, species, attacks, items, growthRates, typeLibrary);
export uint8_t CreatureLib_DataLibrary_Construct(const DataLibrary*& out, LibrarySettings* settings,
SpeciesLibrary* species, AttackLibrary* attacks, ItemLibrary* items,
GrowthRateLibrary* growthRates, TypeLibrary* typeLibrary) {
Try(out = new DataLibrary(settings, species, attacks, items, growthRates, typeLibrary);)
}
export void CreatureLib_DataLibrary_Destruct(const DataLibrary* p) { delete p; }

16
CInterface/Library/GrowthRate.cpp
View File

@ -1,7 +1,7 @@
#include "../../src/Library/GrowthRates/GrowthRate.hpp"
#include "../../src/Library/GrowthRates/ExternGrowthRate.hpp"
#include "../../src/Library/GrowthRates/LookupGrowthRate.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Library;
export GrowthRate* CreatureLib_LookupGrowthRate_Construct(uint32_t experiencePerLevel[], size_t count) {
@ -9,17 +9,17 @@ export GrowthRate* CreatureLib_LookupGrowthRate_Construct(uint32_t experiencePer
return new LookupGrowthRate(exp);
};
export GrowthRate* CreatureLib_ExternGrowthRate_Construct(uint8_t (*calcLevel)(uint32_t),
uint32_t (*calcExperience)(uint8_t)) {
return new ExternGrowthRate(calcLevel, calcExperience);
export uint8_t CreatureLib_ExternGrowthRate_Construct(GrowthRate*& out, uint8_t (*calcLevel)(uint32_t),
uint32_t (*calcExperience)(uint8_t)) {
Try(out = new ExternGrowthRate(calcLevel, calcExperience);)
};
export void CreatureLib_GrowthRate_Destruct(const GrowthRate* p) { delete p; }
export uint8_t CreatureLib_GrowthRate_CalculateLevel(const GrowthRate* p, uint32_t experience) {
return p->CalculateLevel(experience);
export uint8_t CreatureLib_GrowthRate_CalculateLevel(uint8_t& out, const GrowthRate* p, uint32_t experience) {
Try(out = p->CalculateLevel(experience);)
}
export uint32_t CreatureLib_GrowthRate_CalculateExperience(const GrowthRate* p, uint8_t level) {
return p->CalculateExperience(level);
export uint8_t CreatureLib_GrowthRate_CalculateExperience(uint32_t& out, const GrowthRate* p, uint8_t level) {
Try(out = p->CalculateExperience(level);)
}

38
CInterface/Library/GrowthRateLibrary.cpp
View File

@ -1,5 +1,5 @@
#include "../../src/Library/GrowthRates/GrowthRateLibrary.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Library;
export GrowthRateLibrary* CreatureLib_GrowthRateLibrary_Construct(size_t initialCapacity) {
@ -8,30 +8,30 @@ export GrowthRateLibrary* CreatureLib_GrowthRateLibrary_Construct(size_t initial
export void CreatureLib_GrowthRateLibrary_Destruct(GrowthRateLibrary* p) { delete p; }
export uint8_t CreatureLib_GrowthRateLibrary_CalculateLevel(GrowthRateLibrary* library, const char* growthRate,
uint32_t experience) {
return library->CalculateLevel(Arbutils::CaseInsensitiveConstString::GetHash(growthRate), experience);
export uint8_t CreatureLib_GrowthRateLibrary_CalculateLevel(uint8_t& out, GrowthRateLibrary* library,
const char* growthRate, uint32_t experience) {
Try(out = library->CalculateLevel(Arbutils::CaseInsensitiveConstString::GetHash(growthRate), experience);)
}
export uint8_t CreatureLib_GrowthRateLibrary_CalculateLevelWithHash(GrowthRateLibrary* library, uint32_t growthRateHash,
uint32_t experience) {
return library->CalculateLevel(growthRateHash, experience);
export uint8_t CreatureLib_GrowthRateLibrary_CalculateLevelWithHash(uint8_t& out, GrowthRateLibrary* library,
uint32_t growthRateHash, uint32_t experience) {
Try(out = library->CalculateLevel(growthRateHash, experience);)
}
export uint32_t CreatureLib_GrowthRateLibrary_CalculateExperience(GrowthRateLibrary* library, const char* growthRate,
uint8_t level) {
return library->CalculateExperience(Arbutils::CaseInsensitiveConstString::GetHash(growthRate), level);
export uint8_t CreatureLib_GrowthRateLibrary_CalculateExperience(uint32_t& out, GrowthRateLibrary* library,
const char* growthRate, uint8_t level) {
Try(out = library->CalculateExperience(Arbutils::CaseInsensitiveConstString::GetHash(growthRate), level);)
}
export uint32_t CreatureLib_GrowthRateLibrary_CalculateExperienceWithHash(GrowthRateLibrary* library,
uint32_t growthRateHash, uint8_t level) {
return library->CalculateExperience(growthRateHash, level);
export uint8_t CreatureLib_GrowthRateLibrary_CalculateExperienceWithHash(uint32_t& out, GrowthRateLibrary* library,
uint32_t growthRateHash, uint8_t level) {
Try(out = library->CalculateExperience(growthRateHash, level);)
}
export void CreatureLib_GrowthRateLibrary_AddGrowthRate(GrowthRateLibrary* library, const char* growthRateName,
GrowthRate* growthRate) {
return library->AddGrowthRate(Arbutils::CaseInsensitiveConstString::GetHash(growthRateName), growthRate);
export uint8_t CreatureLib_GrowthRateLibrary_AddGrowthRate(GrowthRateLibrary* library, const char* growthRateName,
GrowthRate* growthRate) {
Try(library->AddGrowthRate(Arbutils::CaseInsensitiveConstString::GetHash(growthRateName), growthRate);)
}
export void CreatureLib_GrowthRateLibrary_AddGrowthRateWithHash(GrowthRateLibrary* library, uint32_t growthRateHash,
GrowthRate* growthRate) {
return library->AddGrowthRate(growthRateHash, growthRate);
export uint8_t CreatureLib_GrowthRateLibrary_AddGrowthRateWithHash(GrowthRateLibrary* library, uint32_t growthRateHash,
GrowthRate* growthRate) {
Try(library->AddGrowthRate(growthRateHash, growthRate);)
}

2
CInterface/Library/Item.cpp
View File

@ -1,5 +1,5 @@
#include "../../src/Library/Items/Item.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Library;
using ConstString = Arbutils::CaseInsensitiveConstString;

2
CInterface/Library/ItemLibrary.cpp
View File

@ -1,6 +1,6 @@
#include "../../src/Library/ItemLibrary.hpp"
#include "../Core.hpp"
#include "BaseLibrary.cpp"
#define export extern "C"
using namespace CreatureLib::Library;
export const ItemLibrary* CreatureLib_ItemLibrary_Construct(size_t initialCapacity = 32) {

6
CInterface/Library/LearnableAttacks.cpp
View File

@ -1,9 +1,9 @@
#include "../../src/Library/CreatureData/LearnableAttacks.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Library;
export LearnableAttacks* CreatureLib_LearnableAttacks_Construct(size_t levelAttackCapacity) {
return new LearnableAttacks(levelAttackCapacity);
export uint8_t CreatureLib_LearnableAttacks_Construct(LearnableAttacks*& out, size_t levelAttackCapacity) {
Try(out = new LearnableAttacks(levelAttackCapacity);)
};
export void CreatureLib_LearnableAttacks_Destruct(LearnableAttacks* p) { delete p; }

2
CInterface/Library/LibrarySettings.cpp
View File

@ -1,5 +1,5 @@
#include "../../src/Library/LibrarySettings.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Library;
export const LibrarySettings* CreatureLib_LibrarySettings_Construct(uint8_t maximalLevel, uint8_t maximalMoves) {

2
CInterface/Library/SpeciesLibrary.cpp
View File

@ -1,6 +1,6 @@
#include "../../src/Library/SpeciesLibrary.hpp"
#include "../Core.hpp"
#include "BaseLibrary.cpp"
#define export extern "C"
using namespace CreatureLib::Library;
export const SpeciesLibrary* CreatureLib_SpeciesLibrary_Construct(size_t initialCapacity = 32) {

2
CInterface/Library/SpeciesVariant.cpp
View File

@ -1,5 +1,5 @@
#include "../../src/Library/CreatureData/SpeciesVariant.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Library;
using ConstString = Arbutils::CaseInsensitiveConstString;

35
CInterface/Library/TypeLibrary.cpp
View File

@ -1,5 +1,5 @@
#include "../../src/Library/TypeLibrary.hpp"
#define export extern "C"
#include "../Core.hpp"
using namespace CreatureLib::Library;
export TypeLibrary* CreatureLib_TypeLibrary_Construct(size_t initialCapacity) {
@ -8,30 +8,31 @@ export TypeLibrary* CreatureLib_TypeLibrary_Construct(size_t initialCapacity) {
export void CreatureLib_TypeLibrary_Destruct(const TypeLibrary* p) { delete p; }
export uint8_t CreatureLib_TypeLibrary_GetTypeId(const TypeLibrary* p, const char* type) {
return p->GetTypeId(Arbutils::CaseInsensitiveConstString::GetHash(type));
export uint8_t CreatureLib_TypeLibrary_GetTypeId(uint8_t& out, const TypeLibrary* p, const char* type) {
Try(out = p->GetTypeId(Arbutils::CaseInsensitiveConstString::GetHash(type));)
}
export uint8_t CreatureLib_TypeLibrary_GetTypeIdWithHash(const TypeLibrary* p, uint32_t type) {
return p->GetTypeId(type);
export uint8_t CreatureLib_TypeLibrary_GetTypeIdWithHash(uint8_t& out, const TypeLibrary* p, uint32_t type) {
Try(out = p->GetTypeId(type);)
}
export uint8_t CreatureLib_TypeLibrary_RegisterType(TypeLibrary* p, const char* type) {
return p->RegisterType(Arbutils::CaseInsensitiveConstString::GetHash(type));
export uint8_t CreatureLib_TypeLibrary_RegisterType(uint8_t& out, TypeLibrary* p, const char* type) {
Try(out = p->RegisterType(Arbutils::CaseInsensitiveConstString::GetHash(type));)
}
export uint8_t CreatureLib_TypeLibrary_RegisterTypeWithHash(TypeLibrary* p, uint32_t type) {
return p->RegisterType(type);
export uint8_t CreatureLib_TypeLibrary_RegisterTypeWithHash(uint8_t& out, TypeLibrary* p, uint32_t type) {
Try(out = p->RegisterType(type);)
}
export void CreatureLib_TypeLibrary_SetEffectiveness(TypeLibrary* p, uint8_t attacking, uint8_t defensive,
float effectiveness) {
p->SetEffectiveness(attacking, defensive, effectiveness);
export uint8_t CreatureLib_TypeLibrary_SetEffectiveness(TypeLibrary* p, uint8_t attacking, uint8_t defensive,
float effectiveness) {
Try(p->SetEffectiveness(attacking, defensive, effectiveness);)
}
export float CreatureLib_TypeLibrary_GetSingleEffectiveness(TypeLibrary* p, uint8_t attacking, uint8_t defensive) {
return p->GetSingleEffectiveness(attacking, defensive);
export uint8_t CreatureLib_TypeLibrary_GetSingleEffectiveness(float& out, TypeLibrary* p, uint8_t attacking,
uint8_t defensive) {
Try(out = p->GetSingleEffectiveness(attacking, defensive);)
}
export float CreatureLib_TypeLibrary_GetEffectiveness(TypeLibrary* p, uint8_t attacking, uint8_t defensive[],
size_t defensiveCount) {
return p->GetEffectiveness(attacking, List<uint8_t>(defensive, defensive + defensiveCount));
export uint8_t CreatureLib_TypeLibrary_GetEffectiveness(float& out, TypeLibrary* p, uint8_t attacking,
uint8_t defensive[], size_t defensiveCount) {
Try(out = p->GetEffectiveness(attacking, List<uint8_t>(defensive, defensive + defensiveCount));)
}

4
CMakeLists.txt
View File

@ -32,11 +32,11 @@ if (WINDOWS)
endif (WINDOWS)
# Create main Library library with files in src/Library
file(GLOB_RECURSE LIBRARY_SRC_FILES "src/Library/*.cpp" "src/Library/*.hpp" "CInterface/Library/*.cpp")
file(GLOB_RECURSE LIBRARY_SRC_FILES "src/Library/*.cpp" "src/Library/*.hpp" "CInterface/Library/*.cpp" "CInterface/Core.*")
add_library(CreatureLibLibrary SHARED ${LIBRARY_SRC_FILES})
# Create Battling library with files in src/Battling
file(GLOB_RECURSE BATTLING_SRC_FILES "src/Battling/*.cpp" "src/Battling/*.hpp" "CInterface/Battling/*.cpp")
file(GLOB_RECURSE BATTLING_SRC_FILES "src/Battling/*.cpp" "src/Battling/*.hpp" "CInterface/Battling/*.cpp" "CInterface/Core.*")
add_library(CreatureLibBattling SHARED ${BATTLING_SRC_FILES})
if (NOT DEFINED CONAN_EXPORTED)

15077
extern/catch.hpp vendored
View File

File diff suppressed because it is too large Load Diff

36
src/Battling/EventHooks/EventData.hpp
View File

@ -10,7 +10,7 @@ namespace CreatureLib::Battling {
class EventData {
public:
virtual ~EventData() = default;
virtual EventDataKind GetKind() const = 0;
virtual EventDataKind GetKind() const noexcept = 0;
};
class DamageEvent : public EventData {
@ -20,13 +20,13 @@ namespace CreatureLib::Battling {
uint32_t _newHealth;
public:
DamageEvent(Creature* c, DamageSource s, uint32_t oHealth, uint32_t newHealth)
DamageEvent(Creature* c, DamageSource s, uint32_t oHealth, uint32_t newHealth) noexcept
: _creature(c), _damageSource(s), _originalHealth(oHealth), _newHealth(newHealth) {}
EventDataKind GetKind() const override { return EventDataKind ::Damage; }
Creature* GetCreature() const { return _creature; }
DamageSource GetDamageSource() const { return _damageSource; }
uint32_t GetOriginalHealth() const { return _originalHealth; }
uint32_t GetNewHealth() const { return _newHealth; }
EventDataKind GetKind() const noexcept override { return EventDataKind ::Damage; }
Creature* GetCreature() const noexcept { return _creature; }
DamageSource GetDamageSource() const noexcept { return _damageSource; }
uint32_t GetOriginalHealth() const noexcept { return _originalHealth; }
uint32_t GetNewHealth() const noexcept { return _newHealth; }
};
class HealEvent : public EventData {
@ -35,30 +35,30 @@ namespace CreatureLib::Battling {
uint32_t _newHealth;
public:
HealEvent(Creature* c, uint32_t oHealth, uint32_t newHealth)
HealEvent(Creature* c, uint32_t oHealth, uint32_t newHealth) noexcept
: _creature(c), _originalHealth(oHealth), _newHealth(newHealth) {}
EventDataKind GetKind() const override { return EventDataKind ::Heal; }
Creature* GetCreature() const { return _creature; }
uint32_t GetOriginalHealth() const { return _originalHealth; }
uint32_t GetNewHealth() const { return _newHealth; }
EventDataKind GetKind() const noexcept override { return EventDataKind ::Heal; }
Creature* GetCreature() const noexcept { return _creature; }
uint32_t GetOriginalHealth() const noexcept { return _originalHealth; }
uint32_t GetNewHealth() const noexcept { return _newHealth; }
};
class FaintEvent : public EventData {
Creature* _creature;
public:
FaintEvent(Creature* c) : _creature(c) {}
EventDataKind GetKind() const override { return EventDataKind ::Faint; }
Creature* GetCreature() const { return _creature; }
FaintEvent(Creature* c) noexcept : _creature(c) {}
EventDataKind GetKind() const noexcept override { return EventDataKind ::Faint; }
Creature* GetCreature() const noexcept { return _creature; }
};
class DisplayTextEvent : public EventData {
const std::string _text;
public:
DisplayTextEvent(const std::string& text) : _text(text) {}
EventDataKind GetKind() const override { return EventDataKind ::DisplayText; }
const std::string& GetText() const { return _text; }
DisplayTextEvent(const std::string& text) noexcept : _text(text) {}
EventDataKind GetKind() const noexcept override { return EventDataKind ::DisplayText; }
const std::string& GetText() const noexcept { return _text; }
};
}

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

@ -17,25 +17,31 @@ BattleLibrary::~BattleLibrary() {
delete _miscLibrary;
}
const CreatureLib::Library::LibrarySettings* BattleLibrary::GetSettings() const { return _staticLib->GetSettings(); }
const CreatureLib::Library::LibrarySettings* BattleLibrary::GetSettings() const noexcept {
return _staticLib->GetSettings();
}
const BattleStatCalculator* BattleLibrary::GetStatCalculator() const { return _statCalculator; }
const BattleStatCalculator* BattleLibrary::GetStatCalculator() const noexcept { return _statCalculator; }
const CreatureLib::Library::SpeciesLibrary* BattleLibrary::GetSpeciesLibrary() const {
const CreatureLib::Library::SpeciesLibrary* BattleLibrary::GetSpeciesLibrary() const noexcept {
return _staticLib->GetSpeciesLibrary();
}
const CreatureLib::Library::ItemLibrary* BattleLibrary::GetItemLibrary() const { return _staticLib->GetItemLibrary(); }
const CreatureLib::Library::ItemLibrary* BattleLibrary::GetItemLibrary() const noexcept {
return _staticLib->GetItemLibrary();
}
const CreatureLib::Library::AttackLibrary* BattleLibrary::GetAttackLibrary() const {
const CreatureLib::Library::AttackLibrary* BattleLibrary::GetAttackLibrary() const noexcept {
return _staticLib->GetAttackLibrary();
}
const CreatureLib::Library::TypeLibrary* BattleLibrary::GetTypeLibrary() const { return _staticLib->GetTypeLibrary(); }
const CreatureLib::Library::TypeLibrary* BattleLibrary::GetTypeLibrary() const noexcept {
return _staticLib->GetTypeLibrary();
}
const DamageLibrary* BattleLibrary::GetDamageLibrary() const { return _damageLibrary; }
const DamageLibrary* BattleLibrary::GetDamageLibrary() const noexcept { return _damageLibrary; }
const MiscLibrary* BattleLibrary::GetMiscLibrary() const { return _miscLibrary; }
const MiscLibrary* BattleLibrary::GetMiscLibrary() const noexcept { return _miscLibrary; }
Script* BattleLibrary::LoadScript(ScriptCategory category, const ConstString& scriptName) const {
return _scriptResolver->LoadScript(category, scriptName);

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

@ -23,21 +23,21 @@ namespace CreatureLib::Battling {
DamageLibrary* damageLibrary, ExperienceLibrary* experienceLibrary,
ScriptResolver* scriptResolver, MiscLibrary* miscLibrary);
~BattleLibrary();
inline const Library::DataLibrary* GetStaticLib() const { return _staticLib; }
inline const Library::DataLibrary* GetStaticLib() const noexcept { return _staticLib; }
[[nodiscard]] const Library::LibrarySettings* GetSettings() const;
[[nodiscard]] const Library::SpeciesLibrary* GetSpeciesLibrary() const;
[[nodiscard]] const Library::ItemLibrary* GetItemLibrary() const;
[[nodiscard]] const Library::AttackLibrary* GetAttackLibrary() const;
[[nodiscard]] const Library::TypeLibrary* GetTypeLibrary() const;
[[nodiscard]] const Library::GrowthRateLibrary* GetGrowthRateLibrary() const {
[[nodiscard]] const Library::LibrarySettings* GetSettings() const noexcept;
[[nodiscard]] const Library::SpeciesLibrary* GetSpeciesLibrary() const noexcept;
[[nodiscard]] const Library::ItemLibrary* GetItemLibrary() const noexcept;
[[nodiscard]] const Library::AttackLibrary* GetAttackLibrary() const noexcept;
[[nodiscard]] const Library::TypeLibrary* GetTypeLibrary() const noexcept;
[[nodiscard]] const Library::GrowthRateLibrary* GetGrowthRateLibrary() const noexcept {
return _staticLib->GetGrowthRates();
}
[[nodiscard]] const BattleStatCalculator* GetStatCalculator() const;
[[nodiscard]] const DamageLibrary* GetDamageLibrary() const;
[[nodiscard]] const MiscLibrary* GetMiscLibrary() const;
[[nodiscard]] const ExperienceLibrary* GetExperienceLibrary() const { return _experienceLibrary; }
[[nodiscard]] const BattleStatCalculator* GetStatCalculator() const noexcept;
[[nodiscard]] const DamageLibrary* GetDamageLibrary() const noexcept;
[[nodiscard]] const MiscLibrary* GetMiscLibrary() const noexcept;
[[nodiscard]] const ExperienceLibrary* GetExperienceLibrary() const noexcept { return _experienceLibrary; }
[[nodiscard]] Script* LoadScript(ScriptCategory category, const ConstString& scriptName) const;
};

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

@ -7,7 +7,7 @@
using namespace CreatureLib;
using namespace CreatureLib::Battling;
const BattleLibrary* Battle::GetLibrary() const { return _library; }
const BattleLibrary* Battle::GetLibrary() const noexcept { return _library; }
bool Battle::CanUse(const BaseTurnChoice* choice) {
AssertNotNull(choice)
@ -69,9 +69,9 @@ void Battle::CheckChoicesSetAndRun() {
}
}
ChoiceQueue* Battle::GetCurrentTurnQueue() const { return _currentTurnQueue; }
ChoiceQueue* Battle::GetCurrentTurnQueue() const noexcept { return _currentTurnQueue; }
BattleRandom* Battle::GetRandom() { return &_random; }
BattleRandom* Battle::GetRandom() noexcept { return &_random; }
bool Battle::CreatureInField(const Creature* creature) const {
AssertNotNull(creature)
@ -87,7 +87,6 @@ void Battle::ForceRecall(uint8_t side, uint8_t index) { _sides[side]->SetCreatur
void Battle::GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) { scripts.Append(&_volatile); }
void Battle::SwitchCreature(uint8_t sideIndex, uint8_t index, Creature* c) {
AssertNotNull(c)
auto side = this->_sides[sideIndex];
side->SetCreature(c, index);
}

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

@ -57,18 +57,18 @@ namespace CreatureLib::Battling {
delete _currentTurnQueue;
}
[[nodiscard]] const BattleLibrary* GetLibrary() const;
[[nodiscard]] const BattleLibrary* GetLibrary() const noexcept;
[[nodiscard]] uint32_t GetCurrentTurn() const noexcept { return _currentTurn; }
virtual bool CanUse(const BaseTurnChoice* choice);
virtual bool TrySetChoice(BaseTurnChoice* choice);
bool CanFlee() const { return _canFlee; }
bool CanFlee() const noexcept { return _canFlee; }
void CheckChoicesSetAndRun();
[[nodiscard]] ChoiceQueue* GetCurrentTurnQueue() const;
BattleRandom* GetRandom();
[[nodiscard]] ChoiceQueue* GetCurrentTurnQueue() const noexcept;
BattleRandom* GetRandom() noexcept;
bool CreatureInField(const Creature* creature) const;
@ -84,12 +84,12 @@ namespace CreatureLib::Battling {
void GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) override;
void ValidateBattleState();
inline bool HasEnded() const { return _hasEnded; }
inline const BattleResult& GetResult() const { return _battleResult; }
inline bool HasEnded() const noexcept { return _hasEnded; }
inline const BattleResult& GetResult() const noexcept { return _battleResult; }
const List<BattleSide*>& GetSides() const { return _sides; }
const List<BattleSide*>& GetSides() const noexcept { return _sides; }
Script* GetVolatileScript(const ConstString& key) const { return _volatile.Get(key); }
Script* GetVolatileScript(uint32_t keyHash) const { return _volatile.Get(keyHash); }
Script* GetVolatileScript(uint32_t keyHash) const noexcept { return _volatile.Get(keyHash); }
void AddVolatileScript(const ConstString& key);
void AddVolatileScript(Script* script);
void RemoveVolatileScript(const ConstString& name) { _volatile.Remove(name); }

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

@ -16,9 +16,9 @@ namespace CreatureLib::Battling {
static BattleResult Empty() { return BattleResult(false, 0); }
/// Whether or not the battle has ended with a conclusive result.
bool IsConclusiveResult() const { 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.
uint8_t GetWinningSide() const { return _winningSide; }
uint8_t GetWinningSide() const noexcept { return _winningSide; }
};
}

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

@ -39,14 +39,15 @@ void BattleSide::SetChoice(BaseTurnChoice* choice) {
}
void BattleSide::SetCreature(Creature* creature, uint8_t index) {
AssertNotNull(creature)
auto old = _creatures[index];
if (old != nullptr) {
old->SetOnBattleField(false);
}
_creatures[index] = creature;
creature->SetBattleData(_battle, this);
creature->SetOnBattleField(true);
if (creature != nullptr) {
creature->SetBattleData(_battle, this);
creature->SetOnBattleField(true);
}
if (_battle == nullptr)
return;
for (auto side : _battle->GetSides()) {

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

@ -24,7 +24,12 @@ Battling::Creature::Creature(const BattleLibrary* library, const Library::Creatu
}
void Battling::Creature::ChangeLevelBy(int8_t amount) {
this->_level += amount;
auto level = _level + amount;
if (level > _library->GetSettings()->GetMaximalLevel())
level = _library->GetSettings()->GetMaximalLevel();
if (level < 1)
level = 1;
_level = level;
_experience = _library->GetGrowthRateLibrary()->CalculateExperience(_species->GetGrowthRate(), _level);
RecalculateFlatStats();
}
@ -52,13 +57,17 @@ void Battling::Creature::ChangeStatBoost(Library::Statistic stat, int8_t diffAmo
this->RecalculateBoostedStat(stat);
}
uint32_t Battling::Creature::GetFlatStat(Library::Statistic stat) const { return _flatStats.GetStat(stat); }
uint32_t Battling::Creature::GetFlatStat(Library::Statistic stat) const noexcept { return _flatStats.GetStat(stat); }
uint32_t Battling::Creature::GetBoostedStat(Library::Statistic stat) const { return _boostedStats.GetStat(stat); }
uint32_t Battling::Creature::GetBoostedStat(Library::Statistic stat) const noexcept {
return _boostedStats.GetStat(stat);
}
uint32_t Battling::Creature::GetBaseStat(Library::Statistic stat) const { return _variant->GetStatistic(stat); }
uint32_t Battling::Creature::GetBaseStat(Library::Statistic stat) const noexcept {
return _variant->GetStatistic(stat);
}
int8_t Battling::Creature::GetStatBoost(Library::Statistic stat) const { return _statBoost.GetStat(stat); }
int8_t Battling::Creature::GetStatBoost(Library::Statistic stat) const noexcept { return _statBoost.GetStat(stat); }
void Battling::Creature::RecalculateFlatStats() {
auto statCalc = this->_library->GetStatCalculator();
@ -174,13 +183,13 @@ void Battling::Creature::AddExperience(uint32_t amount) {
_experience = exp;
_level = level;
}
const Library::CreatureSpecies* Battling::Creature::GetDisplaySpecies() const {
const Library::CreatureSpecies* Battling::Creature::GetDisplaySpecies() const noexcept {
auto species = _displaySpecies;
if (species == nullptr)
species = _species;
return species;
}
const Library::SpeciesVariant* Battling::Creature::GetDisplayVariant() const {
const Library::SpeciesVariant* Battling::Creature::GetDisplayVariant() const noexcept {
auto variant = _displayVariant;
if (variant == nullptr)
variant = _variant;

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

@ -129,21 +129,21 @@ namespace CreatureLib::Battling {
void RemoveVolatileScript(Script* script);
bool HasVolatileScript(const ConstString& name) const;
List<LearnedAttack*>& GetAttacks() { return _attacks; }
List<LearnedAttack*>& GetAttacks() noexcept { return _attacks; }
const Library::CreatureSpecies* GetDisplaySpecies() const;
const Library::SpeciesVariant* GetDisplayVariant() const;
const Library::CreatureSpecies* GetDisplaySpecies() const noexcept;
const Library::SpeciesVariant* GetDisplayVariant() const noexcept;
const void SetDisplaySpecies(const Library::CreatureSpecies* species) { _displaySpecies = species; }
const void SetDisplayVariant(const Library::SpeciesVariant* variant) { _displayVariant = variant; };
const void SetDisplaySpecies(const Library::CreatureSpecies* species) noexcept { _displaySpecies = species; }
const void SetDisplayVariant(const Library::SpeciesVariant* variant) noexcept { _displayVariant = variant; };
// region Stat APIs
void ChangeStatBoost(Library::Statistic stat, int8_t diffAmount);
[[nodiscard]] uint32_t GetFlatStat(Library::Statistic stat) const;
[[nodiscard]] uint32_t GetBoostedStat(Library::Statistic stat) const;
[[nodiscard]] uint32_t GetBaseStat(Library::Statistic stat) const;
[[nodiscard]] int8_t GetStatBoost(Library::Statistic stat) const;
[[nodiscard]] uint32_t GetFlatStat(Library::Statistic stat) const noexcept;
[[nodiscard]] uint32_t GetBoostedStat(Library::Statistic stat) const noexcept;
[[nodiscard]] uint32_t GetBaseStat(Library::Statistic stat) const noexcept;
[[nodiscard]] int8_t GetStatBoost(Library::Statistic stat) const noexcept;
void RecalculateFlatStats();
void RecalculateBoostedStats();
void RecalculateFlatStat(Library::Statistic);

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

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

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

@ -9,25 +9,25 @@ namespace CreatureLib::Battling {
Arbutils::Collections::List<Creature*> _party;
public:
CreatureParty(size_t size) : _party(size) {}
CreatureParty(Arbutils::Collections::List<Creature*> party) : _party(party) {}
CreatureParty(std::initializer_list<Creature*> party) : _party(party) {}
CreatureParty(size_t size) noexcept : _party(size) {}
CreatureParty(Arbutils::Collections::List<Creature*> party) noexcept : _party(party) {}
CreatureParty(std::initializer_list<Creature*> party) noexcept : _party(party) {}
virtual ~CreatureParty() {
virtual ~CreatureParty() noexcept {
for (auto c : _party) {
delete c;
}
}
Creature* GetAtIndex(size_t index) const { return _party[index]; }
Creature* GetAtIndex(size_t index) const noexcept { return _party[index]; }
void Switch(size_t a, size_t b) {
void Switch(size_t a, size_t b) noexcept {
auto ca = _party[a];
_party[a] = _party[b];
_party[b] = ca;
}
bool HasAvailableCreatures() const {
bool HasAvailableCreatures() const noexcept {
for (Creature* c : _party) {
if (c == nullptr)
continue;
@ -38,10 +38,10 @@ namespace CreatureLib::Battling {
return false;
}
Arbutils::Collections::List<Creature*>& GetParty() { return _party; }
const Arbutils::Collections::List<Creature*>& GetParty() const { return _party; }
Arbutils::Collections::List<Creature*>& GetParty() noexcept { return _party; }
const Arbutils::Collections::List<Creature*>& GetParty() const noexcept { return _party; }
size_t GetLength() const { return _party.Count(); }
size_t GetLength() const noexcept { return _party.Count(); }
};
}

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

@ -8,7 +8,7 @@
namespace CreatureLib::Battling {
class ScriptSet {
Arbutils::Collections::List<Script*> _scripts;
std::unordered_map<uint32_t, size_t> _lookup;
Arbutils::Collections::Dictionary<uint32_t, size_t> _lookup;
public:
~ScriptSet() {
@ -18,22 +18,23 @@ namespace CreatureLib::Battling {
}
void Add(Script* script) {
auto f = _lookup.find(script->GetName());
if (f != _lookup.end()) {
_scripts[f.operator*().second]->Stack();
size_t v;
if (_lookup.TryGet(script->GetName(), v)) {
_scripts[v]->Stack();
delete script;
return;
}
_scripts.Append(script);
_lookup.insert({script->GetName(), _scripts.Count() - 1});
_lookup.Insert(script->GetName(), _scripts.Count() - 1);
}
Script* Get(const ConstString& key) const { return Get(key.GetHash()); }
Script* Get(uint32_t keyHash) const {
auto f = _lookup.find(keyHash);
if (f != _lookup.end()) {
return _scripts[f->second];
Script* Get(uint32_t keyHash) const noexcept {
size_t v;
if (_lookup.TryGet(keyHash, v)) {
return _scripts[v];
}
return nullptr;
}
@ -41,27 +42,28 @@ namespace CreatureLib::Battling {
void Remove(const ConstString& key) { Remove(key.GetHash()); }
void Remove(uint32_t keyHash) {
auto find = _lookup.find(keyHash);
if (find != _lookup.end()) {
auto script = _scripts[find->second];
size_t v;
if (_lookup.TryGet(keyHash, v)) {
auto script = _scripts[v];
script->OnRemove();
delete script;
_scripts.Remove(find.operator*().second);
_lookup.erase(keyHash);
_scripts.Remove(v);
_lookup.Remove(keyHash);
}
}
void Clear() {
for (auto s : _scripts) {
s->OnRemove();
delete s;
}
_scripts.Clear();
_lookup.clear();
_lookup.Clear();
}
bool Has(const ConstString& key) const { return _lookup.find(key) != _lookup.end(); }
bool Has(const ConstString& key) const { return _lookup.Has(key); }
bool Has(uint32_t keyHash) const { return _lookup.find(keyHash) != _lookup.end(); }
bool Has(uint32_t keyHash) const { return _lookup.Has(keyHash); }
size_t Count() const { return _scripts.Count(); }

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

@ -32,21 +32,21 @@ namespace CreatureLib::Battling {
AssertNotNull(attack)
ResolveScript();
}
AttackTurnChoice(Creature* user, LearnedAttack* attack, const CreatureIndex& target, Script* script)
AttackTurnChoice(Creature* user, LearnedAttack* attack, const CreatureIndex& target, Script* script) noexcept
: BaseTurnChoice(user), _attack(attack), _target(target), _attackScript(script) {}
inline LearnedAttack* GetAttack() const { return _attack; }
inline LearnedAttack* GetAttack() const noexcept { return _attack; }
TurnChoiceKind GetKind() const override { return TurnChoiceKind ::Attack; }
TurnChoiceKind GetKind() const noexcept override { return TurnChoiceKind ::Attack; }
int8_t GetPriority() const {
// HOOK: Change priority
return _attack->GetAttack()->GetPriority();
}
const CreatureIndex& GetTarget() const { return _target; }
const CreatureIndex& GetTarget() const noexcept { return _target; }
Script* GetAttackScript() const { return _attackScript; }
Script* GetAttackScript() const noexcept { return _attackScript; }
protected:
void GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) override {

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

@ -12,12 +12,12 @@ namespace CreatureLib::Battling {
Creature* _user;
protected:
BaseTurnChoice(Creature* user) : _user(user){};
BaseTurnChoice(Creature* user) noexcept : _user(user){};
public:
virtual ~BaseTurnChoice() = default;
[[nodiscard]] virtual TurnChoiceKind GetKind() const = 0;
[[nodiscard]] inline Creature* GetUser() const { return _user; }
[[nodiscard]] virtual TurnChoiceKind GetKind() const noexcept = 0;
[[nodiscard]] inline Creature* GetUser() const noexcept { return _user; }
};
}

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

@ -9,7 +9,7 @@ namespace CreatureLib::Battling {
public:
FleeTurnChoice(Creature* user) : BaseTurnChoice(user) {}
TurnChoiceKind GetKind() const override { return TurnChoiceKind ::Flee; }
TurnChoiceKind GetKind() const noexcept override { return TurnChoiceKind ::Flee; }
protected:
void GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) override {

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

@ -8,7 +8,7 @@ namespace CreatureLib::Battling {
public:
PassTurnChoice(Creature* c) : BaseTurnChoice(c) {}
TurnChoiceKind GetKind() const override { return TurnChoiceKind ::Pass; }
TurnChoiceKind GetKind() const noexcept override { return TurnChoiceKind ::Pass; }
protected:
void GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) override {

9
src/Battling/TurnChoices/SwitchTurnChoice.hpp
View File

@ -7,13 +7,12 @@ namespace CreatureLib::Battling {
Creature* _newCreature;
public:
SwitchTurnChoice(Creature* user, Creature* newCreature) : BaseTurnChoice(user), _newCreature(newCreature) {
AssertNotNull(_newCreature)
}
SwitchTurnChoice(Creature* user, Creature* newCreature) noexcept
: BaseTurnChoice(user), _newCreature(newCreature) {}
TurnChoiceKind GetKind() const final { return TurnChoiceKind::Switch; }
TurnChoiceKind GetKind() const noexcept final { return TurnChoiceKind::Switch; }
inline Creature* GetNewCreature() const { return _newCreature; }
inline Creature* GetNewCreature() const noexcept { return _newCreature; }
protected:
void GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) override {

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

@ -9,9 +9,9 @@ CreatureLib::Library::AttackData::AttackData(const ConstString& name, uint8_t ty
: _name(std::move(name)), _type(type), _category(category), _basePower(power), _accuracy(accuracy),
_baseUsages(baseUsage), _target(target), _priority(priority), _flags(std::move(flags)) {}
bool CreatureLib::Library::AttackData::HasFlag(const ConstString& key) const {
bool CreatureLib::Library::AttackData::HasFlag(const ConstString& key) const noexcept {
return this->_flags.find(key) != this->_flags.end();
}
bool CreatureLib::Library::AttackData::HasFlag(uint32_t key) const {
bool CreatureLib::Library::AttackData::HasFlag(uint32_t key) const noexcept {
return this->_flags.find(key) != this->_flags.end();
}

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

@ -27,17 +27,17 @@ namespace CreatureLib::Library {
uint8_t baseUsage, AttackTarget target, int8_t priority, std::unordered_set<uint32_t> flags);
virtual ~AttackData() = default;
inline const ConstString& GetName() const { return _name; }
inline const uint8_t GetType() const { return _type; }
inline AttackCategory GetCategory() const { return _category; }
inline uint8_t GetBasePower() const { return _basePower; }
inline uint8_t GetAccuracy() const { return _accuracy; }
inline uint8_t GetBaseUsages() const { return _baseUsages; }
inline AttackTarget GetTarget() const { return _target; }
inline int8_t GetPriority() const { return _priority; }
inline const ConstString& GetName() const noexcept { return _name; }
inline const uint8_t GetType() const noexcept { return _type; }
inline AttackCategory GetCategory() const noexcept { return _category; }
inline uint8_t GetBasePower() const noexcept { return _basePower; }
inline uint8_t GetAccuracy() const noexcept { return _accuracy; }
inline uint8_t GetBaseUsages() const noexcept { return _baseUsages; }
inline AttackTarget GetTarget() const noexcept { return _target; }
inline int8_t GetPriority() const noexcept { return _priority; }
bool HasFlag(const ConstString& key) const;
bool HasFlag(uint32_t keyHash) const;
bool HasFlag(const ConstString& key) const noexcept;
bool HasFlag(uint32_t keyHash) const noexcept;
};
}

14
src/Library/DataLibrary.cpp
View File

@ -15,24 +15,26 @@ CreatureLib::Library::DataLibrary::DataLibrary(LibrarySettings* settings, Creatu
AssertNotNull(_typeLibrary)
}
const CreatureLib::Library::LibrarySettings* CreatureLib::Library::DataLibrary::GetSettings() const {
const CreatureLib::Library::LibrarySettings* CreatureLib::Library::DataLibrary::GetSettings() const noexcept {
return _settings;
}
const CreatureLib::Library::SpeciesLibrary* CreatureLib::Library::DataLibrary::GetSpeciesLibrary() const {
const CreatureLib::Library::SpeciesLibrary* CreatureLib::Library::DataLibrary::GetSpeciesLibrary() const noexcept {
return _species;
}
const CreatureLib::Library::AttackLibrary* CreatureLib::Library::DataLibrary::GetAttackLibrary() const {
const CreatureLib::Library::AttackLibrary* CreatureLib::Library::DataLibrary::GetAttackLibrary() const noexcept {
return _attacks;
}
const CreatureLib::Library::ItemLibrary* CreatureLib::Library::DataLibrary::GetItemLibrary() const { return _items; }
const CreatureLib::Library::ItemLibrary* CreatureLib::Library::DataLibrary::GetItemLibrary() const noexcept {
return _items;
}
const CreatureLib::Library::GrowthRateLibrary* CreatureLib::Library::DataLibrary::GetGrowthRates() const {
const CreatureLib::Library::GrowthRateLibrary* CreatureLib::Library::DataLibrary::GetGrowthRates() const noexcept {
return _growthRates;
}
const CreatureLib::Library::TypeLibrary* CreatureLib::Library::DataLibrary::GetTypeLibrary() const {
const CreatureLib::Library::TypeLibrary* CreatureLib::Library::DataLibrary::GetTypeLibrary() const noexcept {
return _typeLibrary;
}

12
src/Library/DataLibrary.hpp
View File

@ -34,12 +34,12 @@ namespace CreatureLib::Library {
delete _typeLibrary;
}
[[nodiscard]] const LibrarySettings* GetSettings() const;
[[nodiscard]] const SpeciesLibrary* GetSpeciesLibrary() const;
[[nodiscard]] const AttackLibrary* GetAttackLibrary() const;
[[nodiscard]] const ItemLibrary* GetItemLibrary() const;
[[nodiscard]] const GrowthRateLibrary* GetGrowthRates() const;
[[nodiscard]] const TypeLibrary* GetTypeLibrary() const;
[[nodiscard]] const LibrarySettings* GetSettings() const noexcept;
[[nodiscard]] const SpeciesLibrary* GetSpeciesLibrary() const noexcept;
[[nodiscard]] const AttackLibrary* GetAttackLibrary() const noexcept;
[[nodiscard]] const ItemLibrary* GetItemLibrary() const noexcept;
[[nodiscard]] const GrowthRateLibrary* GetGrowthRates() const noexcept;
[[nodiscard]] const TypeLibrary* GetTypeLibrary() const noexcept;
};
}

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

@ -1,9 +1,11 @@
#include "Item.hpp"
bool CreatureLib::Library::Item::HasFlag(const Arbutils::CaseInsensitiveConstString& flag) const {
bool CreatureLib::Library::Item::HasFlag(const Arbutils::CaseInsensitiveConstString& flag) const noexcept {
return this->_flags.find(flag) != this->_flags.end();
}
bool CreatureLib::Library::Item::HasFlag(uint32_t flag) const noexcept {
return this->_flags.find(flag) != this->_flags.end();
}
bool CreatureLib::Library::Item::HasFlag(uint32_t flag) const { return this->_flags.find(flag) != this->_flags.end(); }
CreatureLib::Library::Item::Item(const Arbutils::CaseInsensitiveConstString& name,
CreatureLib::Library::ItemCategory category,

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

@ -20,13 +20,13 @@ namespace CreatureLib::Library {
Item(const Arbutils::CaseInsensitiveConstString& name, ItemCategory category, BattleItemCategory battleCategory,
int32_t price, std::unordered_set<uint32_t> flags);
inline const Arbutils::CaseInsensitiveConstString& GetName() const { return _name; }
inline ItemCategory GetCategory() const { return _category; }
inline BattleItemCategory GetBattleCategory() const { return _battleCategory; }
inline const int32_t GetPrice() const { return _price; }
inline const Arbutils::CaseInsensitiveConstString& GetName() const noexcept { return _name; }
inline ItemCategory GetCategory() const noexcept { return _category; }
inline BattleItemCategory GetBattleCategory() const noexcept { return _battleCategory; }
inline const int32_t GetPrice() const noexcept { return _price; }
bool HasFlag(const Arbutils::CaseInsensitiveConstString& flag) const;
bool HasFlag(uint32_t flag) const;
bool HasFlag(const Arbutils::CaseInsensitiveConstString& flag) const noexcept;
bool HasFlag(uint32_t flag) const noexcept;
};
}