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

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

Browse Source
This commit is contained in:
Deukhoofd
2020-03-25 19:07:36 +01:00
parent 27288563cd
commit 7ce3e6940d
53 changed files with 7526 additions and 8340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
CInterface/Battling/Battle.cpp
View File

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

2
CInterface/Battling/BattleLibrary.cpp
View File

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

20
CInterface/Battling/BattleParty.cpp
View File

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

16
CInterface/Battling/BattleStatCalculator.cpp
View File

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

65
CInterface/Battling/Creature.cpp
View File

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

8
CInterface/Battling/CreatureParty.cpp
View File

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

22
CInterface/Battling/DamageLibrary.cpp
View File

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

2
CInterface/Battling/EventData.cpp
View File

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

10
CInterface/Battling/ExperienceLibrary.cpp
View File

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

17
CInterface/Battling/MiscLibrary.cpp
View File

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

10
CInterface/Battling/ScriptResolver.cpp
View File

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

6
CInterface/Battling/TurnChoices.cpp
View File

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

4
CInterface/Core.cpp Normal file
View File

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

26
CInterface/Core.hpp Normal file
View File

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

20
CInterface/Library/AttackData.cpp
View File

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

5
CInterface/Library/AttackLibrary.cpp
View File

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

28
CInterface/Library/BaseLibrary.cpp
View File

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

25
CInterface/Library/CreatureSpecies.cpp
View File

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

10
CInterface/Library/DataLibrary.cpp
View File

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

16
CInterface/Library/GrowthRate.cpp
View File

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

38
CInterface/Library/GrowthRateLibrary.cpp
View File

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

2
CInterface/Library/Item.cpp
View File

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

2
CInterface/Library/ItemLibrary.cpp
View File

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

6
CInterface/Library/LearnableAttacks.cpp
View File

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

2
CInterface/Library/LibrarySettings.cpp
View File

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

2
CInterface/Library/SpeciesLibrary.cpp
View File

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

2
CInterface/Library/SpeciesVariant.cpp
View File

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

35
CInterface/Library/TypeLibrary.cpp
View File

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