From 25f65eb47b20d0e90d7629d81a6bb219269abc58 Mon Sep 17 00:00:00 2001 From: Deukhoofd Date: Tue, 26 May 2020 18:31:06 +0200 Subject: [PATCH] Update to newer Arbutils version. --- CInterface/Battling/Battle.cpp | 8 ++- CInterface/Battling/BattleParty.cpp | 7 +-- CInterface/Battling/Creature.cpp | 27 ++++---- CInterface/Battling/CreatureParty.cpp | 2 +- CInterface/Battling/ExecutingAttack.cpp | 2 +- CInterface/Battling/LearnedAttack.cpp | 3 +- CInterface/Battling/Script.cpp | 3 +- CInterface/Battling/ScriptResolver.cpp | 2 +- CInterface/Library/AttackData.cpp | 12 ++-- CInterface/Library/BaseLibrary.cpp | 12 ++-- CInterface/Library/CreatureSpecies.cpp | 16 ++--- CInterface/Library/EffectParameter.cpp | 2 +- CInterface/Library/GrowthRate.cpp | 2 +- CInterface/Library/GrowthRateLibrary.cpp | 6 +- CInterface/Library/Item.cpp | 2 +- CInterface/Library/SpeciesVariant.cpp | 13 ++-- CInterface/Library/TypeLibrary.cpp | 6 +- src/Battling/Flow/TurnHandler.cpp | 2 +- src/Battling/Flow/TurnOrdering.cpp | 2 +- src/Battling/Flow/TurnOrdering.hpp | 2 +- src/Battling/Library/BattleLibrary.cpp | 3 +- src/Battling/Library/BattleLibrary.hpp | 2 +- src/Battling/Library/MiscLibrary.cpp | 2 +- src/Battling/Models/Battle.cpp | 4 +- src/Battling/Models/Battle.hpp | 31 +++++----- src/Battling/Models/BattleParty.hpp | 8 +-- src/Battling/Models/BattleRandom.hpp | 4 +- src/Battling/Models/BattleSide.cpp | 4 +- src/Battling/Models/BattleSide.hpp | 14 ++--- src/Battling/Models/CreateCreature.cpp | 10 +-- src/Battling/Models/CreateCreature.hpp | 19 +++--- src/Battling/Models/Creature.cpp | 21 ++++--- src/Battling/Models/Creature.hpp | 62 +++++++++---------- src/Battling/Models/CreatureParty.hpp | 8 +-- src/Battling/Models/ExecutingAttack.hpp | 14 ++--- src/Battling/Models/LearnedAttack.cpp | 11 ++-- src/Battling/Models/LearnedAttack.hpp | 10 +-- src/Battling/ScriptHandling/Script.hpp | 9 +-- .../ScriptHandling/ScriptAggregator.hpp | 4 +- .../ScriptHandling/ScriptResolver.hpp | 4 +- src/Battling/ScriptHandling/ScriptSet.hpp | 12 ++-- src/Battling/ScriptHandling/ScriptSource.hpp | 4 +- src/Battling/TurnChoices/AttackTurnChoice.hpp | 2 +- src/Battling/TurnChoices/FleeTurnChoice.hpp | 4 +- src/Battling/TurnChoices/PassTurnChoice.hpp | 4 +- src/Battling/TurnChoices/SwitchTurnChoice.hpp | 4 +- src/Library/Attacks/AttackData.cpp | 4 +- src/Library/Attacks/AttackData.hpp | 14 ++--- src/Library/Attacks/SecondaryEffect.hpp | 15 ++--- src/Library/BaseLibrary.hpp | 32 +++++----- src/Library/CreatureData/CreatureSpecies.cpp | 21 ++++--- src/Library/CreatureData/CreatureSpecies.hpp | 38 ++++++------ src/Library/CreatureData/LearnableAttacks.cpp | 5 +- src/Library/CreatureData/LearnableAttacks.hpp | 10 ++- src/Library/CreatureData/SpeciesVariant.cpp | 13 ++-- src/Library/CreatureData/SpeciesVariant.hpp | 35 ++++++----- src/Library/EffectParameter.hpp | 8 +-- src/Library/GrowthRates/GrowthRateLibrary.hpp | 2 +- src/Library/GrowthRates/LookupGrowthRate.hpp | 4 +- src/Library/Items/Item.cpp | 4 +- src/Library/Items/Item.hpp | 8 +-- src/Library/TypeLibrary.cpp | 6 +- src/Library/TypeLibrary.hpp | 14 ++--- .../ScriptTests/ScriptAggregatorTests.cpp | 26 ++++---- .../ScriptTests/ScriptSetTests.cpp | 4 +- .../ScriptTests/ScriptSourceTest.cpp | 8 +-- tests/BattleTests/TurnOrderTests.cpp | 10 +-- tests/LibraryTests/EffectParameterTests.cpp | 2 +- 68 files changed, 334 insertions(+), 354 deletions(-) diff --git a/CInterface/Battling/Battle.cpp b/CInterface/Battling/Battle.cpp index 795617a..5ed2eaa 100644 --- a/CInterface/Battling/Battle.cpp +++ b/CInterface/Battling/Battle.cpp @@ -5,13 +5,13 @@ using namespace CreatureLib::Battling; export uint8_t CreatureLib_Battle_Construct(Battle*& out, const BattleLibrary* library, BattleParty* partyArr[], size_t numberOfParties, bool canFlee, uint8_t numberOfSides, uint8_t creaturesPerSide) { - Try(List parties(partyArr, partyArr + numberOfParties); + Try(ArbUt::List 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 const BattleLibrary* CreatureLib_Battle_GetLibrary(const Battle* p) { return p->GetLibrary().GetRaw(); } export uint8_t CreatureLib_Battle_CanUse(bool& out, Battle* p, const BaseTurnChoice* turnChoice) { Try(out = p->CanUse(turnChoice);) } @@ -49,7 +49,9 @@ export size_t CreatureLib_Battle_GetSidesCount(const Battle* p) { return p->GetS export BattleSide* const* CreatureLib_Battle_GetSides(const Battle* p) { return p->GetSides().RawData(); } export size_t CreatureLib_Battle_GetPartiesCount(const Battle* p) { return p->GetParties().Count(); } -export BattleParty* const* CreatureLib_Battle_GetParties(const Battle* p) { return p->GetParties().RawData(); } +export BattleParty* const* CreatureLib_Battle_GetParties(const Battle* p) { + return reinterpret_cast(p->GetParties().RawData()); +} export Script* CreatureLib_Battle_GetVolatileScript(Battle* p, const char* key) { return p->GetVolatileScript(ConstString::GetHash(key)); diff --git a/CInterface/Battling/BattleParty.cpp b/CInterface/Battling/BattleParty.cpp index 6cd72bc..dd40f29 100644 --- a/CInterface/Battling/BattleParty.cpp +++ b/CInterface/Battling/BattleParty.cpp @@ -6,10 +6,9 @@ using namespace CreatureLib::Battling; // side, one after the other. export uint8_t CreatureLib_BattleParty_Construct(BattleParty*& out, CreatureParty* p, uint8_t creatureIndices[], size_t numberOfIndices) { - Try(Arbutils::Collections::List 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);) + Try(ArbUt::List 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; } diff --git a/CInterface/Battling/Creature.cpp b/CInterface/Battling/Creature.cpp index a3475eb..c713a8e 100644 --- a/CInterface/Battling/Creature.cpp +++ b/CInterface/Battling/Creature.cpp @@ -1,7 +1,6 @@ #include "../../src/Battling/Models/Creature.hpp" #include "../Core.hpp" using namespace CreatureLib::Battling; -using ConstString = Arbutils::CaseInsensitiveConstString; export uint8_t CreatureLib_Creature_Construct(Creature*& out, const BattleLibrary* library, const CreatureLib::Library::CreatureSpecies* species, @@ -10,11 +9,11 @@ export uint8_t CreatureLib_Creature_Construct(Creature*& out, const BattleLibrar uint8_t coloring, const CreatureLib::Library::Item* heldItem, const char* nickname, bool secretTalent, uint8_t talent, LearnedAttack* attacks[], size_t attacksNum, bool allowedExperienceGain) { - Try(auto attacksVec = List(attacks, attacks + attacksNum); - out = new Creature(library, borrowed_ptr(species), variant, level, - experience, uid, gender, coloring, borrowed_ptr(heldItem), - nickname, CreatureLib::Library::TalentIndex(secretTalent, talent), attacksVec, - allowedExperienceGain);) + Try(auto attacksVec = ArbUt::List(attacks, attacks + attacksNum); + out = new Creature(library, ArbUt::BorrowedPtr(species), variant, + level, experience, uid, gender, coloring, + ArbUt::BorrowedPtr(heldItem), nickname, + CreatureLib::Library::TalentIndex(secretTalent, talent), attacksVec, allowedExperienceGain);) }; export void CreatureLib_Creature_Destruct(const Creature* p) { delete p; } @@ -32,16 +31,16 @@ SIMPLE_GET_FUNC(Creature, GetGender, CreatureLib::Library::Gender); SIMPLE_GET_FUNC(Creature, GetColoring, uint8_t); export bool CreatureLib_Creature_HasHeldItem(const Creature* p, const char* name) { - return p->HasHeldItem(ConstString(name)); + return p->HasHeldItem(ArbUt::CaseInsensitiveConstString(name)); } export bool CreatureLib_Creature_HasHeldItemWithHash(const Creature* p, uint32_t hash) { return p->HasHeldItem(hash); } SIMPLE_GET_FUNC_SMART_PTR(Creature, GetHeldItem, const CreatureLib::Library::Item*); export uint8_t CreatureLib_Creature_SetHeldItem(Creature* p, const char* name) { - Try(p->SetHeldItem(ConstString(name));) + Try(p->SetHeldItem(ArbUt::CaseInsensitiveConstString(name));) } 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(borrowed_ptr(item)); + return p->SetHeldItem(ArbUt::BorrowedPtr(item)); } SIMPLE_GET_FUNC(Creature, GetCurrentHealth, uint32_t); SIMPLE_GET_FUNC(Creature, GetBattle, Battle*); @@ -60,33 +59,33 @@ export uint8_t CreatureLib_Creature_Heal(Creature* p, uint32_t health, bool canR Try(p->Heal(health, canRevive);) } export uint8_t CreatureLib_Creature_OverrideActiveTalent(Creature* p, const char* talent) { - Try(p->OverrideActiveTalent(ConstString(talent));) + Try(p->OverrideActiveTalent(ArbUt::CaseInsensitiveConstString(talent));) } export uint8_t CreatureLib_Creature_AddExperience(Creature* p, uint32_t experience) { Try(p->AddExperience(experience);) } 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));) + Try(p->AddVolatileScript(ArbUt::CaseInsensitiveConstString(scriptName));) } 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));) + Try(p->RemoveVolatileScript(ArbUt::CaseInsensitiveConstString(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)); + return p->HasVolatileScript(ArbUt::CaseInsensitiveConstString(scriptName)); } export size_t CreatureLib_Creature_GetAttacksCount(Creature* p) { return p->GetAttacks().Count(); } export LearnedAttack* const* CreatureLib_Creature_GetAttacks(Creature* p) { return p->GetAttacks().RawData(); } SIMPLE_GET_FUNC_SMART_PTR(Creature, GetDisplaySpecies, const CreatureLib::Library::CreatureSpecies*); SIMPLE_GET_FUNC_SMART_PTR(Creature, GetDisplayVariant, const CreatureLib::Library::SpeciesVariant*); export void CreatureLib_Creature_SetDisplaySpecies(Creature* p, const CreatureLib::Library::CreatureSpecies* species) { - return p->SetDisplaySpecies(borrowed_ptr(species)); + return p->SetDisplaySpecies(ArbUt::BorrowedPtr(species)); } export void CreatureLib_Creature_SetDisplayVariant(Creature* p, const CreatureLib::Library::SpeciesVariant* variant) { return p->SetDisplayVariant(variant); diff --git a/CInterface/Battling/CreatureParty.cpp b/CInterface/Battling/CreatureParty.cpp index de615b2..4a0f258 100644 --- a/CInterface/Battling/CreatureParty.cpp +++ b/CInterface/Battling/CreatureParty.cpp @@ -4,7 +4,7 @@ using namespace CreatureLib::Battling; export CreatureParty* CreatureLib_CreatureParty_ConstructWithSize(size_t size) { return new CreatureParty(size); } export CreatureParty* CreatureLib_CreatureParty_ConstructFromArray(Creature* creatures[], size_t size) { - return new CreatureParty(Arbutils::Collections::List(creatures, creatures + size)); + return new CreatureParty(ArbUt::List(creatures, creatures + size)); } export void CreatureLib_CreatureParty_Destruct(const CreatureParty* p) { delete p; } diff --git a/CInterface/Battling/ExecutingAttack.cpp b/CInterface/Battling/ExecutingAttack.cpp index 213fac1..39924bc 100644 --- a/CInterface/Battling/ExecutingAttack.cpp +++ b/CInterface/Battling/ExecutingAttack.cpp @@ -5,7 +5,7 @@ using namespace CreatureLib::Battling; export uint8_t CreatureLib_ExecutingAttack_Construct(ExecutingAttack*& out, Creature* const* targets, size_t targetCount, uint8_t numberHits, Creature* user, LearnedAttack* attack, Script* script) { - Try(auto ls = List(targets, targets + targetCount); + Try(auto ls = ArbUt::List(targets, targets + targetCount); out = new ExecutingAttack(ls, numberHits, user, attack, script);) } diff --git a/CInterface/Battling/LearnedAttack.cpp b/CInterface/Battling/LearnedAttack.cpp index 3f950b9..da342bd 100644 --- a/CInterface/Battling/LearnedAttack.cpp +++ b/CInterface/Battling/LearnedAttack.cpp @@ -4,7 +4,8 @@ using namespace CreatureLib::Battling; export uint8_t CreatureLib_LearnedAttack_Construct(LearnedAttack*& out, const CreatureLib::Library::AttackData* attack, uint8_t maxUses, AttackLearnMethod learnMethod) { - Try(out = new LearnedAttack(borrowed_ptr(attack), maxUses, learnMethod);) + Try(out = new LearnedAttack(ArbUt::BorrowedPtr(attack), maxUses, + learnMethod);) } export void CreatureLib_LearnedAttack_Destruct(LearnedAttack* p) { delete p; } diff --git a/CInterface/Battling/Script.cpp b/CInterface/Battling/Script.cpp index c1969db..e616cac 100644 --- a/CInterface/Battling/Script.cpp +++ b/CInterface/Battling/Script.cpp @@ -11,7 +11,8 @@ export const char* CreatureLib_Script_GetName(Script* p) { return p->GetName().c export uint8_t CreatureLib_Script_OnBeforeTurn(Script* p, const BaseTurnChoice* choice) { Try(p->OnBeforeTurn(choice)); } -export uint8_t CreatureLib_Script_ChangeAttack(Script* p, AttackTurnChoice* choice, ConstString* outAttack) { +export uint8_t CreatureLib_Script_ChangeAttack(Script* p, AttackTurnChoice* choice, + ArbUt::CaseInsensitiveConstString* outAttack) { Try(p->ChangeAttack(choice, outAttack)); } export uint8_t CreatureLib_Script_PreventAttack(Script* p, ExecutingAttack* attack, bool* outResult) { diff --git a/CInterface/Battling/ScriptResolver.cpp b/CInterface/Battling/ScriptResolver.cpp index 9a77ad6..e9dc907 100644 --- a/CInterface/Battling/ScriptResolver.cpp +++ b/CInterface/Battling/ScriptResolver.cpp @@ -11,5 +11,5 @@ export uint8_t CreatureLib_ScriptResolver_Initialize(ScriptResolver* p, BattleLi }; export uint8_t CreatureLib_ScriptResolver_LoadScript(Script*& out, ScriptResolver* p, ScriptCategory category, const char* scriptName) { - Try(out = p->LoadScript(category, ConstString(scriptName));) + Try(out = p->LoadScript(category, ArbUt::CaseInsensitiveConstString(scriptName));) }; diff --git a/CInterface/Library/AttackData.cpp b/CInterface/Library/AttackData.cpp index de39ad6..ee46e71 100644 --- a/CInterface/Library/AttackData.cpp +++ b/CInterface/Library/AttackData.cpp @@ -11,18 +11,18 @@ export uint8_t CreatureLib_AttackData_Construct(AttackData*& out, const char* na Try({ std::unordered_set conversedFlags(flagsCount); for (size_t i = 0; i < flagsCount; i++) { - conversedFlags.insert(ConstString::GetHash(flags[i])); + conversedFlags.insert(ArbUt::CaseInsensitiveConstString::GetHash(flags[i])); } - Arbutils::Collections::List effectParameterList(effectParameterCount); + ArbUt::List effectParameterList(effectParameterCount); for (size_t i = 0; i < effectParameterCount; i++) { effectParameterList[i] = effectParameters[i]; } auto effect = - new SecondaryEffect(effectChance, Arbutils::CaseInsensitiveConstString(effectName), effectParameterList); + new SecondaryEffect(effectChance, ArbUt::CaseInsensitiveConstString(effectName), effectParameterList); - out = new AttackData(ConstString(name), type, category, power, accuracy, baseUsage, target, priority, effect, - conversedFlags); + out = new AttackData(ArbUt::CaseInsensitiveConstString(name), type, category, power, accuracy, baseUsage, + target, priority, effect, conversedFlags); }) }; @@ -51,7 +51,7 @@ export const char* CreatureLib_AttackData_GetSecondaryEffectName(const AttackDat } export bool CreatureLib_AttackData_HasFlag(const AttackData* p, const char* key) { - return p->HasFlag(ConstString::GetHash(key)); + return p->HasFlag(ArbUt::CaseInsensitiveConstString::GetHash(key)); } #undef SIMPLE_GET_FUNC \ No newline at end of file diff --git a/CInterface/Library/BaseLibrary.cpp b/CInterface/Library/BaseLibrary.cpp index 7a72d88..5206ad3 100644 --- a/CInterface/Library/BaseLibrary.cpp +++ b/CInterface/Library/BaseLibrary.cpp @@ -2,7 +2,7 @@ #define BASELIBRARY(simpleName, fullname, returnType) \ export uint8_t simpleName##_Insert(fullname* p, const char* name, returnType* t) { \ - Try(p->Insert(Arbutils::CaseInsensitiveConstString::GetHash(name), t);) \ + Try(p->Insert(ArbUt::CaseInsensitiveConstString::GetHash(name), t);) \ } \ \ export uint8_t simpleName##_InsertWithHash(fullname* p, uint32_t hashedKey, returnType* t) { \ @@ -10,27 +10,27 @@ } \ \ export uint8_t simpleName##_Delete(fullname* p, const char* name) { \ - Try(p->Delete(Arbutils::CaseInsensitiveConstString::GetHash(name));) \ + Try(p->Delete(ArbUt::CaseInsensitiveConstString::GetHash(name));) \ } \ \ 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) { \ - borrowed_ptr o; \ - auto v = p->TryGet(Arbutils::CaseInsensitiveConstString::GetHash(name), o); \ + ArbUt::BorrowedPtr o; \ + auto v = p->TryGet(ArbUt::CaseInsensitiveConstString::GetHash(name), o); \ out = o.operator->(); \ return v; \ } \ \ export bool simpleName##_TryGetWithHash(fullname* p, uint32_t hashedKey, const returnType*& out) { \ - borrowed_ptr o; \ + ArbUt::BorrowedPtr o; \ auto v = p->TryGet(hashedKey, o); \ out = o.operator->(); \ return v; \ } \ \ export uint8_t simpleName##_Get(fullname* p, const char* name, const returnType*& out) { \ - Try(out = p->Get(Arbutils::CaseInsensitiveConstString::GetHash(name)).operator->();) \ + Try(out = p->Get(ArbUt::CaseInsensitiveConstString::GetHash(name)).operator->();) \ } \ \ export uint8_t simpleName##_GetWithHash(fullname* p, uint32_t hashedKey, const returnType*& out) { \ diff --git a/CInterface/Library/CreatureSpecies.cpp b/CInterface/Library/CreatureSpecies.cpp index df25248..17af8d9 100644 --- a/CInterface/Library/CreatureSpecies.cpp +++ b/CInterface/Library/CreatureSpecies.cpp @@ -6,8 +6,8 @@ export uint8_t CreatureLib_CreatureSpecies_Construct(CreatureSpecies*& out, uint SpeciesVariant* defaultVariant, float genderRatio, const char* growthRate, uint8_t captureRate) { - Try(out = new CreatureSpecies(id, Arbutils::CaseInsensitiveConstString(name), defaultVariant, genderRatio, - Arbutils::CaseInsensitiveConstString(growthRate), captureRate);) + Try(out = new CreatureSpecies(id, ArbUt::CaseInsensitiveConstString(name), defaultVariant, genderRatio, + ArbUt::CaseInsensitiveConstString(growthRate), captureRate);) } export void CreatureLib_CreatureSpecies_Destruct(const CreatureSpecies* p) { delete p; } @@ -23,21 +23,21 @@ export const char* CreatureLib_CreatureSpecies_GetGrowthRate(const CreatureSpeci return p->GetGrowthRate().c_str(); } export bool CreatureLib_CreatureSpecies_HasVariant(const CreatureSpecies* p, const char* name) { - return p->HasVariant(Arbutils::CaseInsensitiveConstString::GetHash(name)); + return p->HasVariant(ArbUt::CaseInsensitiveConstString::GetHash(name)); } export bool CreatureLib_CreatureSpecies_HasVariantWithHash(const CreatureSpecies* p, uint32_t hash) { return p->HasVariant(hash); } export bool CreatureLib_CreatureSpecies_TryGetVariant(const CreatureSpecies* p, const char* name, const SpeciesVariant*& out) { - borrowed_ptr o; - auto res = p->TryGetVariant(Arbutils::CaseInsensitiveConstString::GetHash(name), o); + ArbUt::BorrowedPtr o; + auto res = p->TryGetVariant(ArbUt::CaseInsensitiveConstString::GetHash(name), o); out = o.GetRaw(); return res; } export bool CreatureLib_CreatureSpecies_TryGetVariantWithHash(const CreatureSpecies* p, uint32_t hash, const SpeciesVariant*& out) { - borrowed_ptr o; + ArbUt::BorrowedPtr o; auto res = p->TryGetVariant(hash, o); out = o.GetRaw(); return res; @@ -45,14 +45,14 @@ export bool CreatureLib_CreatureSpecies_TryGetVariantWithHash(const CreatureSpec export uint8_t CreatureLib_CreatureSpecies_GetVariant(const SpeciesVariant*& out, const CreatureSpecies* p, const char* name) { - Try(out = p->GetVariant(Arbutils::CaseInsensitiveConstString::GetHash(name)).GetRaw();) + Try(out = p->GetVariant(ArbUt::CaseInsensitiveConstString::GetHash(name)).GetRaw();) } export uint8_t CreatureLib_CreatureSpecies_GetVariantWithHash(const SpeciesVariant* out, const CreatureSpecies* p, uint32_t hash) { Try(out = p->GetVariant(hash).GetRaw();) } export uint8_t CreatureLib_CreatureSpecies_SetVariant(CreatureSpecies* p, const char* name, SpeciesVariant* variant) { - Try(p->SetVariant(Arbutils::CaseInsensitiveConstString(name), variant);) + Try(p->SetVariant(ArbUt::CaseInsensitiveConstString(name), variant);) } #undef SIMPLE_GET_FUNC \ No newline at end of file diff --git a/CInterface/Library/EffectParameter.cpp b/CInterface/Library/EffectParameter.cpp index 9732ef3..d4f3c72 100644 --- a/CInterface/Library/EffectParameter.cpp +++ b/CInterface/Library/EffectParameter.cpp @@ -6,7 +6,7 @@ export EffectParameter* CreatureLib_EffectParameter_FromBool(bool b) { return ne export EffectParameter* CreatureLib_EffectParameter_FromInt(int64_t i) { return new EffectParameter(i); } export EffectParameter* CreatureLib_EffectParameter_FromFloat(float f) { return new EffectParameter(f); } export EffectParameter* CreatureLib_EffectParameter_FromString(const char* c) { - return new EffectParameter(Arbutils::CaseInsensitiveConstString(c)); + return new EffectParameter(ArbUt::CaseInsensitiveConstString(c)); } export void CreatureLib_EffectParameter_Destruct(const EffectParameter* p) { delete p; } diff --git a/CInterface/Library/GrowthRate.cpp b/CInterface/Library/GrowthRate.cpp index 00c69d9..24af7d3 100644 --- a/CInterface/Library/GrowthRate.cpp +++ b/CInterface/Library/GrowthRate.cpp @@ -5,7 +5,7 @@ using namespace CreatureLib::Library; export GrowthRate* CreatureLib_LookupGrowthRate_Construct(uint32_t experiencePerLevel[], size_t count) { - Arbutils::Collections::List exp(experiencePerLevel, experiencePerLevel + count); + ArbUt::List exp(experiencePerLevel, experiencePerLevel + count); return new LookupGrowthRate(exp); }; diff --git a/CInterface/Library/GrowthRateLibrary.cpp b/CInterface/Library/GrowthRateLibrary.cpp index ecccdf7..628fb1c 100644 --- a/CInterface/Library/GrowthRateLibrary.cpp +++ b/CInterface/Library/GrowthRateLibrary.cpp @@ -10,7 +10,7 @@ export void CreatureLib_GrowthRateLibrary_Destruct(GrowthRateLibrary* p) { delet 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);) + Try(out = library->CalculateLevel(ArbUt::CaseInsensitiveConstString::GetHash(growthRate), experience);) } export uint8_t CreatureLib_GrowthRateLibrary_CalculateLevelWithHash(uint8_t& out, GrowthRateLibrary* library, uint32_t growthRateHash, uint32_t experience) { @@ -19,7 +19,7 @@ export uint8_t CreatureLib_GrowthRateLibrary_CalculateLevelWithHash(uint8_t& out 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);) + Try(out = library->CalculateExperience(ArbUt::CaseInsensitiveConstString::GetHash(growthRate), level);) } export uint8_t CreatureLib_GrowthRateLibrary_CalculateExperienceWithHash(uint32_t& out, GrowthRateLibrary* library, @@ -28,7 +28,7 @@ export uint8_t CreatureLib_GrowthRateLibrary_CalculateExperienceWithHash(uint32_ } export uint8_t CreatureLib_GrowthRateLibrary_AddGrowthRate(GrowthRateLibrary* library, const char* growthRateName, GrowthRate* growthRate) { - Try(library->AddGrowthRate(Arbutils::CaseInsensitiveConstString::GetHash(growthRateName), growthRate);) + Try(library->AddGrowthRate(ArbUt::CaseInsensitiveConstString::GetHash(growthRateName), growthRate);) } export uint8_t CreatureLib_GrowthRateLibrary_AddGrowthRateWithHash(GrowthRateLibrary* library, uint32_t growthRateHash, diff --git a/CInterface/Library/Item.cpp b/CInterface/Library/Item.cpp index 6f53bdf..34de76d 100644 --- a/CInterface/Library/Item.cpp +++ b/CInterface/Library/Item.cpp @@ -1,7 +1,7 @@ #include "../../src/Library/Items/Item.hpp" #include "../Core.hpp" using namespace CreatureLib::Library; -using ConstString = Arbutils::CaseInsensitiveConstString; +using ConstString = ArbUt::CaseInsensitiveConstString; export Item* CreatureLib_Item_Construct(const char* name, ItemCategory category, BattleItemCategory battleCategory, int32_t price, const char* flags[], size_t flagsCount) { diff --git a/CInterface/Library/SpeciesVariant.cpp b/CInterface/Library/SpeciesVariant.cpp index 0b30c63..31f0cab 100644 --- a/CInterface/Library/SpeciesVariant.cpp +++ b/CInterface/Library/SpeciesVariant.cpp @@ -2,7 +2,6 @@ #include "../Core.hpp" using namespace CreatureLib::Library; -using ConstString = Arbutils::CaseInsensitiveConstString; export SpeciesVariant* CreatureLib_SpeciesVariant_Construct( const char* name, float height, float weight, uint32_t baseExperience, uint8_t types[], size_t typeLength, @@ -10,17 +9,17 @@ export SpeciesVariant* CreatureLib_SpeciesVariant_Construct( uint16_t baseMagicalDefense, uint16_t baseSpeed, const char* talents[], size_t talentsLength, const char* secretTalents[], size_t secretTalentsLength, const LearnableAttacks* attacks) { - auto talentsWrapped = Arbutils::Collections::List(talentsLength); + auto talentsWrapped = ArbUt::List(talentsLength); for (size_t i = 0; i < talentsLength; i++) { - talentsWrapped.Append(ConstString(talents[i])); + talentsWrapped.Append(ArbUt::CaseInsensitiveConstString(talents[i])); } - auto secretTalentsWrapped = Arbutils::Collections::List(secretTalentsLength); + auto secretTalentsWrapped = ArbUt::List(secretTalentsLength); for (size_t i = 0; i < secretTalentsLength; i++) { - secretTalentsWrapped.Append(ConstString(secretTalents[i])); + secretTalentsWrapped.Append(ArbUt::CaseInsensitiveConstString(secretTalents[i])); } - return new SpeciesVariant(Arbutils::CaseInsensitiveConstString(name), height, weight, baseExperience, - Arbutils::Collections::List(types, types + typeLength), + return new SpeciesVariant(ArbUt::CaseInsensitiveConstString(name), height, weight, baseExperience, + ArbUt::List(types, types + typeLength), CreatureLib::Library::StatisticSet(baseHealth, baseAttack, baseDefense, baseMagicalAttack, baseMagicalDefense, baseSpeed), diff --git a/CInterface/Library/TypeLibrary.cpp b/CInterface/Library/TypeLibrary.cpp index 2c3cb2e..ff79907 100644 --- a/CInterface/Library/TypeLibrary.cpp +++ b/CInterface/Library/TypeLibrary.cpp @@ -9,14 +9,14 @@ export TypeLibrary* CreatureLib_TypeLibrary_Construct(size_t initialCapacity) { 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) { - Try(out = p->GetTypeId(Arbutils::CaseInsensitiveConstString::GetHash(type));) + Try(out = p->GetTypeId(ArbUt::CaseInsensitiveConstString::GetHash(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(uint8_t& out, TypeLibrary* p, const char* type) { - Try(out = p->RegisterType(Arbutils::CaseInsensitiveConstString::GetHash(type));) + Try(out = p->RegisterType(ArbUt::CaseInsensitiveConstString::GetHash(type));) } export uint8_t CreatureLib_TypeLibrary_RegisterTypeWithHash(uint8_t& out, TypeLibrary* p, uint32_t type) { Try(out = p->RegisterType(type);) @@ -34,5 +34,5 @@ export uint8_t CreatureLib_TypeLibrary_GetSingleEffectiveness(float& out, TypeLi 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(defensive, defensive + defensiveCount));) + Try(out = p->GetEffectiveness(attacking, ArbUt::List(defensive, defensive + defensiveCount));) } diff --git a/src/Battling/Flow/TurnHandler.cpp b/src/Battling/Flow/TurnHandler.cpp index 40172b8..58e230e 100644 --- a/src/Battling/Flow/TurnHandler.cpp +++ b/src/Battling/Flow/TurnHandler.cpp @@ -60,7 +60,7 @@ void TurnHandler::ExecuteAttackChoice(AttackTurnChoice* choice) { // FIXME: Resolve all targets auto target = choice->GetUser()->GetBattle()->GetCreature(choice->GetTarget()); - Arbutils::Collections::List targets = {target}; + ArbUt::List targets = {target}; auto attack = new ExecutingAttack(targets, 1, choice->GetUser(), choice->GetAttack(), choice->GetAttackScript()); bool prevented = false; diff --git a/src/Battling/Flow/TurnOrdering.cpp b/src/Battling/Flow/TurnOrdering.cpp index f15c27f..81c05fc 100644 --- a/src/Battling/Flow/TurnOrdering.cpp +++ b/src/Battling/Flow/TurnOrdering.cpp @@ -29,6 +29,6 @@ public: } }; -void TurnOrdering::OrderChoices(std::vector& vec, Arbutils::Random& rand) { +void TurnOrdering::OrderChoices(std::vector& vec, ArbUt::Random& rand) { std::sort(vec.begin(), vec.end(), ChoiceCompare()); } diff --git a/src/Battling/Flow/TurnOrdering.hpp b/src/Battling/Flow/TurnOrdering.hpp index 112682f..cad76dc 100644 --- a/src/Battling/Flow/TurnOrdering.hpp +++ b/src/Battling/Flow/TurnOrdering.hpp @@ -8,7 +8,7 @@ namespace CreatureLib::Battling { class TurnOrdering { public: - static void OrderChoices(std::vector& vec, Arbutils::Random& rand); + static void OrderChoices(std::vector& vec, ArbUt::Random& rand); }; } diff --git a/src/Battling/Library/BattleLibrary.cpp b/src/Battling/Library/BattleLibrary.cpp index 4d0af15..20dea3d 100644 --- a/src/Battling/Library/BattleLibrary.cpp +++ b/src/Battling/Library/BattleLibrary.cpp @@ -43,7 +43,6 @@ const std::unique_ptr& BattleLibrary::GetDamageLibrary() co const std::unique_ptr& BattleLibrary::GetMiscLibrary() const noexcept { return _miscLibrary; } -Script* BattleLibrary::LoadScript(ScriptCategory category, - const Arbutils::CaseInsensitiveConstString& scriptName) const { +Script* BattleLibrary::LoadScript(ScriptCategory category, const ArbUt::CaseInsensitiveConstString& scriptName) const { return _scriptResolver->LoadScript(category, scriptName); } \ No newline at end of file diff --git a/src/Battling/Library/BattleLibrary.hpp b/src/Battling/Library/BattleLibrary.hpp index 86ad12b..4eb70d2 100644 --- a/src/Battling/Library/BattleLibrary.hpp +++ b/src/Battling/Library/BattleLibrary.hpp @@ -42,7 +42,7 @@ namespace CreatureLib::Battling { } [[nodiscard]] Script* LoadScript(ScriptCategory category, - const Arbutils::CaseInsensitiveConstString& scriptName) const; + const ArbUt::CaseInsensitiveConstString& scriptName) const; }; } diff --git a/src/Battling/Library/MiscLibrary.cpp b/src/Battling/Library/MiscLibrary.cpp index 0cad651..0f56263 100644 --- a/src/Battling/Library/MiscLibrary.cpp +++ b/src/Battling/Library/MiscLibrary.cpp @@ -13,7 +13,7 @@ bool CreatureLib::Battling::MiscLibrary::IsCritical(CreatureLib::Battling::Execu static CreatureLib::Battling::LearnedAttack* _replacementAttack = nullptr; static std::unique_ptr _replacementAttackData = nullptr; -static borrowed_ptr GetReplacementAttackData() { +static ArbUt::BorrowedPtr GetReplacementAttackData() { if (_replacementAttackData == nullptr) { _replacementAttackData = std::unique_ptr(new CreatureLib::Library::AttackData( diff --git a/src/Battling/Models/Battle.cpp b/src/Battling/Models/Battle.cpp index 56eedce..b30e65f 100644 --- a/src/Battling/Models/Battle.cpp +++ b/src/Battling/Models/Battle.cpp @@ -7,7 +7,7 @@ using namespace CreatureLib; using namespace CreatureLib::Battling; -const BattleLibrary* Battle::GetLibrary() const noexcept { return _library; } +const ArbUt::BorrowedPtr& Battle::GetLibrary() const noexcept { return _library; } bool Battle::CanUse(const BaseTurnChoice* choice) { AssertNotNull(choice) @@ -86,7 +86,7 @@ bool Battle::CreatureInField(const Creature* creature) const { void Battle::ForceRecall(uint8_t side, uint8_t index) { _sides[side]->SetCreature(nullptr, index); } size_t Battle::ScriptCount() const { return 1; } -void Battle::GetActiveScripts(Arbutils::Collections::List& scripts) { +void Battle::GetActiveScripts(ArbUt::List& scripts) { scripts.Append(ScriptWrapper::FromSet(&_volatile)); } diff --git a/src/Battling/Models/Battle.hpp b/src/Battling/Models/Battle.hpp index 9b1bc89..ab989e3 100644 --- a/src/Battling/Models/Battle.hpp +++ b/src/Battling/Models/Battle.hpp @@ -3,6 +3,7 @@ #include #include +#include #include "../EventHooks/EventHook.hpp" #include "../Flow/ChoiceQueue.hpp" #include "../Library/BattleLibrary.hpp" @@ -13,17 +14,15 @@ #include "BattleSide.hpp" #include "CreatureIndex.hpp" -using namespace Arbutils::Collections; - namespace CreatureLib::Battling { class Battle : public ScriptSource { protected: - const BattleLibrary* _library; - List _parties; + ArbUt::BorrowedPtr _library; + ArbUt::List> _parties; bool _canFlee; uint8_t _numberOfSides; uint8_t _creaturesPerSide; - List _sides; + ArbUt::List _sides; BattleRandom _random; ChoiceQueue* _currentTurnQueue = nullptr; bool _hasEnded = false; @@ -34,14 +33,17 @@ namespace CreatureLib::Battling { ScriptSet _volatile; public: - Battle(const BattleLibrary* library, List parties, bool canFlee = true, uint8_t numberOfSides = 2, - uint8_t creaturesPerSide = 1) - : _library(library), _parties(std::move(parties)), _canFlee(canFlee), _numberOfSides(numberOfSides), + Battle(const BattleLibrary* library, ArbUt::List parties, bool canFlee = true, + uint8_t numberOfSides = 2, uint8_t creaturesPerSide = 1) + : _library(library), _parties(parties.Count()), _canFlee(canFlee), _numberOfSides(numberOfSides), _creaturesPerSide(creaturesPerSide) { AssertNotNull(_library); AssertAllNotNull(parties); + for (size_t i = 0; i < parties.Count(); i++) { + _parties.GetStdList().push_back(std::unique_ptr(parties[i])); + } - _sides = List(numberOfSides); + _sides = ArbUt::List(numberOfSides); for (size_t i = 0; i < numberOfSides; i++) { _sides.Append(new BattleSide(i, this, creaturesPerSide)); } @@ -51,13 +53,10 @@ namespace CreatureLib::Battling { for (auto s : _sides) { delete s; } - for (auto party : _parties) { - delete party; - } delete _currentTurnQueue; } - [[nodiscard]] const BattleLibrary* GetLibrary() const noexcept; + [[nodiscard]] const ArbUt::BorrowedPtr& GetLibrary() const noexcept; [[nodiscard]] uint32_t GetCurrentTurn() const noexcept { return _currentTurn; } virtual bool CanUse(const BaseTurnChoice* choice); @@ -82,14 +81,14 @@ namespace CreatureLib::Battling { bool CanSlotBeFilled(uint8_t side, uint8_t index) const; size_t ScriptCount() const override; - void GetActiveScripts(Arbutils::Collections::List& scripts) override; + void GetActiveScripts(ArbUt::List& scripts) override; void ValidateBattleState(); inline bool HasEnded() const noexcept { return _hasEnded; } inline const BattleResult& GetResult() const noexcept { return _battleResult; } - const List& GetParties() const noexcept { return _parties; } - const List& GetSides() const noexcept { return _sides; } + const ArbUt::List>& GetParties() const noexcept { return _parties; } + const ArbUt::List& GetSides() const noexcept { return _sides; } Script* GetVolatileScript(const ConstString& key) const { return _volatile.Get(key); } Script* GetVolatileScript(uint32_t keyHash) const noexcept { return _volatile.Get(keyHash); } void AddVolatileScript(const ConstString& key); diff --git a/src/Battling/Models/BattleParty.hpp b/src/Battling/Models/BattleParty.hpp index 402d84e..3ca0591 100644 --- a/src/Battling/Models/BattleParty.hpp +++ b/src/Battling/Models/BattleParty.hpp @@ -6,21 +6,19 @@ #include "CreatureIndex.hpp" #include "CreatureParty.hpp" -using namespace Arbutils::Collections; - namespace CreatureLib::Battling { class BattleParty { CreatureParty* _party; - List _responsibleIndices; + ArbUt::List _responsibleIndices; public: - BattleParty(CreatureParty* party, const List& responsibleIndices) + BattleParty(CreatureParty* party, const ArbUt::List& responsibleIndices) : _party(party), _responsibleIndices(responsibleIndices) { AssertNotNull(_party) } inline CreatureParty* GetParty() const { return _party; } - inline const List& GetResponsibleIndices() const { return _responsibleIndices; } + inline const ArbUt::List& GetResponsibleIndices() const { return _responsibleIndices; } inline bool IsResponsibleForIndex(const CreatureIndex& index) const { return _responsibleIndices.Contains(index); diff --git a/src/Battling/Models/BattleRandom.hpp b/src/Battling/Models/BattleRandom.hpp index ca9b387..fc7b76d 100644 --- a/src/Battling/Models/BattleRandom.hpp +++ b/src/Battling/Models/BattleRandom.hpp @@ -9,7 +9,7 @@ namespace CreatureLib::Battling { class BattleRandom { private: - Arbutils::Random _random; + ArbUt::Random _random; public: BattleRandom() noexcept : _random() {} @@ -19,7 +19,7 @@ namespace CreatureLib::Battling { int32_t Get() noexcept { return _random.Get(); } int32_t Get(int32_t max) noexcept { return _random.Get(max); } int32_t Get(int32_t min, int32_t max) noexcept { return _random.Get(min, max); } - Arbutils::Random& GetRNG() noexcept { return _random; } + ArbUt::Random& GetRNG() noexcept { return _random; } uint_fast32_t GetSeed() const noexcept { return _random.GetSeed(); } }; } diff --git a/src/Battling/Models/BattleSide.cpp b/src/Battling/Models/BattleSide.cpp index 7b6dbc2..bc73b99 100644 --- a/src/Battling/Models/BattleSide.cpp +++ b/src/Battling/Models/BattleSide.cpp @@ -26,7 +26,7 @@ void BattleSide::ResetChoices() noexcept { } } -const List& BattleSide::GetChoices() const noexcept { return _choices; } +const ArbUt::List& BattleSide::GetChoices() const noexcept { return _choices; } void BattleSide::SetChoice(BaseTurnChoice* choice) { AssertNotNull(choice) @@ -69,7 +69,7 @@ bool BattleSide::CreatureOnSide(const Creature* creature) const { Creature* BattleSide::GetCreature(uint8_t index) const { return _creatures[index]; } -void BattleSide::GetActiveScripts(Arbutils::Collections::List& scripts) { +void BattleSide::GetActiveScripts(ArbUt::List& scripts) { scripts.Append(ScriptWrapper::FromSet(&_volatile)); _battle->GetActiveScripts(scripts); } diff --git a/src/Battling/Models/BattleSide.hpp b/src/Battling/Models/BattleSide.hpp index dae3aa9..74919f1 100644 --- a/src/Battling/Models/BattleSide.hpp +++ b/src/Battling/Models/BattleSide.hpp @@ -7,15 +7,13 @@ #include "../TurnChoices/BaseTurnChoice.hpp" #include "Creature.hpp" -using namespace Arbutils::Collections; - namespace CreatureLib::Battling { class BattleSide : public ScriptSource { uint8_t _index; uint8_t _creaturesPerSide; - List _creatures; - List _choices; - List _fillableSlots; + ArbUt::List _creatures; + ArbUt::List _choices; + ArbUt::List _fillableSlots; uint8_t _choicesSet = 0; ScriptSet _volatile; Battle* _battle; @@ -36,7 +34,7 @@ namespace CreatureLib::Battling { virtual ~BattleSide() = default; [[nodiscard]] bool AllChoicesSet() const noexcept; - [[nodiscard]] const List& GetChoices() const noexcept; + [[nodiscard]] const ArbUt::List& GetChoices() const noexcept; [[nodiscard]] bool AllPossibleSlotsFilled() const; @@ -49,9 +47,9 @@ namespace CreatureLib::Battling { bool CreatureOnSide(const Creature* creature) const; size_t ScriptCount() const override; - void GetActiveScripts(Arbutils::Collections::List& scripts) override; + void GetActiveScripts(ArbUt::List& scripts) override; - const List& GetCreatures() { return _creatures; } + const ArbUt::List& GetCreatures() { return _creatures; } uint8_t GetSideIndex() noexcept { return _index; } uint8_t GetCreatureIndex(Creature* c) { diff --git a/src/Battling/Models/CreateCreature.cpp b/src/Battling/Models/CreateCreature.cpp index ad966b7..b1da5cf 100644 --- a/src/Battling/Models/CreateCreature.cpp +++ b/src/Battling/Models/CreateCreature.cpp @@ -5,7 +5,7 @@ using namespace CreatureLib::Battling; -CreateCreature CreateCreature::WithVariant(const Arbutils::CaseInsensitiveConstString& variant) { +CreateCreature CreateCreature::WithVariant(const ArbUt::CaseInsensitiveConstString& variant) { this->_variant = variant; return *this; } @@ -20,7 +20,7 @@ CreateCreature CreateCreature::WithGender(Library::Gender gender) { return *this; } -CreateCreature CreateCreature::WithAttack(const Arbutils::CaseInsensitiveConstString& attackName, +CreateCreature CreateCreature::WithAttack(const ArbUt::CaseInsensitiveConstString& attackName, AttackLearnMethod learnMethod) { if (_attacks.Count() >= _library->GetSettings()->GetMaximalMoves()) throw CreatureException("You have already set the maximum amount of allowed moves."); @@ -31,7 +31,7 @@ CreateCreature CreateCreature::WithAttack(const Arbutils::CaseInsensitiveConstSt } Creature* CreateCreature::Create() { - auto rand = Arbutils::Random(); + auto rand = ArbUt::Random(); auto species = this->_library->GetSpeciesLibrary()->Get(this->_species.GetHash()); auto variant = species->GetVariant(this->_variant); Library::TalentIndex talent; @@ -48,7 +48,7 @@ Creature* CreateCreature::Create() { if (gender == static_cast(-1)) { gender = species->GetRandomGender(rand); } - borrowed_ptr heldItem; + ArbUt::BorrowedPtr heldItem; if (!this->_heldItem.Empty()) { if (!_library->GetItemLibrary()->TryGet(this->_heldItem.GetHash(), heldItem)) { throw CreatureException("Invalid held item."); @@ -56,7 +56,7 @@ Creature* CreateCreature::Create() { } auto experience = _library->GetGrowthRateLibrary()->CalculateExperience(species->GetGrowthRate(), _level); - auto attacks = List(_attacks.Count()); + auto attacks = ArbUt::List(_attacks.Count()); for (size_t i = 0; i < _attacks.Count(); i++) { auto kv = _attacks[i]; attacks.Append(new LearnedAttack(std::get<0>(kv), std::get<1>(kv))); diff --git a/src/Battling/Models/CreateCreature.hpp b/src/Battling/Models/CreateCreature.hpp index 5d9d7fc..65a4a7a 100644 --- a/src/Battling/Models/CreateCreature.hpp +++ b/src/Battling/Models/CreateCreature.hpp @@ -6,33 +6,30 @@ #include "../Library/BattleLibrary.hpp" #include "Creature.hpp" -using namespace Arbutils::Collections; - namespace CreatureLib::Battling { class CreateCreature { const BattleLibrary* _library; - Arbutils::CaseInsensitiveConstString _species; - Arbutils::CaseInsensitiveConstString _variant = "default"_cnc; + ArbUt::CaseInsensitiveConstString _species; + ArbUt::CaseInsensitiveConstString _variant = "default"_cnc; uint8_t _level; std::string _nickname = ""; - Arbutils::CaseInsensitiveConstString _talent = ""_cnc; + ArbUt::CaseInsensitiveConstString _talent = ""_cnc; Library::Gender _gender = static_cast(-1); uint8_t _coloring = 0; - Arbutils::CaseInsensitiveConstString _heldItem = ""_cnc; + ArbUt::CaseInsensitiveConstString _heldItem = ""_cnc; uint32_t _identifier = 0; - List, AttackLearnMethod>> _attacks; + ArbUt::List, AttackLearnMethod>> _attacks; public: - CreateCreature(const BattleLibrary* library, const Arbutils::CaseInsensitiveConstString& species, uint8_t level) + CreateCreature(const BattleLibrary* library, const ArbUt::CaseInsensitiveConstString& species, uint8_t level) : _library(library), _species(species), _level(level), _attacks(library->GetSettings()->GetMaximalMoves()) { } - CreateCreature WithVariant(const Arbutils::CaseInsensitiveConstString& variant); + CreateCreature WithVariant(const ArbUt::CaseInsensitiveConstString& variant); CreateCreature WithNickname(std::string nickname); CreateCreature WithGender(Library::Gender gender); - CreateCreature WithAttack(const Arbutils::CaseInsensitiveConstString& attackName, - AttackLearnMethod learnMethod); + CreateCreature WithAttack(const ArbUt::CaseInsensitiveConstString& attackName, AttackLearnMethod learnMethod); Creature* Create(); }; diff --git a/src/Battling/Models/Creature.cpp b/src/Battling/Models/Creature.cpp index 5d7b1c0..784e33b 100644 --- a/src/Battling/Models/Creature.cpp +++ b/src/Battling/Models/Creature.cpp @@ -6,11 +6,12 @@ using namespace CreatureLib; -Battling::Creature::Creature(const BattleLibrary* library, const borrowed_ptr& species, - const borrowed_ptr& variant, uint8_t level, +Battling::Creature::Creature(const BattleLibrary* library, + const ArbUt::BorrowedPtr& species, + const ArbUt::BorrowedPtr& variant, uint8_t level, uint32_t experience, uint32_t uid, Library::Gender gender, uint8_t coloring, - const borrowed_ptr heldItem, std::string nickname, - const Library::TalentIndex& talent, const List& attacks, + const ArbUt::BorrowedPtr heldItem, std::string nickname, + const Library::TalentIndex& talent, const ArbUt::List& attacks, bool allowedExperienceGain) : _library(library), _species(species), _variant(variant), _level(level), _experience(experience), _uniqueIdentifier(uid), _gender(gender), _coloring(coloring), _heldItem(heldItem), _nickname(std::move(nickname)), @@ -146,7 +147,7 @@ void Battling::Creature::OverrideActiveTalent(const ConstString& talent) { _activeTalent = this->_library->LoadScript(ScriptCategory::Talent, talent); } -const List& Battling::Creature::GetTypes() const noexcept { +const ArbUt::List& Battling::Creature::GetTypes() const noexcept { // HOOK: override types. return this->_variant->GetTypes(); } @@ -164,7 +165,7 @@ size_t Battling::Creature::ScriptCount() const { return c; } -void Battling::Creature::GetActiveScripts(Arbutils::Collections::List& scripts) { +void Battling::Creature::GetActiveScripts(ArbUt::List& scripts) { scripts.Append(ScriptWrapper::FromScript(&_activeTalent)); scripts.Append(ScriptWrapper::FromScript(&_status)); scripts.Append(ScriptWrapper::FromSet(&_volatile)); @@ -186,27 +187,27 @@ void Battling::Creature::AddExperience(uint32_t amount) { _experience = exp; _level = level; } -borrowed_ptr Battling::Creature::GetDisplaySpecies() const noexcept { +ArbUt::BorrowedPtr Battling::Creature::GetDisplaySpecies() const noexcept { auto species = _displaySpecies; if (species == nullptr) species = _species; return species; } -borrowed_ptr Battling::Creature::GetDisplayVariant() const noexcept { +ArbUt::BorrowedPtr Battling::Creature::GetDisplayVariant() const noexcept { auto variant = _displayVariant; if (variant == nullptr) variant = _variant; return variant; } void Battling::Creature::SetHeldItem(const ConstString& itemName) { - borrowed_ptr item; + ArbUt::BorrowedPtr item; if (!_library->GetItemLibrary()->TryGet(itemName.GetHash(), item)) { throw CreatureException("Item not found."); } _heldItem = item; } void Battling::Creature::SetHeldItem(uint32_t itemNameHash) { - borrowed_ptr item; + ArbUt::BorrowedPtr item; if (!_library->GetItemLibrary()->TryGet(itemNameHash, item)) { throw CreatureException("Item not found."); } diff --git a/src/Battling/Models/Creature.hpp b/src/Battling/Models/Creature.hpp index 1363de2..822f5a9 100644 --- a/src/Battling/Models/Creature.hpp +++ b/src/Battling/Models/Creature.hpp @@ -2,7 +2,7 @@ #define CREATURELIB_BATTLECREATURE_HPP #include -#include +#include #include "../../Library/ClampedStatisticSet.hpp" #include "../../Library/CreatureData/CreatureSpecies.hpp" #include "../../Library/Items/Item.hpp" @@ -12,8 +12,6 @@ #include "DamageSource.hpp" #include "LearnedAttack.hpp" -using namespace Arbutils::Collections; - namespace CreatureLib::Battling { // Forward declare battle class class Battle; @@ -24,18 +22,18 @@ namespace CreatureLib::Battling { protected: const BattleLibrary* _library; - borrowed_ptr _species; - borrowed_ptr _variant; + ArbUt::BorrowedPtr _species; + ArbUt::BorrowedPtr _variant; - borrowed_ptr _displaySpecies = nullptr; - borrowed_ptr _displayVariant = nullptr; + ArbUt::BorrowedPtr _displaySpecies = nullptr; + ArbUt::BorrowedPtr _displayVariant = nullptr; uint8_t _level; uint32_t _experience; uint32_t _uniqueIdentifier; Library::Gender _gender; uint8_t _coloring; - borrowed_ptr _heldItem; + ArbUt::BorrowedPtr _heldItem; uint32_t _currentHealth; Library::ClampedStatisticSet _statBoost; @@ -51,10 +49,10 @@ namespace CreatureLib::Battling { Script* _activeTalent = nullptr; bool _hasOverridenTalent; - ConstString _overridenTalentName = ""_cnc; + ArbUt::CaseInsensitiveConstString _overridenTalentName = ""_cnc; std::unordered_set _seenOpponents = {}; - List _attacks; + ArbUt::List _attacks; bool _allowedExperienceGain; Script* _status = nullptr; @@ -64,11 +62,11 @@ namespace CreatureLib::Battling { void OnFaint(); public: - Creature(const BattleLibrary* library, const borrowed_ptr& species, - const borrowed_ptr& variant, uint8_t level, uint32_t experience, + Creature(const BattleLibrary* library, const ArbUt::BorrowedPtr& species, + const ArbUt::BorrowedPtr& variant, uint8_t level, uint32_t experience, uint32_t uid, Library::Gender gender, uint8_t coloring, - const borrowed_ptr heldItem, std::string nickname, - const Library::TalentIndex& talent, const List& attacks, + const ArbUt::BorrowedPtr heldItem, std::string nickname, + const Library::TalentIndex& talent, const ArbUt::List& attacks, bool allowedExperienceGain = true); virtual ~Creature() { @@ -84,22 +82,24 @@ namespace CreatureLib::Battling { _currentHealth = GetBoostedStat(Library::Statistic::Health); } - inline const borrowed_ptr& GetSpecies() const noexcept { return _species; } - inline const borrowed_ptr& GetVariant() const noexcept { return _variant; } + inline const ArbUt::BorrowedPtr& GetSpecies() const noexcept { + return _species; + } + inline const ArbUt::BorrowedPtr& GetVariant() const noexcept { return _variant; } inline uint8_t GetLevel() const noexcept { return _level; } inline uint32_t GetExperience() const noexcept { return _experience; } inline Library::Gender GetGender() const noexcept { return _gender; } inline uint8_t GetColoring() const noexcept { return _coloring; } - inline bool HasHeldItem(const ConstString& name) const noexcept { + inline bool HasHeldItem(const ArbUt::CaseInsensitiveConstString& name) const noexcept { return _heldItem != nullptr && _heldItem->GetName() == name; } inline bool HasHeldItem(uint32_t nameHash) const noexcept { return _heldItem != nullptr && _heldItem->GetName() == nameHash; } - inline const borrowed_ptr& GetHeldItem() const noexcept { return _heldItem; } - void SetHeldItem(const ConstString& itemName); + inline const ArbUt::BorrowedPtr& GetHeldItem() const noexcept { return _heldItem; } + void SetHeldItem(const ArbUt::CaseInsensitiveConstString& itemName); void SetHeldItem(uint32_t itemNameHash); - inline void SetHeldItem(const borrowed_ptr& item) noexcept { _heldItem = item; }; + inline void SetHeldItem(const ArbUt::BorrowedPtr& item) noexcept { _heldItem = item; }; inline uint32_t GetCurrentHealth() const noexcept { return _currentHealth; } @@ -110,37 +110,37 @@ namespace CreatureLib::Battling { bool IsOnBattleField() const { return _onBattleField; } const std::string& GetNickname() const noexcept { return _nickname; } - const ConstString& GetActiveTalent() const; + const ArbUt::CaseInsensitiveConstString& GetActiveTalent() const; [[nodiscard]] bool IsFainted() const noexcept; - [[nodiscard]] const List& GetTypes() const noexcept; + [[nodiscard]] const ArbUt::List& GetTypes() const noexcept; [[nodiscard]] bool HasType(uint8_t type) const noexcept; uint32_t GetMaxHealth() const noexcept { return _boostedStats.GetHealth(); } void ChangeLevelBy(int8_t amount); void Damage(uint32_t damage, DamageSource source); void Heal(uint32_t amount, bool canRevive = false); - void OverrideActiveTalent(const ConstString& talent); + void OverrideActiveTalent(const ArbUt::CaseInsensitiveConstString& talent); void AddExperience(uint32_t amount); void MarkOpponentAsSeen(Creature* creature) { _seenOpponents.insert(creature); } const std::unordered_set& GetSeenOpponents() const { return _seenOpponents; } size_t ScriptCount() const override; - void GetActiveScripts(Arbutils::Collections::List& scripts) override; + void GetActiveScripts(ArbUt::List& scripts) override; void ClearVolatileScripts(); - void AddVolatileScript(const ConstString& name); + void AddVolatileScript(const ArbUt::CaseInsensitiveConstString& name); void AddVolatileScript(Script* script); - void RemoveVolatileScript(const ConstString& name); + void RemoveVolatileScript(const ArbUt::CaseInsensitiveConstString& name); void RemoveVolatileScript(Script* script); - bool HasVolatileScript(const ConstString& name) const; + bool HasVolatileScript(const ArbUt::CaseInsensitiveConstString& name) const; - const List& GetAttacks() noexcept { return _attacks; } + const ArbUt::List& GetAttacks() noexcept { return _attacks; } - borrowed_ptr GetDisplaySpecies() const noexcept; - borrowed_ptr GetDisplayVariant() const noexcept; + ArbUt::BorrowedPtr GetDisplaySpecies() const noexcept; + ArbUt::BorrowedPtr GetDisplayVariant() const noexcept; - void SetDisplaySpecies(const borrowed_ptr& species) noexcept { + void SetDisplaySpecies(const ArbUt::BorrowedPtr& species) noexcept { _displaySpecies = species; } void SetDisplayVariant(const Library::SpeciesVariant* variant) noexcept { _displayVariant = variant; }; diff --git a/src/Battling/Models/CreatureParty.hpp b/src/Battling/Models/CreatureParty.hpp index 7503148..8eae008 100644 --- a/src/Battling/Models/CreatureParty.hpp +++ b/src/Battling/Models/CreatureParty.hpp @@ -6,11 +6,11 @@ namespace CreatureLib::Battling { class CreatureParty { - Arbutils::Collections::List _party; + ArbUt::List _party; public: CreatureParty(size_t size) noexcept : _party(size) {} - CreatureParty(Arbutils::Collections::List party) noexcept : _party(party) {} + CreatureParty(ArbUt::List party) noexcept : _party(party) {} CreatureParty(std::initializer_list party) noexcept : _party(party) {} virtual ~CreatureParty() noexcept { @@ -38,8 +38,8 @@ namespace CreatureLib::Battling { return false; } - Arbutils::Collections::List& GetParty() noexcept { return _party; } - const Arbutils::Collections::List& GetParty() const noexcept { return _party; } + ArbUt::List& GetParty() noexcept { return _party; } + const ArbUt::List& GetParty() const noexcept { return _party; } size_t GetLength() const noexcept { return _party.Count(); } }; diff --git a/src/Battling/Models/ExecutingAttack.hpp b/src/Battling/Models/ExecutingAttack.hpp index d7ff3b7..aef47e8 100644 --- a/src/Battling/Models/ExecutingAttack.hpp +++ b/src/Battling/Models/ExecutingAttack.hpp @@ -9,8 +9,6 @@ #include #include "Creature.hpp" -using namespace Arbutils::Collections; - namespace CreatureLib::Battling { class ExecutingAttack : public ScriptSource { public: @@ -38,16 +36,16 @@ namespace CreatureLib::Battling { }; private: - List _targets; + ArbUt::List _targets; uint8_t _numberHits; - List _hits; + ArbUt::List _hits; Creature* _user; LearnedAttack* _attack; Script* _script; public: - ExecutingAttack(const List& targets, uint8_t numberHits, Creature* user, LearnedAttack* attack, - Script* script) + ExecutingAttack(const ArbUt::List& targets, uint8_t numberHits, Creature* user, + LearnedAttack* attack, Script* script) : _targets(targets.Count()), _numberHits(numberHits), _hits(targets.Count() * numberHits), _user(user), _attack(attack), _script(script) { AssertNotNull(user) @@ -79,7 +77,7 @@ namespace CreatureLib::Battling { } bool IsCreatureTarget(Creature* creature) noexcept { return _targets.IndexOf(creature) != (size_t)-1; } - const List& GetTargets() noexcept { return _targets; } + const ArbUt::List& GetTargets() noexcept { return _targets; } uint8_t GetNumberOfHits() const noexcept { return _numberHits; } Creature* GetUser() noexcept { return _user; } @@ -88,7 +86,7 @@ namespace CreatureLib::Battling { size_t ScriptCount() const override { return _user->ScriptCount() + 1; } protected: - void GetActiveScripts(Arbutils::Collections::List& scripts) override { + void GetActiveScripts(ArbUt::List& scripts) override { scripts.Append(ScriptWrapper::FromScript(&_script)); _user->GetActiveScripts(scripts); } diff --git a/src/Battling/Models/LearnedAttack.cpp b/src/Battling/Models/LearnedAttack.cpp index 97e335e..907521c 100644 --- a/src/Battling/Models/LearnedAttack.cpp +++ b/src/Battling/Models/LearnedAttack.cpp @@ -1,18 +1,19 @@ #include "LearnedAttack.hpp" #include -CreatureLib::Battling::LearnedAttack::LearnedAttack(const borrowed_ptr& attack, - uint8_t maxUses, AttackLearnMethod learnMethod) +CreatureLib::Battling::LearnedAttack::LearnedAttack( + const ArbUt::BorrowedPtr& attack, uint8_t maxUses, + AttackLearnMethod learnMethod) : _attack(attack), _maxUses(maxUses), _remainingUses(maxUses), _learnMethod(learnMethod) { AssertNotNull(_attack) } -CreatureLib::Battling::LearnedAttack::LearnedAttack(const borrowed_ptr& attack, - AttackLearnMethod learnMethod) +CreatureLib::Battling::LearnedAttack::LearnedAttack( + const ArbUt::BorrowedPtr& attack, AttackLearnMethod learnMethod) : _attack(attack), _maxUses(attack->GetBaseUsages()), _remainingUses(_maxUses), _learnMethod(learnMethod) { AssertNotNull(_attack) } -const borrowed_ptr& +const ArbUt::BorrowedPtr& CreatureLib::Battling::LearnedAttack::GetAttack() const noexcept { return _attack; } diff --git a/src/Battling/Models/LearnedAttack.hpp b/src/Battling/Models/LearnedAttack.hpp index 88584fb..45250c5 100644 --- a/src/Battling/Models/LearnedAttack.hpp +++ b/src/Battling/Models/LearnedAttack.hpp @@ -1,27 +1,27 @@ #ifndef CREATURELIB_LEARNEDATTACK_HPP #define CREATURELIB_LEARNEDATTACK_HPP -#include +#include #include #include "../../Library/Attacks/AttackData.hpp" #include "AttackLearnMethod.hpp" namespace CreatureLib::Battling { class LearnedAttack { - borrowed_ptr _attack; + ArbUt::BorrowedPtr _attack; uint8_t _maxUses; uint8_t _remainingUses; AttackLearnMethod _learnMethod; public: - LearnedAttack(const borrowed_ptr& attack, uint8_t maxUses, + LearnedAttack(const ArbUt::BorrowedPtr& attack, uint8_t maxUses, AttackLearnMethod learnMethod); - LearnedAttack(const borrowed_ptr& attack, + LearnedAttack(const ArbUt::BorrowedPtr& attack, AttackLearnMethod learnMethod); virtual ~LearnedAttack() = default; - const borrowed_ptr& GetAttack() const noexcept; + const ArbUt::BorrowedPtr& GetAttack() const noexcept; uint8_t GetMaxUses() const noexcept; uint8_t GetRemainingUses() const noexcept; AttackLearnMethod GetLearnMethod() const noexcept; diff --git a/src/Battling/ScriptHandling/Script.hpp b/src/Battling/ScriptHandling/Script.hpp index c5d1f15..bcad16a 100644 --- a/src/Battling/ScriptHandling/Script.hpp +++ b/src/Battling/ScriptHandling/Script.hpp @@ -5,8 +5,6 @@ #include #include "../../Library/EffectParameter.hpp" -using ConstString = Arbutils::CaseInsensitiveConstString; - namespace CreatureLib::Battling { class BaseTurnChoice; class AttackTurnChoice; @@ -21,13 +19,12 @@ namespace CreatureLib::Battling { virtual void Stack(){}; virtual void OnRemove(){}; - virtual const ConstString& GetName() const noexcept = 0; + virtual const ArbUt::CaseInsensitiveConstString& GetName() const noexcept = 0; - virtual void - OnInitialize(const Arbutils::Collections::List& parameters){}; + virtual void OnInitialize(const ArbUt::List& parameters){}; virtual void OnBeforeTurn(const BaseTurnChoice* choice){}; - virtual void ChangeAttack(AttackTurnChoice* choice, ConstString* outAttack){}; + virtual void ChangeAttack(AttackTurnChoice* choice, ArbUt::CaseInsensitiveConstString* outAttack){}; virtual void PreventAttack(ExecutingAttack* attack, bool* outResult){}; virtual void FailAttack(ExecutingAttack* attack, bool* outFailed){}; virtual void StopBeforeAttack(ExecutingAttack* attack, bool* outResult){}; diff --git a/src/Battling/ScriptHandling/ScriptAggregator.hpp b/src/Battling/ScriptHandling/ScriptAggregator.hpp index 3e66f6a..b0ee820 100644 --- a/src/Battling/ScriptHandling/ScriptAggregator.hpp +++ b/src/Battling/ScriptHandling/ScriptAggregator.hpp @@ -7,8 +7,6 @@ #include "ScriptSet.hpp" #include "ScriptWrapper.hpp" -using namespace Arbutils::Collections; - namespace CreatureLib::Battling { class ScriptAggregator { const ScriptWrapper* _scripts; @@ -18,7 +16,7 @@ namespace CreatureLib::Battling { public: ScriptAggregator(){}; - explicit ScriptAggregator(const List& scripts) + explicit ScriptAggregator(const ArbUt::List& scripts) : _scripts(scripts.RawData()), _size(scripts.Count()){}; inline void Reset() { diff --git a/src/Battling/ScriptHandling/ScriptResolver.hpp b/src/Battling/ScriptHandling/ScriptResolver.hpp index dec4df7..9a154d8 100644 --- a/src/Battling/ScriptHandling/ScriptResolver.hpp +++ b/src/Battling/ScriptHandling/ScriptResolver.hpp @@ -14,7 +14,9 @@ namespace CreatureLib::Battling { virtual ~ScriptResolver() = default; virtual void Initialize(BattleLibrary* library){}; - virtual Script* LoadScript(ScriptCategory category, const ConstString& scriptName) const { return nullptr; }; + virtual Script* LoadScript(ScriptCategory category, const ArbUt::CaseInsensitiveConstString& scriptName) const { + return nullptr; + }; }; } diff --git a/src/Battling/ScriptHandling/ScriptSet.hpp b/src/Battling/ScriptHandling/ScriptSet.hpp index 88dd0c7..b5f76a5 100644 --- a/src/Battling/ScriptHandling/ScriptSet.hpp +++ b/src/Battling/ScriptHandling/ScriptSet.hpp @@ -8,8 +8,8 @@ namespace CreatureLib::Battling { class ScriptSet { - Arbutils::Collections::List _scripts; - Arbutils::Collections::Dictionary _lookup; + ArbUt::List _scripts; + ArbUt::Dictionary _lookup; public: ~ScriptSet() { @@ -33,7 +33,7 @@ namespace CreatureLib::Battling { _lookup.Insert(script->GetName(), _scripts.Count() - 1); } - Script* Get(const ConstString& key) const { return Get(key.GetHash()); } + Script* Get(const ArbUt::CaseInsensitiveConstString& key) const { return Get(key.GetHash()); } Script* Get(uint32_t keyHash) const noexcept { size_t v; @@ -43,7 +43,7 @@ namespace CreatureLib::Battling { return nullptr; } - void Remove(const ConstString& key) { Remove(key.GetHash()); } + void Remove(const ArbUt::CaseInsensitiveConstString& key) { Remove(key.GetHash()); } void Remove(uint32_t keyHash) { size_t v; @@ -65,13 +65,13 @@ namespace CreatureLib::Battling { _lookup.Clear(); } - bool Has(const ConstString& key) const { return _lookup.Has(key); } + bool Has(const ArbUt::CaseInsensitiveConstString& key) const { return _lookup.Has(key); } bool Has(uint32_t keyHash) const { return _lookup.Has(keyHash); } inline size_t Count() const { return _scripts.Count(); } - const Arbutils::Collections::List* GetIterator() const { return &_scripts; } + const ArbUt::List* GetIterator() const { return &_scripts; } }; } diff --git a/src/Battling/ScriptHandling/ScriptSource.hpp b/src/Battling/ScriptHandling/ScriptSource.hpp index 49a2809..8c84a9e 100644 --- a/src/Battling/ScriptHandling/ScriptSource.hpp +++ b/src/Battling/ScriptHandling/ScriptSource.hpp @@ -8,11 +8,11 @@ namespace CreatureLib::Battling { class ScriptSource { bool _areScriptsInitialized = false; - List _scripts; + ArbUt::List _scripts; ScriptAggregator _scriptsIterator; protected: - virtual void GetActiveScripts(Arbutils::Collections::List& scripts) = 0; + virtual void GetActiveScripts(ArbUt::List& scripts) = 0; void ResetActiveScripts() { _areScriptsInitialized = false; } public: diff --git a/src/Battling/TurnChoices/AttackTurnChoice.hpp b/src/Battling/TurnChoices/AttackTurnChoice.hpp index 251c45e..6deecf4 100644 --- a/src/Battling/TurnChoices/AttackTurnChoice.hpp +++ b/src/Battling/TurnChoices/AttackTurnChoice.hpp @@ -56,7 +56,7 @@ namespace CreatureLib::Battling { size_t ScriptCount() const override { return 1 + GetUser()->ScriptCount(); } protected: - void GetActiveScripts(Arbutils::Collections::List& scripts) override { + void GetActiveScripts(ArbUt::List& scripts) override { scripts.Append(ScriptWrapper::FromScript(&_attackScript)); GetUser()->GetActiveScripts(scripts); } diff --git a/src/Battling/TurnChoices/FleeTurnChoice.hpp b/src/Battling/TurnChoices/FleeTurnChoice.hpp index 749df8b..700dab9 100644 --- a/src/Battling/TurnChoices/FleeTurnChoice.hpp +++ b/src/Battling/TurnChoices/FleeTurnChoice.hpp @@ -13,9 +13,7 @@ namespace CreatureLib::Battling { size_t ScriptCount() const override { return GetUser()->ScriptCount(); } protected: - void GetActiveScripts(Arbutils::Collections::List& scripts) override { - GetUser()->GetActiveScripts(scripts); - } + void GetActiveScripts(ArbUt::List& scripts) override { GetUser()->GetActiveScripts(scripts); } }; } diff --git a/src/Battling/TurnChoices/PassTurnChoice.hpp b/src/Battling/TurnChoices/PassTurnChoice.hpp index 5b67c10..2b3255c 100644 --- a/src/Battling/TurnChoices/PassTurnChoice.hpp +++ b/src/Battling/TurnChoices/PassTurnChoice.hpp @@ -12,9 +12,7 @@ namespace CreatureLib::Battling { size_t ScriptCount() const override { return GetUser()->ScriptCount(); } protected: - void GetActiveScripts(Arbutils::Collections::List& scripts) override { - GetUser()->GetActiveScripts(scripts); - } + void GetActiveScripts(ArbUt::List& scripts) override { GetUser()->GetActiveScripts(scripts); } }; } diff --git a/src/Battling/TurnChoices/SwitchTurnChoice.hpp b/src/Battling/TurnChoices/SwitchTurnChoice.hpp index 23e2316..d199c6d 100644 --- a/src/Battling/TurnChoices/SwitchTurnChoice.hpp +++ b/src/Battling/TurnChoices/SwitchTurnChoice.hpp @@ -16,9 +16,7 @@ namespace CreatureLib::Battling { size_t ScriptCount() const override { return GetUser()->ScriptCount(); } protected: - void GetActiveScripts(Arbutils::Collections::List& scripts) override { - GetUser()->GetActiveScripts(scripts); - } + void GetActiveScripts(ArbUt::List& scripts) override { GetUser()->GetActiveScripts(scripts); } }; } diff --git a/src/Library/Attacks/AttackData.cpp b/src/Library/Attacks/AttackData.cpp index d7c83b2..c40116b 100644 --- a/src/Library/Attacks/AttackData.cpp +++ b/src/Library/Attacks/AttackData.cpp @@ -1,7 +1,7 @@ #include "AttackData.hpp" #include -CreatureLib::Library::AttackData::AttackData(const ConstString& name, uint8_t type, +CreatureLib::Library::AttackData::AttackData(const ArbUt::CaseInsensitiveConstString& name, uint8_t type, CreatureLib::Library::AttackCategory category, uint8_t power, uint8_t accuracy, uint8_t baseUsage, CreatureLib::Library::AttackTarget target, int8_t priority, @@ -9,7 +9,7 @@ CreatureLib::Library::AttackData::AttackData(const ConstString& name, uint8_t ty : _name(name), _type(type), _category(category), _basePower(power), _accuracy(accuracy), _baseUsages(baseUsage), _target(target), _priority(priority), _effect(effect), _flags(std::move(flags)) {} -bool CreatureLib::Library::AttackData::HasFlag(const ConstString& key) const noexcept { +bool CreatureLib::Library::AttackData::HasFlag(const ArbUt::CaseInsensitiveConstString& key) const noexcept { return this->_flags.find(key) != this->_flags.end(); } bool CreatureLib::Library::AttackData::HasFlag(uint32_t key) const noexcept { diff --git a/src/Library/Attacks/AttackData.hpp b/src/Library/Attacks/AttackData.hpp index df3a89e..0107301 100644 --- a/src/Library/Attacks/AttackData.hpp +++ b/src/Library/Attacks/AttackData.hpp @@ -9,12 +9,10 @@ #include "AttackTarget.hpp" #include "SecondaryEffect.hpp" -using ConstString = Arbutils::CaseInsensitiveConstString; - namespace CreatureLib::Library { class AttackData { protected: - ConstString _name; + ArbUt::CaseInsensitiveConstString _name; uint8_t _type; AttackCategory _category; uint8_t _basePower; @@ -26,12 +24,12 @@ namespace CreatureLib::Library { std::unordered_set _flags; public: - AttackData(const ConstString& name, uint8_t type, AttackCategory category, uint8_t power, uint8_t accuracy, - uint8_t baseUsage, AttackTarget target, int8_t priority, const SecondaryEffect* effect, - std::unordered_set flags); + AttackData(const ArbUt::CaseInsensitiveConstString& name, uint8_t type, AttackCategory category, uint8_t power, + uint8_t accuracy, uint8_t baseUsage, AttackTarget target, int8_t priority, + const SecondaryEffect* effect, std::unordered_set flags); virtual ~AttackData() = default; - inline const ConstString& GetName() const noexcept { return _name; } + inline const ArbUt::CaseInsensitiveConstString& 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; } @@ -44,7 +42,7 @@ namespace CreatureLib::Library { } inline const std::unique_ptr& GetSecondaryEffect() const noexcept { return _effect; } - bool HasFlag(const ConstString& key) const noexcept; + bool HasFlag(const ArbUt::CaseInsensitiveConstString& key) const noexcept; bool HasFlag(uint32_t keyHash) const noexcept; }; } diff --git a/src/Library/Attacks/SecondaryEffect.hpp b/src/Library/Attacks/SecondaryEffect.hpp index 9015dfa..109b2d0 100644 --- a/src/Library/Attacks/SecondaryEffect.hpp +++ b/src/Library/Attacks/SecondaryEffect.hpp @@ -6,18 +6,17 @@ #include #include "../EffectParameter.hpp" -using namespace Arbutils::Collections; namespace CreatureLib::Library { class SecondaryEffect { private: float _chance; - Arbutils::CaseInsensitiveConstString _effectName; - List _parameters; + ArbUt::CaseInsensitiveConstString _effectName; + ArbUt::List _parameters; public: SecondaryEffect() noexcept : _chance(0), _effectName() {} - SecondaryEffect(float chance, const Arbutils::CaseInsensitiveConstString& effectName, - const List& parameters) noexcept + SecondaryEffect(float chance, const ArbUt::CaseInsensitiveConstString& effectName, + const ArbUt::List& parameters) noexcept : _chance(chance), _effectName(effectName), _parameters(parameters) {} ~SecondaryEffect() { @@ -27,10 +26,8 @@ namespace CreatureLib::Library { } constexpr inline float GetChance() const noexcept { return _chance; } - constexpr inline const Arbutils::CaseInsensitiveConstString& GetEffectName() const noexcept { - return _effectName; - } - const inline List& GetParameters() const noexcept { return _parameters; } + constexpr inline const ArbUt::CaseInsensitiveConstString& GetEffectName() const noexcept { return _effectName; } + const inline ArbUt::List& GetParameters() const noexcept { return _parameters; } }; } diff --git a/src/Library/BaseLibrary.hpp b/src/Library/BaseLibrary.hpp index 29be9c4..19591d3 100644 --- a/src/Library/BaseLibrary.hpp +++ b/src/Library/BaseLibrary.hpp @@ -5,7 +5,7 @@ #include #include #include -#include +#include #include #include #include @@ -13,8 +13,8 @@ namespace CreatureLib::Library { template class BaseLibrary { - Arbutils::Collections::Dictionary> _values; - Arbutils::Collections::List _listValues; + ArbUt::Dictionary> _values; + ArbUt::List _listValues; size_t _index; public: @@ -22,7 +22,7 @@ namespace CreatureLib::Library { virtual ~BaseLibrary() { _values.Clear(); } - inline void Insert(const Arbutils::CaseInsensitiveConstString& key, const T* value) { + inline void Insert(const ArbUt::CaseInsensitiveConstString& key, const T* value) { AssertNotNull(value) _values.GetStdMap().insert({key.GetHash(), std::unique_ptr(value)}); _listValues.Append(key); @@ -33,7 +33,7 @@ namespace CreatureLib::Library { _listValues.Append(hashedKey); } - inline void Delete(const Arbutils::CaseInsensitiveConstString& key) { + inline void Delete(const ArbUt::CaseInsensitiveConstString& key) { _values.erase(key.GetHash()); auto k = _listValues.IndexOf(key); _listValues.Remove(k); @@ -44,10 +44,10 @@ namespace CreatureLib::Library { _listValues.Remove(k); } - bool TryGet(const Arbutils::CaseInsensitiveConstString& name, borrowed_ptr& out) const { + bool TryGet(const ArbUt::CaseInsensitiveConstString& name, ArbUt::BorrowedPtr& out) const { return TryGet(name.GetHash(), out); } - bool TryGet(uint32_t hashedKey, borrowed_ptr& out) const { + bool TryGet(uint32_t hashedKey, ArbUt::BorrowedPtr& out) const { auto find = _values.GetStdMap().find(hashedKey); if (find == _values.GetStdMap().end()) return false; @@ -55,27 +55,29 @@ namespace CreatureLib::Library { return true; } - [[nodiscard]] inline borrowed_ptr Get(const Arbutils::CaseInsensitiveConstString& name) const { + [[nodiscard]] inline ArbUt::BorrowedPtr Get(const ArbUt::CaseInsensitiveConstString& name) const { return _values.Get(name.GetHash()); } - [[nodiscard]] inline borrowed_ptr Get(uint32_t hashedKey) const { return _values.Get(hashedKey); } + [[nodiscard]] inline ArbUt::BorrowedPtr Get(uint32_t hashedKey) const { + return _values.Get(hashedKey); + } - [[nodiscard]] inline borrowed_ptr operator[](const Arbutils::CaseInsensitiveConstString& name) const { + [[nodiscard]] inline ArbUt::BorrowedPtr + operator[](const ArbUt::CaseInsensitiveConstString& name) const { return Get(name); } - [[nodiscard]] inline borrowed_ptr operator[](uint32_t hashedKey) const { return Get(hashedKey); } - [[nodiscard]] inline const Arbutils::Collections::Dictionary>& - GetIterator() const { + [[nodiscard]] inline ArbUt::BorrowedPtr operator[](uint32_t hashedKey) const { return Get(hashedKey); } + [[nodiscard]] inline const ArbUt::Dictionary>& GetIterator() const { return _values; } [[nodiscard]] size_t GetCount() const { return _values.Count(); } - inline borrowed_ptr GetRandomValue(Arbutils::Random rand = Arbutils::Random()) const { + inline ArbUt::BorrowedPtr GetRandomValue(ArbUt::Random rand = ArbUt::Random()) const { auto i = rand.Get(_listValues.Count()); return _values[_listValues[i]]; } - inline borrowed_ptr GetRandomValue(Arbutils::Random* rand) const { + inline ArbUt::BorrowedPtr GetRandomValue(ArbUt::Random* rand) const { auto i = rand->Get(_listValues.Count()); return _values[_listValues[i]]; } diff --git a/src/Library/CreatureData/CreatureSpecies.cpp b/src/Library/CreatureData/CreatureSpecies.cpp index dcf7dab..f1b404f 100644 --- a/src/Library/CreatureData/CreatureSpecies.cpp +++ b/src/Library/CreatureData/CreatureSpecies.cpp @@ -3,19 +3,21 @@ using namespace CreatureLib::Library; -CreatureSpecies::CreatureSpecies(uint16_t id, const ConstString& name, const SpeciesVariant* defaultVariant, - float genderRatio, const ConstString& growthRate, uint8_t captureRate) +CreatureSpecies::CreatureSpecies(uint16_t id, const ArbUt::CaseInsensitiveConstString& name, + const SpeciesVariant* defaultVariant, float genderRatio, + const ArbUt::CaseInsensitiveConstString& growthRate, uint8_t captureRate) : _name(name), _id(id), _genderRate(genderRatio), _growthRate(growthRate), _captureRate(captureRate), _variants(1) { AssertNotNull(defaultVariant) SetVariant("default"_cnc, defaultVariant); } -bool CreatureSpecies::HasVariant(const ConstString& name) const { return _variants.Has(name); } +bool CreatureSpecies::HasVariant(const ArbUt::CaseInsensitiveConstString& name) const { return _variants.Has(name); } -bool CreatureSpecies::TryGetVariant(const ConstString& name, borrowed_ptr& out) const { +bool CreatureSpecies::TryGetVariant(const ArbUt::CaseInsensitiveConstString& name, + ArbUt::BorrowedPtr& out) const { return TryGetVariant(name.GetHash(), out); } -bool CreatureSpecies::TryGetVariant(uint32_t hash, borrowed_ptr& out) const { +bool CreatureSpecies::TryGetVariant(uint32_t hash, ArbUt::BorrowedPtr& out) const { auto find = _variants.GetStdMap().find(hash); if (find == _variants.end()) return false; @@ -23,17 +25,18 @@ bool CreatureSpecies::TryGetVariant(uint32_t hash, borrowed_ptr CreatureSpecies::GetVariant(const ConstString& name) const { +ArbUt::BorrowedPtr +CreatureSpecies::GetVariant(const ArbUt::CaseInsensitiveConstString& name) const { return _variants.Get(name); } -borrowed_ptr CreatureSpecies::GetVariant(uint32_t key) const { return _variants.Get(key); } +ArbUt::BorrowedPtr CreatureSpecies::GetVariant(uint32_t key) const { return _variants.Get(key); } bool CreatureSpecies::HasVariant(uint32_t hash) const { return _variants.Has(hash); } -void CreatureSpecies::SetVariant(const ConstString& name, const SpeciesVariant* variant) { +void CreatureSpecies::SetVariant(const ArbUt::CaseInsensitiveConstString& name, const SpeciesVariant* variant) { _variants.GetStdMap().insert({name, std::unique_ptr(variant)}); } -Gender CreatureSpecies::GetRandomGender(Arbutils::Random& rand) const { +Gender CreatureSpecies::GetRandomGender(ArbUt::Random& rand) const { // TODO: Genderless creatures auto val = rand.GetDouble(); if (val >= this->_genderRate) diff --git a/src/Library/CreatureData/CreatureSpecies.hpp b/src/Library/CreatureData/CreatureSpecies.hpp index 244efda..f7efbec 100644 --- a/src/Library/CreatureData/CreatureSpecies.hpp +++ b/src/Library/CreatureData/CreatureSpecies.hpp @@ -3,52 +3,52 @@ #include #include -#include +#include #include #include #include #include "../Gender.hpp" #include "SpeciesVariant.hpp" -using ConstString = Arbutils::CaseInsensitiveConstString; - namespace CreatureLib::Library { /*! \brief This holds the data required for a species of a creature, so the general data we can describe different creatures with. */ class CreatureSpecies { - const ConstString _name; + const ArbUt::CaseInsensitiveConstString _name; uint16_t _id; float _genderRate; - const ConstString _growthRate; + const ArbUt::CaseInsensitiveConstString _growthRate; uint8_t _captureRate; - Arbutils::Collections::Dictionary> _variants; + ArbUt::Dictionary> _variants; public: - CreatureSpecies(uint16_t id, const ConstString& name, const SpeciesVariant* defaultVariant, float genderRatio, - const ConstString& growthRate, uint8_t captureRate); + CreatureSpecies(uint16_t id, const ArbUt::CaseInsensitiveConstString& name, + const SpeciesVariant* defaultVariant, float genderRatio, + const ArbUt::CaseInsensitiveConstString& growthRate, uint8_t captureRate); virtual ~CreatureSpecies() { _variants.Clear(); } inline uint16_t GetId() const { return _id; } inline float GetGenderRate() const { return _genderRate; } - inline const ConstString& GetGrowthRate() const { return _growthRate; } + inline const ArbUt::CaseInsensitiveConstString& GetGrowthRate() const { return _growthRate; } inline uint8_t GetCaptureRate() const { return _captureRate; } - [[nodiscard]] bool HasVariant(const ConstString& key) const; + [[nodiscard]] bool HasVariant(const ArbUt::CaseInsensitiveConstString& key) const; [[nodiscard]] bool HasVariant(uint32_t hash) const; - [[nodiscard]] bool TryGetVariant(const ConstString& name, borrowed_ptr& out) const; - [[nodiscard]] bool TryGetVariant(uint32_t hash, borrowed_ptr& out) const; - [[nodiscard]] borrowed_ptr GetVariant(const ConstString& key) const; - [[nodiscard]] borrowed_ptr GetVariant(uint32_t key) const; - [[nodiscard]] Gender GetRandomGender(Arbutils::Random& rand) const; - [[nodiscard]] const ConstString& GetName() const { return _name; } + [[nodiscard]] bool TryGetVariant(const ArbUt::CaseInsensitiveConstString& name, + ArbUt::BorrowedPtr& out) const; + [[nodiscard]] bool TryGetVariant(uint32_t hash, ArbUt::BorrowedPtr& out) const; + [[nodiscard]] ArbUt::BorrowedPtr + GetVariant(const ArbUt::CaseInsensitiveConstString& key) const; + [[nodiscard]] ArbUt::BorrowedPtr GetVariant(uint32_t key) const; + [[nodiscard]] Gender GetRandomGender(ArbUt::Random& rand) const; + [[nodiscard]] const ArbUt::CaseInsensitiveConstString& GetName() const { return _name; } - void SetVariant(const ConstString& name, const SpeciesVariant* variant); + void SetVariant(const ArbUt::CaseInsensitiveConstString& name, const SpeciesVariant* variant); - const Arbutils::Collections::Dictionary>& - GetVariantsIterator() const { + const ArbUt::Dictionary>& GetVariantsIterator() const { return _variants; } }; diff --git a/src/Library/CreatureData/LearnableAttacks.cpp b/src/Library/CreatureData/LearnableAttacks.cpp index 7234941..4f2d2ec 100644 --- a/src/Library/CreatureData/LearnableAttacks.cpp +++ b/src/Library/CreatureData/LearnableAttacks.cpp @@ -3,8 +3,7 @@ using namespace CreatureLib::Library; void LearnableAttacks::AddLevelAttack(uint8_t level, const AttackData* attack) { - - List levelData; + ArbUt::List levelData; if (_learnedByLevel.TryGet(level, levelData)) { levelData.Append(attack); } else { @@ -14,6 +13,6 @@ void LearnableAttacks::AddLevelAttack(uint8_t level, const AttackData* attack) { _distinctAttacks.insert(attack); } -const List& LearnableAttacks::GetAttacksForLevel(uint8_t level) const { +const ArbUt::List& LearnableAttacks::GetAttacksForLevel(uint8_t level) const { return _learnedByLevel.Get(level); } diff --git a/src/Library/CreatureData/LearnableAttacks.hpp b/src/Library/CreatureData/LearnableAttacks.hpp index fb85add..128e3e0 100644 --- a/src/Library/CreatureData/LearnableAttacks.hpp +++ b/src/Library/CreatureData/LearnableAttacks.hpp @@ -8,17 +8,15 @@ #include #include "../Attacks/AttackData.hpp" -using namespace Arbutils::Collections; - namespace CreatureLib::Library { class LearnableAttacks { protected: - Dictionary> _learnedByLevel; + ArbUt::Dictionary> _learnedByLevel; std::unordered_set _distinctAttacks; public: explicit LearnableAttacks(size_t levelAttackCapacity) - : _learnedByLevel(Dictionary>(levelAttackCapacity)) { + : _learnedByLevel(ArbUt::Dictionary>(levelAttackCapacity)) { for (auto kv : _learnedByLevel) { for (auto attack : kv.second) { AssertNotNull(attack) @@ -31,9 +29,9 @@ namespace CreatureLib::Library { void AddLevelAttack(uint8_t level, const AttackData* attack); - const List& GetAttacksForLevel(uint8_t level) const; + const ArbUt::List& GetAttacksForLevel(uint8_t level) const; - virtual const AttackData* GetRandomAttack(Arbutils::Random& rand) const { + virtual const AttackData* GetRandomAttack(ArbUt::Random& rand) const { if (_distinctAttacks.empty()) { return nullptr; } diff --git a/src/Library/CreatureData/SpeciesVariant.cpp b/src/Library/CreatureData/SpeciesVariant.cpp index 34c06a9..fa46866 100644 --- a/src/Library/CreatureData/SpeciesVariant.cpp +++ b/src/Library/CreatureData/SpeciesVariant.cpp @@ -2,7 +2,7 @@ #include #include -const List& CreatureLib::Library::SpeciesVariant::GetTypes() const { return _types; } +const ArbUt::List& CreatureLib::Library::SpeciesVariant::GetTypes() const { return _types; } size_t CreatureLib::Library::SpeciesVariant::GetTypeCount() const { return _types.Count(); } @@ -13,7 +13,7 @@ uint16_t CreatureLib::Library::SpeciesVariant::GetStatistic(CreatureLib::Library } const CreatureLib::Library::TalentIndex -CreatureLib::Library::SpeciesVariant::GetTalentIndex(const ConstString& talent) const { +CreatureLib::Library::SpeciesVariant::GetTalentIndex(const ArbUt::CaseInsensitiveConstString& talent) const { for (size_t i = 0; i < _talents.Count(); i++) { if (_talents.At(i) == talent) { return TalentIndex(false, i); @@ -27,7 +27,7 @@ CreatureLib::Library::SpeciesVariant::GetTalentIndex(const ConstString& talent) throw CreatureException("The given talent is not a valid talent for this creature."); } -CreatureLib::Library::TalentIndex CreatureLib::Library::SpeciesVariant::GetRandomTalent(Arbutils::Random* rand) const { +CreatureLib::Library::TalentIndex CreatureLib::Library::SpeciesVariant::GetRandomTalent(ArbUt::Random* rand) const { return TalentIndex(false, rand->Get(_talents.Count())); } @@ -36,10 +36,11 @@ CreatureLib::Library::SpeciesVariant::GetLearnableAttacks() const { return _attacks; } -CreatureLib::Library::SpeciesVariant::SpeciesVariant(ConstString name, float height, float weight, - uint32_t baseExperience, List types, +CreatureLib::Library::SpeciesVariant::SpeciesVariant(ArbUt::CaseInsensitiveConstString name, float height, float weight, + uint32_t baseExperience, ArbUt::List types, CreatureLib::Library::StatisticSet baseStats, - List talents, List secretTalents, + ArbUt::List talents, + ArbUt::List secretTalents, const LearnableAttacks* attacks) : _name(std::move(name)), _height(height), _weight(weight), _baseExperience(baseExperience), _types(std::move(types)), _baseStatistics(baseStats), _talents(std::move(talents)), diff --git a/src/Library/CreatureData/SpeciesVariant.hpp b/src/Library/CreatureData/SpeciesVariant.hpp index 5e847b1..6fbd12b 100644 --- a/src/Library/CreatureData/SpeciesVariant.hpp +++ b/src/Library/CreatureData/SpeciesVariant.hpp @@ -8,8 +8,6 @@ #include "../StatisticSet.hpp" #include "LearnableAttacks.hpp" #include "TalentIndex.hpp" -using ConstString = Arbutils::CaseInsensitiveConstString; -using namespace Arbutils::Collections; namespace CreatureLib::Library { /*! @@ -17,47 +15,52 @@ namespace CreatureLib::Library { */ class SpeciesVariant { protected: - ConstString _name; + ArbUt::CaseInsensitiveConstString _name; float _height; float _weight; uint32_t _baseExperience; private: - List _types; + ArbUt::List _types; Library::StatisticSet _baseStatistics; - List _talents; - List _secretTalents; + ArbUt::List _talents; + ArbUt::List _secretTalents; std::unique_ptr _attacks; public: - SpeciesVariant(ConstString name, float height, float weight, uint32_t baseExperience, List types, - Library::StatisticSet baseStats, List talents, - List secretTalents, const LearnableAttacks* attacks); + SpeciesVariant(ArbUt::CaseInsensitiveConstString name, float height, float weight, uint32_t baseExperience, + ArbUt::List types, Library::StatisticSet baseStats, + ArbUt::List talents, + ArbUt::List secretTalents, const LearnableAttacks* attacks); virtual ~SpeciesVariant() = default; - inline const ConstString& GetName() const { return _name; } + inline const ArbUt::CaseInsensitiveConstString& GetName() const { return _name; } inline float GetHeight() const { return _height; } inline float GetWeight() const { return _weight; } inline uint32_t GetBaseExperience() const { return _baseExperience; } [[nodiscard]] size_t GetTypeCount() const; [[nodiscard]] uint8_t GetType(size_t index) const; - [[nodiscard]] const List& GetTypes() const; + [[nodiscard]] const ArbUt::List& GetTypes() const; [[nodiscard]] uint16_t GetStatistic(Library::Statistic stat) const; [[nodiscard]] const size_t GetTalentCount() const { return _talents.Count(); } [[nodiscard]] const size_t GetSecretTalentCount() const { return _secretTalents.Count(); } - [[nodiscard]] const ConstString& GetTalent(const TalentIndex& index) const { + [[nodiscard]] const ArbUt::CaseInsensitiveConstString& GetTalent(const TalentIndex& index) const { if (index.IsSecret()) return _secretTalents.At(index.GetIndex()); return _talents.At(index.GetIndex()); } - [[nodiscard]] const TalentIndex GetTalentIndex(const ConstString& talent) const; + [[nodiscard]] const TalentIndex GetTalentIndex(const ArbUt::CaseInsensitiveConstString& talent) const; [[nodiscard]] const std::unique_ptr& GetLearnableAttacks() const; - [[nodiscard]] TalentIndex GetRandomTalent(Arbutils::Random* rand) const; - [[nodiscard]] inline const List& GetTalents() const { return _talents; } - [[nodiscard]] inline const List& GetSecretTalents() const { return _secretTalents; } + [[nodiscard]] TalentIndex GetRandomTalent(ArbUt::Random* rand) const; + [[nodiscard]] inline const ArbUt::List& GetTalents() const { + return _talents; + } + [[nodiscard]] inline const ArbUt::List& GetSecretTalents() const { + return _secretTalents; + } }; } diff --git a/src/Library/EffectParameter.hpp b/src/Library/EffectParameter.hpp index 61736bd..7cc52ca 100644 --- a/src/Library/EffectParameter.hpp +++ b/src/Library/EffectParameter.hpp @@ -11,14 +11,14 @@ namespace CreatureLib::Library { class EffectParameter { private: EffectParameterType _type = EffectParameterType::None; - std::variant _value; + std::variant _value; public: EffectParameter() : _type(EffectParameterType::None){}; explicit EffectParameter(bool b) : _type(EffectParameterType::Bool), _value(b){}; explicit EffectParameter(int64_t i) : _type(EffectParameterType::Int), _value(i){}; explicit EffectParameter(float f) : _type(EffectParameterType::Float), _value(f){}; - explicit EffectParameter(const Arbutils::CaseInsensitiveConstString& s) + explicit EffectParameter(const ArbUt::CaseInsensitiveConstString& s) : _type(EffectParameterType::String), _value(s){}; EffectParameter(const EffectParameter& other) = delete; EffectParameter& operator=(const EffectParameter& other) = delete; @@ -54,13 +54,13 @@ namespace CreatureLib::Library { } return std::get(_value); } - const Arbutils::CaseInsensitiveConstString& AsString() const { + const ArbUt::CaseInsensitiveConstString& AsString() const { if (_type != EffectParameterType::String) { std::stringstream ss; ss << "Cast effect parameter to string, but was " << EffectParameterTypeHelper::ToString(_type); throw CreatureException(ss.str()); } - return std::get(_value); + return std::get(_value); } }; } diff --git a/src/Library/GrowthRates/GrowthRateLibrary.hpp b/src/Library/GrowthRates/GrowthRateLibrary.hpp index 27f3e9d..d6dcce6 100644 --- a/src/Library/GrowthRates/GrowthRateLibrary.hpp +++ b/src/Library/GrowthRates/GrowthRateLibrary.hpp @@ -8,7 +8,7 @@ #include #include "GrowthRate.hpp" -using ConstString = Arbutils::CaseInsensitiveConstString; +using ConstString = ArbUt::CaseInsensitiveConstString; namespace CreatureLib::Library { class GrowthRateLibrary { diff --git a/src/Library/GrowthRates/LookupGrowthRate.hpp b/src/Library/GrowthRates/LookupGrowthRate.hpp index 732993b..d7e43f8 100644 --- a/src/Library/GrowthRates/LookupGrowthRate.hpp +++ b/src/Library/GrowthRates/LookupGrowthRate.hpp @@ -7,10 +7,10 @@ namespace CreatureLib::Library { class LookupGrowthRate : public GrowthRate { protected: - Arbutils::Collections::List _experience; + ArbUt::List _experience; public: - LookupGrowthRate(const Arbutils::Collections::List& experience) : _experience(experience) {} + LookupGrowthRate(const ArbUt::List& experience) : _experience(experience) {} uint8_t CalculateLevel(uint32_t experience) const override { for (uint8_t i = 0; i < _experience.Count(); i++) { diff --git a/src/Library/Items/Item.cpp b/src/Library/Items/Item.cpp index 55764cf..b81d9c7 100644 --- a/src/Library/Items/Item.cpp +++ b/src/Library/Items/Item.cpp @@ -1,13 +1,13 @@ #include "Item.hpp" -bool CreatureLib::Library::Item::HasFlag(const Arbutils::CaseInsensitiveConstString& flag) const noexcept { +bool CreatureLib::Library::Item::HasFlag(const ArbUt::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(); } -CreatureLib::Library::Item::Item(const Arbutils::CaseInsensitiveConstString& name, +CreatureLib::Library::Item::Item(const ArbUt::CaseInsensitiveConstString& name, CreatureLib::Library::ItemCategory category, CreatureLib::Library::BattleItemCategory battleCategory, int32_t price, const std::unordered_set& flags) diff --git a/src/Library/Items/Item.hpp b/src/Library/Items/Item.hpp index 42ae54a..149cb29 100644 --- a/src/Library/Items/Item.hpp +++ b/src/Library/Items/Item.hpp @@ -10,22 +10,22 @@ namespace CreatureLib::Library { class Item { protected: - Arbutils::CaseInsensitiveConstString _name; + ArbUt::CaseInsensitiveConstString _name; ItemCategory _category; BattleItemCategory _battleCategory; int32_t _price; std::unordered_set _flags; public: - Item(const Arbutils::CaseInsensitiveConstString& name, ItemCategory category, BattleItemCategory battleCategory, + Item(const ArbUt::CaseInsensitiveConstString& name, ItemCategory category, BattleItemCategory battleCategory, int32_t price, const std::unordered_set& flags); - inline const Arbutils::CaseInsensitiveConstString& GetName() const noexcept { return _name; } + inline const ArbUt::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 noexcept; + bool HasFlag(const ArbUt::CaseInsensitiveConstString& flag) const noexcept; bool HasFlag(uint32_t flag) const noexcept; }; } diff --git a/src/Library/TypeLibrary.cpp b/src/Library/TypeLibrary.cpp index 75250fa..215ac0f 100644 --- a/src/Library/TypeLibrary.cpp +++ b/src/Library/TypeLibrary.cpp @@ -4,7 +4,7 @@ using namespace CreatureLib::Library; -float TypeLibrary::GetEffectiveness(uint8_t attacking, const List& defensive) const { +float TypeLibrary::GetEffectiveness(uint8_t attacking, const ArbUt::List& defensive) const { return std::accumulate( defensive.begin(), defensive.end(), (float)1, [this, attacking](float init, uint8_t defense) { return init * GetSingleEffectiveness(attacking, defense); }); @@ -14,10 +14,10 @@ float TypeLibrary::GetSingleEffectiveness(uint8_t attacking, uint8_t defensive) return _effectiveness[attacking][defensive]; } -uint8_t TypeLibrary::GetTypeId(const ConstString& key) const { return _types.Get(key); } +uint8_t TypeLibrary::GetTypeId(const ArbUt::CaseInsensitiveConstString& key) const { return _types.Get(key); } uint8_t TypeLibrary::GetTypeId(uint32_t s) const { return _types.Get(s); } -uint8_t TypeLibrary::RegisterType(const ConstString& key) { +uint8_t TypeLibrary::RegisterType(const ArbUt::CaseInsensitiveConstString& key) { _types.Insert(key, _types.Count()); _effectiveness.Resize(_types.Count()); for (auto& eff : _effectiveness) { diff --git a/src/Library/TypeLibrary.hpp b/src/Library/TypeLibrary.hpp index 0c81f1f..c3eade0 100644 --- a/src/Library/TypeLibrary.hpp +++ b/src/Library/TypeLibrary.hpp @@ -6,23 +6,21 @@ #include #include #include -using ConstString = Arbutils::CaseInsensitiveConstString; -using namespace Arbutils::Collections; namespace CreatureLib::Library { class TypeLibrary { - Dictionary _types; - List> _effectiveness; + ArbUt::Dictionary _types; + ArbUt::List> _effectiveness; public: - TypeLibrary(size_t initialCapacity = 20) : _types(Dictionary(initialCapacity)) {} + TypeLibrary(size_t initialCapacity = 20) : _types(ArbUt::Dictionary(initialCapacity)) {} - uint8_t GetTypeId(const ConstString& s) const; + uint8_t GetTypeId(const ArbUt::CaseInsensitiveConstString& s) const; uint8_t GetTypeId(uint32_t s) const; [[nodiscard]] float GetSingleEffectiveness(uint8_t attacking, uint8_t defensive) const; - [[nodiscard]] float GetEffectiveness(uint8_t attacking, const List& defensive) const; + [[nodiscard]] float GetEffectiveness(uint8_t attacking, const ArbUt::List& defensive) const; - uint8_t RegisterType(const ConstString& typeName); + uint8_t RegisterType(const ArbUt::CaseInsensitiveConstString& typeName); uint8_t RegisterType(uint32_t typeHash); void SetEffectiveness(uint8_t attacking, uint8_t defensive, float effectiveness); }; diff --git a/tests/BattleTests/ScriptTests/ScriptAggregatorTests.cpp b/tests/BattleTests/ScriptTests/ScriptAggregatorTests.cpp index 73dac75..74ca08f 100644 --- a/tests/BattleTests/ScriptTests/ScriptAggregatorTests.cpp +++ b/tests/BattleTests/ScriptTests/ScriptAggregatorTests.cpp @@ -9,11 +9,11 @@ using namespace CreatureLib::Battling; class TestScript : public Script { private: - ConstString _name; + ArbUt::CaseInsensitiveConstString _name; public: explicit TestScript(std::string name) : _name(std::move(name)){}; - const ConstString& GetName() const noexcept override { return _name; } + const ArbUt::CaseInsensitiveConstString& GetName() const noexcept override { return _name; } void TestMethod(int& runCount) { runCount++; } }; @@ -21,7 +21,7 @@ public: TEST_CASE("Script Aggregator properly iterates containing script.", "[Battling, Scripting]") { Script* script = new TestScript("test"); auto ran = 0; - auto vec = Arbutils::Collections::List{ScriptWrapper::FromScript(&script)}; + auto vec = ArbUt::List{ScriptWrapper::FromScript(&script)}; auto aggr = ScriptAggregator(vec); while (aggr.HasNext()) { auto next = aggr.GetNext(); @@ -37,8 +37,8 @@ TEST_CASE("Script Aggregator properly iterates multiple scripts.", "[Battling, S Script* script2 = new TestScript("test2"); Script* script3 = new TestScript("test3"); auto ran = 0; - auto vec = Arbutils::Collections::List{ - ScriptWrapper::FromScript(&script), ScriptWrapper::FromScript(&script2), ScriptWrapper::FromScript(&script3)}; + auto vec = ArbUt::List{ScriptWrapper::FromScript(&script), ScriptWrapper::FromScript(&script2), + ScriptWrapper::FromScript(&script3)}; auto aggr = ScriptAggregator(vec); while (aggr.HasNext()) { auto next = aggr.GetNext(); @@ -60,7 +60,7 @@ TEST_CASE("Script Aggregator properly iterates Script Set.", "[Battling, Scripti set.Add(script); set.Add(script2); set.Add(script3); - auto vec = Arbutils::Collections::List{ScriptWrapper::FromSet(&set)}; + auto vec = ArbUt::List{ScriptWrapper::FromSet(&set)}; auto aggr = ScriptAggregator(vec); while (aggr.HasNext()) { auto next = aggr.GetNextNotNull(); @@ -78,8 +78,7 @@ TEST_CASE("Script Aggregator properly iterates data of Script Set and Script.", auto set = ScriptSet(); set.Add(script2); set.Add(script3); - auto vec = - Arbutils::Collections::List{ScriptWrapper::FromSet(&set), ScriptWrapper::FromScript(&script)}; + auto vec = ArbUt::List{ScriptWrapper::FromSet(&set), ScriptWrapper::FromScript(&script)}; auto aggr = ScriptAggregator(vec); while (aggr.HasNext()) { auto next = aggr.GetNextNotNull(); @@ -98,8 +97,7 @@ TEST_CASE("Script Aggregator properly iterates data of Script and Script Set.", auto set = ScriptSet(); set.Add(script2); set.Add(script3); - auto vec = - Arbutils::Collections::List{ScriptWrapper::FromScript(&script), ScriptWrapper::FromSet(&set)}; + auto vec = ArbUt::List{ScriptWrapper::FromScript(&script), ScriptWrapper::FromSet(&set)}; auto aggr = ScriptAggregator(vec); while (aggr.HasNext()) { auto next = aggr.GetNextNotNull(); @@ -119,8 +117,8 @@ TEST_CASE("Script Aggregator properly iterates data of Script, Script Set and Sc auto set = ScriptSet(); set.Add(script2); set.Add(script3); - auto vec = Arbutils::Collections::List{ - ScriptWrapper::FromScript(&script), ScriptWrapper::FromSet(&set), ScriptWrapper::FromScript(&script4)}; + auto vec = ArbUt::List{ScriptWrapper::FromScript(&script), ScriptWrapper::FromSet(&set), + ScriptWrapper::FromScript(&script4)}; auto aggr = ScriptAggregator(vec); while (aggr.HasNext()) { auto next = aggr.GetNextNotNull(); @@ -134,7 +132,7 @@ TEST_CASE("Script Aggregator properly iterates data of Script, Script Set and Sc TEST_CASE("Script Aggregator properly iterates when empty.", "[Battling, Scripting]") { auto ran = 0; - auto vec = Arbutils::Collections::List{}; + auto vec = ArbUt::List{}; auto aggr = ScriptAggregator(vec); while (aggr.HasNext()) { throw CreatureException("Aggregator returned a script, but should have been empty."); @@ -145,7 +143,7 @@ TEST_CASE("Script Aggregator properly iterates when empty.", "[Battling, Scripti TEST_CASE("Script Aggregator properly iterates empty Script Set.", "[Battling, Scripting]") { auto ran = 0; auto set = ScriptSet(); - auto vec = Arbutils::Collections::List{ScriptWrapper::FromSet(&set)}; + auto vec = ArbUt::List{ScriptWrapper::FromSet(&set)}; auto aggr = ScriptAggregator(vec); while (aggr.HasNext()) { auto next = aggr.GetNext(); diff --git a/tests/BattleTests/ScriptTests/ScriptSetTests.cpp b/tests/BattleTests/ScriptTests/ScriptSetTests.cpp index b15efe5..6d66c24 100644 --- a/tests/BattleTests/ScriptTests/ScriptSetTests.cpp +++ b/tests/BattleTests/ScriptTests/ScriptSetTests.cpp @@ -9,11 +9,11 @@ using namespace CreatureLib::Battling; class TestScript : public Script { private: - ConstString _name; + ArbUt::CaseInsensitiveConstString _name; public: explicit TestScript(std::string name) : _name(std::move(name)){}; - const ConstString& GetName() const noexcept override { return _name; } + const ArbUt::CaseInsensitiveConstString& GetName() const noexcept override { return _name; } }; TEST_CASE("Empty script set count == 0", "[Battling, Scripting]") { diff --git a/tests/BattleTests/ScriptTests/ScriptSourceTest.cpp b/tests/BattleTests/ScriptTests/ScriptSourceTest.cpp index e877f2b..4ee6d29 100644 --- a/tests/BattleTests/ScriptTests/ScriptSourceTest.cpp +++ b/tests/BattleTests/ScriptTests/ScriptSourceTest.cpp @@ -10,11 +10,11 @@ using namespace CreatureLib::Battling; class TestScript : public Script { private: - ConstString _name; + ArbUt::CaseInsensitiveConstString _name; public: explicit TestScript(std::string name) : _name(std::move(name)){}; - const ConstString& GetName() const noexcept override { return _name; } + const ArbUt::CaseInsensitiveConstString& GetName() const noexcept override { return _name; } void TestMethod(int& runCount) { runCount++; } }; @@ -25,7 +25,7 @@ public: protected: size_t ScriptCount() const override { return 1; } - void GetActiveScripts(Arbutils::Collections::List& scripts) override { + void GetActiveScripts(ArbUt::List& scripts) override { scripts.Append(ScriptWrapper::FromScript(&ScriptPtr)); } }; @@ -36,7 +36,7 @@ public: protected: size_t ScriptCount() const override { return 1; } - void GetActiveScripts(Arbutils::Collections::List& scripts) override { + void GetActiveScripts(ArbUt::List& scripts) override { scripts.Append(ScriptWrapper::FromSet(&Set)); } }; diff --git a/tests/BattleTests/TurnOrderTests.cpp b/tests/BattleTests/TurnOrderTests.cpp index 975319c..d3d765f 100644 --- a/tests/BattleTests/TurnOrderTests.cpp +++ b/tests/BattleTests/TurnOrderTests.cpp @@ -16,7 +16,7 @@ TEST_CASE("Turn ordering: Attack before pass", "[Battling]") { auto choice1 = new PassTurnChoice(nullptr); auto choice2 = new AttackTurnChoice(nullptr, &learnedAttack, CreatureIndex(0, 0)); auto vec = std::vector{choice1, choice2}; - auto rand = Arbutils::Random(); + auto rand = ArbUt::Random(); TurnOrdering::OrderChoices(vec, rand); CHECK(vec[0] == choice2); CHECK(vec[1] == choice1); @@ -36,7 +36,7 @@ TEST_CASE("Turn ordering: High priority goes before no priority", "[Battling]") auto choice1 = new AttackTurnChoice(nullptr, a1, CreatureIndex(0, 0)); auto choice2 = new AttackTurnChoice(nullptr, a2, CreatureIndex(0, 0)); auto vec = std::vector{choice1, choice2}; - auto rand = Arbutils::Random(); + auto rand = ArbUt::Random(); TurnOrdering::OrderChoices(vec, rand); CHECK(vec[0] == choice2); CHECK(vec[1] == choice1); @@ -58,7 +58,7 @@ TEST_CASE("Turn ordering: Higher priority goes before high priority", "[Battling auto choice1 = new AttackTurnChoice(nullptr, a1, CreatureIndex(0, 0)); auto choice2 = new AttackTurnChoice(nullptr, a2, CreatureIndex(0, 0)); auto vec = std::vector{choice1, choice2}; - auto rand = Arbutils::Random(); + auto rand = ArbUt::Random(); TurnOrdering::OrderChoices(vec, rand); CHECK(vec[0] == choice2); CHECK(vec[1] == choice1); @@ -80,7 +80,7 @@ TEST_CASE("Turn ordering: High priority goes before low priority", "[Battling]") auto choice1 = new AttackTurnChoice(nullptr, a1, CreatureIndex(0, 0)); auto choice2 = new AttackTurnChoice(nullptr, a2, CreatureIndex(0, 0)); auto vec = std::vector{choice1, choice2}; - auto rand = Arbutils::Random(); + auto rand = ArbUt::Random(); TurnOrdering::OrderChoices(vec, rand); CHECK(vec[0] == choice2); CHECK(vec[1] == choice1); @@ -102,7 +102,7 @@ TEST_CASE("Turn ordering: No priority goes before low priority", "[Battling]") { auto choice1 = new AttackTurnChoice(nullptr, a1, CreatureIndex(0, 0)); auto choice2 = new AttackTurnChoice(nullptr, a2, CreatureIndex(0, 0)); auto vec = std::vector{choice1, choice2}; - auto rand = Arbutils::Random(); + auto rand = ArbUt::Random(); TurnOrdering::OrderChoices(vec, rand); CHECK(vec[0] == choice2); CHECK(vec[1] == choice1); diff --git a/tests/LibraryTests/EffectParameterTests.cpp b/tests/LibraryTests/EffectParameterTests.cpp index a841e73..8e1ef0a 100644 --- a/tests/LibraryTests/EffectParameterTests.cpp +++ b/tests/LibraryTests/EffectParameterTests.cpp @@ -17,7 +17,7 @@ TEST_CASE("Int EffectParameter", "[Library]") { } TEST_CASE("String EffectParameter", "[Library]") { - auto p = EffectParameter((Arbutils::CaseInsensitiveConstString) "foobar"_cnc); + auto p = EffectParameter((ArbUt::CaseInsensitiveConstString) "foobar"_cnc); REQUIRE(p.AsString() == "foobar"); }