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

Merge Core library into Library, as with its utility functionality merged into Arbutils, it's becoming less and less useful.
continuous-integration/drone/push Build is failing Details

This commit is contained in:
Deukhoofd 2020-03-22 10:11:53 +01:00
parent 5672f2d2a7
commit a7b87ab4f8
Signed by: Deukhoofd
GPG Key ID: ADF2E9256009EDCE
28 changed files with 162 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CInterface/Battling/BattleStatCalculator.cpp
View File

@ -7,10 +7,10 @@ export const BattleStatCalculator* CreatureLib_BattleStatCalculator_Construct()
export void CreatureLib_BattleStatCalculator_Destruct(const BattleStatCalculator* p) { delete p; }
export uint32_t CreatureLib_BattleStatCalculator_CalculateFlatStat(const BattleStatCalculator* p, Creature* creature,
CreatureLib::Core::Statistic stat) {
CreatureLib::Library::Statistic stat) {
return p->CalculateFlatStat(creature, stat);
}
export uint32_t CreatureLib_BattleStatCalculator_CalculateBoostedStat(const BattleStatCalculator* p, Creature* creature,
CreatureLib::Core::Statistic stat) {
CreatureLib::Library::Statistic stat) {
return p->CalculateBoostedStat(creature, stat);
}

11
CInterface/Battling/Creature.cpp
View File

@ -85,21 +85,20 @@ export void CreatureLib_Creature_SetDisplaySpecies(Creature* p, const CreatureLi
export void CreatureLib_Creature_SetDisplayVariant(Creature* p, const CreatureLib::Library::SpeciesVariant* variant) {
return p->SetDisplayVariant(variant);
}
export void CreatureLib_Creature_ChangeStatBoost(Creature* p, CreatureLib::Core::Statistic stat, int8_t diffAmount){
export void CreatureLib_Creature_ChangeStatBoost(Creature* p, CreatureLib::Library::Statistic stat, int8_t diffAmount) {
p->ChangeStatBoost(stat, diffAmount);
}
export uint32_t CreatureLib_Creature_GetFlatStat(Creature* p, CreatureLib::Core::Statistic stat){
export uint32_t CreatureLib_Creature_GetFlatStat(Creature* p, CreatureLib::Library::Statistic stat) {
return p->GetFlatStat(stat);
}
export uint32_t CreatureLib_Creature_GetBoostedStat(Creature* p, CreatureLib::Core::Statistic stat){
export uint32_t CreatureLib_Creature_GetBoostedStat(Creature* p, CreatureLib::Library::Statistic stat) {
return p->GetBoostedStat(stat);
}
export uint32_t CreatureLib_Creature_GetBaseStat(Creature* p, CreatureLib::Core::Statistic stat){
export uint32_t CreatureLib_Creature_GetBaseStat(Creature* p, CreatureLib::Library::Statistic stat) {
return p->GetBaseStat(stat);
}
export int8_t CreatureLib_Creature_GetStatBoost(Creature* p, CreatureLib::Core::Statistic stat){
export int8_t CreatureLib_Creature_GetStatBoost(Creature* p, CreatureLib::Library::Statistic stat) {
return p->GetStatBoost(stat);
}
#undef SIMPLE_GET_FUNC

8
CInterface/Library/SpeciesVariant.cpp
View File

@ -21,9 +21,9 @@ export SpeciesVariant* CreatureLib_SpeciesVariant_Construct(
return new SpeciesVariant(Arbutils::CaseInsensitiveConstString(name), height, weight, baseExperience,
std::vector<uint8_t>(types, types + typeLength),
CreatureLib::Core::StatisticSet<uint16_t>(baseHealth, baseAttack, baseDefense,
baseMagicalAttack, baseMagicalDefense,
baseSpeed),
CreatureLib::Library::StatisticSet<uint16_t>(baseHealth, baseAttack, baseDefense,
baseMagicalAttack, baseMagicalDefense,
baseSpeed),
talentsWrapped, secretTalentsWrapped, attacks);
}
@ -38,7 +38,7 @@ SIMPLE_GET_FUNC(SpeciesVariant, GetWeight, float);
SIMPLE_GET_FUNC(SpeciesVariant, GetBaseExperience, uint32_t);
SIMPLE_GET_FUNC(SpeciesVariant, GetTypeCount, size_t);
export uint8_t CreatureLib_SpeciesVariant_GetType(SpeciesVariant* p, size_t index) { return p->GetType(index); }
export uint32_t CreatureLib_SpeciesVariant_GetStatistic(SpeciesVariant* p, CreatureLib::Core::Statistic stat) {
export uint32_t CreatureLib_SpeciesVariant_GetStatistic(SpeciesVariant* p, CreatureLib::Library::Statistic stat) {
return p->GetStatistic(stat);
}
SIMPLE_GET_FUNC(SpeciesVariant, GetTalentCount, size_t);

11
CMakeLists.txt
View File

@ -31,11 +31,6 @@ if (WINDOWS)
ADD_DEFINITIONS(-D WINDOWS=1)
endif (WINDOWS)
# Create Core library with files in src/Core
file(GLOB_RECURSE CORE_SRC_FILES "src/Core/*.cpp" "src/Core/*.hpp" "CInterface/Core/*.cpp")
add_library(CreatureLibCore SHARED ${CORE_SRC_FILES})
set_target_properties(CreatureLibCore PROPERTIES LINKER_LANGUAGE CXX)
# Create main Library library with files in src/Library
file(GLOB_RECURSE LIBRARY_SRC_FILES "src/Library/*.cpp" "src/Library/*.hpp" "CInterface/Library/*.cpp")
add_library(CreatureLibLibrary SHARED ${LIBRARY_SRC_FILES})
@ -50,14 +45,9 @@ if (NOT DEFINED CONAN_EXPORTED)
add_executable(CreatureLibTests ${TEST_FILES} extern/catch.hpp)
endif ()
# Link the core library to the individual other libraries
target_link_libraries(CreatureLibLibrary CreatureLibCore)
target_link_libraries(CreatureLibBattling CreatureLibCore)
# Link the library data to the Battling library
target_link_libraries(CreatureLibBattling CreatureLibLibrary)
target_link_libraries(CreatureLibCore Arbutils)
target_link_libraries(CreatureLibLibrary Arbutils)
target_link_libraries(CreatureLibBattling Arbutils)
@ -71,7 +61,6 @@ if (WINDOWS)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -L ${CMAKE_BINARY_DIR}/bin")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m64 -Wa,-mbig-obj -Wl,-allow-multiple-definition")
# Statically link libraries we need in Windows.
target_link_libraries(CreatureLibCore -static-libgcc -static-libstdc++)
target_link_libraries(CreatureLibLibrary -static-libgcc -static-libstdc++)
target_link_libraries(CreatureLibBattling -static-libgcc -static-libstdc++)
if (NOT DEFINED CONAN_EXPORTED)

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

@ -1,5 +1,5 @@
#include "TurnHandler.hpp"
#include "../../Core/Exceptions/NotImplementedException.hpp"
#include "../../Library/Exceptions/NotImplementedException.hpp"
#include "../Models/Battle.hpp"
#include "../ScriptHandling/ScriptMacros.hpp"

4
src/Battling/Flow/TurnOrdering.cpp
View File

@ -17,8 +17,8 @@ bool ___ChoiceOrderFunc(const BaseTurnChoice* a, const BaseTurnChoice* b, Arbuti
if (aPriority != bPriority)
return aPriority > bPriority;
}
auto aSpeed = a->GetUser()->GetBoostedStat(Core::Statistic::Speed);
auto bSpeed = b->GetUser()->GetBoostedStat(Core::Statistic::Speed);
auto aSpeed = a->GetUser()->GetBoostedStat(Library::Statistic::Speed);
auto bSpeed = b->GetUser()->GetBoostedStat(Library::Statistic::Speed);
if (aSpeed != bSpeed)
return aSpeed > bSpeed;

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

@ -1,46 +1,48 @@
#include "BattleStatCalculator.hpp"
#include "../../Core/Exceptions/NotImplementedException.hpp"
#include "../../Library/Exceptions/NotImplementedException.hpp"
#include "../Models/Creature.hpp"
using namespace CreatureLib;
Core::StatisticSet<uint32_t> Battling::BattleStatCalculator::CalculateFlatStats(Battling::Creature* creature) const {
return Core::StatisticSet<uint32_t>(CalculateFlatStat(creature, Core::Statistic::Health),
CalculateFlatStat(creature, Core::Statistic::PhysicalAttack),
CalculateFlatStat(creature, Core::Statistic::PhysicalDefense),
CalculateFlatStat(creature, Core::Statistic::MagicalAttack),
CalculateFlatStat(creature, Core::Statistic::MagicalDefense),
CalculateFlatStat(creature, Core::Statistic::Speed));
Library::StatisticSet<uint32_t> Battling::BattleStatCalculator::CalculateFlatStats(Battling::Creature* creature) const {
return Library::StatisticSet<uint32_t>(CalculateFlatStat(creature, Library::Statistic::Health),
CalculateFlatStat(creature, Library::Statistic::PhysicalAttack),
CalculateFlatStat(creature, Library::Statistic::PhysicalDefense),
CalculateFlatStat(creature, Library::Statistic::MagicalAttack),
CalculateFlatStat(creature, Library::Statistic::MagicalDefense),
CalculateFlatStat(creature, Library::Statistic::Speed));
}
Core::StatisticSet<uint32_t> Battling::BattleStatCalculator::CalculateBoostedStats(Battling::Creature* creature) const {
return Core::StatisticSet<uint32_t>(CalculateBoostedStat(creature, Core::Statistic::Health),
CalculateBoostedStat(creature, Core::Statistic::PhysicalAttack),
CalculateBoostedStat(creature, Core::Statistic::PhysicalDefense),
CalculateBoostedStat(creature, Core::Statistic::MagicalAttack),
CalculateBoostedStat(creature, Core::Statistic::MagicalDefense),
CalculateBoostedStat(creature, Core::Statistic::Speed));
Library::StatisticSet<uint32_t>
Battling::BattleStatCalculator::CalculateBoostedStats(Battling::Creature* creature) const {
return Library::StatisticSet<uint32_t>(CalculateBoostedStat(creature, Library::Statistic::Health),
CalculateBoostedStat(creature, Library::Statistic::PhysicalAttack),
CalculateBoostedStat(creature, Library::Statistic::PhysicalDefense),
CalculateBoostedStat(creature, Library::Statistic::MagicalAttack),
CalculateBoostedStat(creature, Library::Statistic::MagicalDefense),
CalculateBoostedStat(creature, Library::Statistic::Speed));
}
uint32_t CalculateHealthStat(Battling::Creature* creature) {
auto level = creature->GetLevel();
auto a = (creature->GetBaseStat(Core::Statistic::Health)) * 2 * level;
auto a = (creature->GetBaseStat(Library::Statistic::Health)) * 2 * level;
return floor(a / 100) + level + 10;
}
uint32_t CalculateOtherStat(Battling::Creature* creature, Core::Statistic stat) {
uint32_t CalculateOtherStat(Battling::Creature* creature, Library::Statistic stat) {
auto level = creature->GetLevel();
auto a = (creature->GetBaseStat(stat)) * 2 * level;
return floor(a / 100) + 10;
}
uint32_t Battling::BattleStatCalculator::CalculateFlatStat(Battling::Creature* creature, Core::Statistic stat) const {
if (stat == Core::Statistic::Health)
uint32_t Battling::BattleStatCalculator::CalculateFlatStat(Battling::Creature* creature,
Library::Statistic stat) const {
if (stat == Library::Statistic::Health)
return CalculateHealthStat(creature);
return CalculateOtherStat(creature, stat);
}
uint32_t Battling::BattleStatCalculator::CalculateBoostedStat(Battling::Creature* creature,
Core::Statistic stat) const {
Library::Statistic stat) const {
return creature->GetFlatStat(stat) + (creature->GetBoostedStat(stat));
}

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

@ -1,7 +1,7 @@
#ifndef CREATURELIB_BATTLESTATCALCULATOR_HPP
#define CREATURELIB_BATTLESTATCALCULATOR_HPP
#include "../../Core/StatisticSet.hpp"
#include "../../Library/StatisticSet.hpp"
namespace CreatureLib::Battling {
// predeclare BattleCreature class
@ -11,10 +11,10 @@ namespace CreatureLib::Battling {
public:
virtual ~BattleStatCalculator() = default;
virtual Core::StatisticSet<uint32_t> CalculateFlatStats(Creature* creature) const;
virtual Core::StatisticSet<uint32_t> CalculateBoostedStats(Creature* creature) const;
virtual uint32_t CalculateFlatStat(Creature* creature, Core::Statistic stat) const;
virtual uint32_t CalculateBoostedStat(Creature* creature, Core::Statistic stat) const;
virtual Library::StatisticSet<uint32_t> CalculateFlatStats(Creature* creature) const;
virtual Library::StatisticSet<uint32_t> CalculateBoostedStats(Creature* creature) const;
virtual uint32_t CalculateFlatStat(Creature* creature, Library::Statistic stat) const;
virtual uint32_t CalculateBoostedStat(Creature* creature, Library::Statistic stat) const;
};
}

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

@ -24,14 +24,14 @@ float DamageLibrary::GetStatModifier(ExecutingAttack* attack, Creature* target,
auto user = attack->GetUser();
HOOK(ChangeDamageStatsUser, attack, attack, target, hitIndex, &user);
auto hit = attack->GetAttackDataForTarget(target)->GetHit(hitIndex);
Core::Statistic offensiveStat;
Core::Statistic defensiveStat;
Library::Statistic offensiveStat;
Library::Statistic defensiveStat;
if (attack->GetAttack()->GetAttack()->GetCategory() == Library::AttackCategory::Physical) {
offensiveStat = Core::Statistic::PhysicalAttack;
defensiveStat = Core::Statistic::PhysicalDefense;
offensiveStat = Library::Statistic::PhysicalAttack;
defensiveStat = Library::Statistic::PhysicalDefense;
} else {
offensiveStat = Core::Statistic::MagicalAttack;
defensiveStat = Core::Statistic::MagicalDefense;
offensiveStat = Library::Statistic::MagicalAttack;
defensiveStat = Library::Statistic::MagicalDefense;
}
auto bypassDefensive = hit->IsCritical() && target->GetStatBoost(defensiveStat) > 0;

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

@ -1,5 +1,5 @@
#include "Battle.hpp"
#include "../../Core/Exceptions/NotImplementedException.hpp"
#include "../../Library/Exceptions/NotImplementedException.hpp"
#include "../Flow/TurnHandler.hpp"
#include "../Flow/TurnOrdering.hpp"

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

@ -1,6 +1,6 @@
#include "BattleSide.hpp"
#include <algorithm>
#include "../../Core/Exceptions/CreatureException.hpp"
#include "../../Library/Exceptions/CreatureException.hpp"
#include "Battle.hpp"
using namespace CreatureLib::Battling;

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

@ -42,7 +42,7 @@ void Battling::Creature::SetBattleData(Battling::Battle* battle, Battling::Battl
// region Stat APIs
void Battling::Creature::ChangeStatBoost(Core::Statistic stat, int8_t diffAmount) {
void Battling::Creature::ChangeStatBoost(Library::Statistic stat, int8_t diffAmount) {
if (diffAmount > 0)
this->_statBoost.IncreaseStatBy(stat, diffAmount);
else
@ -50,13 +50,13 @@ void Battling::Creature::ChangeStatBoost(Core::Statistic stat, int8_t diffAmount
this->RecalculateBoostedStat(stat);
}
uint32_t Battling::Creature::GetFlatStat(Core::Statistic stat) const { return _flatStats.GetStat(stat); }
uint32_t Battling::Creature::GetFlatStat(Library::Statistic stat) const { return _flatStats.GetStat(stat); }
uint32_t Battling::Creature::GetBoostedStat(Core::Statistic stat) const { return _boostedStats.GetStat(stat); }
uint32_t Battling::Creature::GetBoostedStat(Library::Statistic stat) const { return _boostedStats.GetStat(stat); }
uint32_t Battling::Creature::GetBaseStat(Core::Statistic stat) const { return _variant->GetStatistic(stat); }
uint32_t Battling::Creature::GetBaseStat(Library::Statistic stat) const { return _variant->GetStatistic(stat); }
int8_t Battling::Creature::GetStatBoost(Core::Statistic stat) const { return _statBoost.GetStat(stat); }
int8_t Battling::Creature::GetStatBoost(Library::Statistic stat) const { return _statBoost.GetStat(stat); }
void Battling::Creature::RecalculateFlatStats() {
auto statCalc = this->_library->GetStatCalculator();
@ -67,13 +67,13 @@ void Battling::Creature::RecalculateBoostedStats() {
this->_boostedStats = this->_library->GetStatCalculator()->CalculateFlatStats(this);
}
void Battling::Creature::RecalculateFlatStat(Core::Statistic stat) {
void Battling::Creature::RecalculateFlatStat(Library::Statistic stat) {
auto s = this->_library->GetStatCalculator()->CalculateFlatStat(this, stat);
this->_flatStats.SetStat(stat, s);
RecalculateBoostedStat(stat);
}
void Battling::Creature::RecalculateBoostedStat(Core::Statistic stat) {
void Battling::Creature::RecalculateBoostedStat(Library::Statistic stat) {
auto s = this->_library->GetStatCalculator()->CalculateBoostedStat(this, stat);
this->_boostedStats.SetStat(stat, s);
}

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

@ -33,9 +33,9 @@ namespace CreatureLib::Battling {
const Library::Item* _heldItem;
uint32_t _currentHealth;
Core::StatisticSet<int8_t> _statBoost;
Core::StatisticSet<uint32_t> _flatStats;
Core::StatisticSet<uint32_t> _boostedStats;
Library::StatisticSet<int8_t> _statBoost;
Library::StatisticSet<uint32_t> _flatStats;
Library::StatisticSet<uint32_t> _boostedStats;
Battle* _battle = nullptr;
BattleSide* _side = nullptr;
@ -73,7 +73,7 @@ namespace CreatureLib::Battling {
virtual void Initialize() {
RecalculateFlatStats();
_currentHealth = GetBoostedStat(Core::Statistic::Health);
_currentHealth = GetBoostedStat(Library::Statistic::Health);
}
inline const Library::CreatureSpecies* GetSpecies() const { return _species; }
@ -136,15 +136,15 @@ namespace CreatureLib::Battling {
// region Stat APIs
void ChangeStatBoost(Core::Statistic stat, int8_t diffAmount);
[[nodiscard]] uint32_t GetFlatStat(Core::Statistic stat) const;
[[nodiscard]] uint32_t GetBoostedStat(Core::Statistic stat) const;
[[nodiscard]] uint32_t GetBaseStat(Core::Statistic stat) const;
[[nodiscard]] int8_t GetStatBoost(Core::Statistic stat) const;
void ChangeStatBoost(Library::Statistic stat, int8_t diffAmount);
[[nodiscard]] uint32_t GetFlatStat(Library::Statistic stat) const;
[[nodiscard]] uint32_t GetBoostedStat(Library::Statistic stat) const;
[[nodiscard]] uint32_t GetBaseStat(Library::Statistic stat) const;
[[nodiscard]] int8_t GetStatBoost(Library::Statistic stat) const;
void RecalculateFlatStats();
void RecalculateBoostedStats();
void RecalculateFlatStat(Core::Statistic);
void RecalculateBoostedStat(Core::Statistic);
void RecalculateFlatStat(Library::Statistic);
void RecalculateBoostedStat(Library::Statistic);
// endregion
};

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

@ -3,7 +3,7 @@
#include <any>
#include <queue>
#include "../../Core/Exceptions/NotReachableException.hpp"
#include "../../Library/Exceptions/NotReachableException.hpp"
#include "Script.hpp"
#include "ScriptSet.hpp"
#include "ScriptWrapper.hpp"

81
src/Core/StatisticSet.hpp
View File

@ -1,81 +0,0 @@
#ifndef CREATURELIB_STATISTICSET_HPP
#define CREATURELIB_STATISTICSET_HPP
#include <exception>
#include <stdint.h>
#include "Exceptions/NotReachableException.hpp"
#include "Statistic.hpp"
namespace CreatureLib::Core {
template <class T> class StatisticSet {
protected:
T _health;
T _physicalAttack;
T _physicalDefense;
T _magicalAttack;
T _magicalDefense;
T _speed;
public:
StatisticSet(T health, T physicalAttack, T physicalDefense, T magicalAttack, T magicalDefense, T speed)
: _health(health), _physicalAttack(physicalAttack), _physicalDefense(physicalDefense),
_magicalAttack(magicalAttack), _magicalDefense(magicalDefense), _speed(speed) {}
StatisticSet()
: _health(0), _physicalAttack(0), _physicalDefense(0), _magicalAttack(0), _magicalDefense(0), _speed(0) {}
inline T GetHealth() const { return _health; }
inline T GetPhysicalAttack() const { return _physicalAttack; }
inline T GetPhysicalDefense() const { return _physicalDefense; }
inline T GetMagicalAttack() const { return _magicalAttack; }
inline T GetMagicalDefense() const { return _magicalDefense; }
inline T GetSpeed() const { return _speed; }
[[nodiscard]] inline T GetStat(Statistic stat) const {
switch (stat) {
case CreatureLib::Core::Statistic::Health: return _health;
case CreatureLib::Core::Statistic::PhysicalAttack: return _physicalAttack;
case CreatureLib::Core::Statistic::PhysicalDefense: return _physicalDefense;
case CreatureLib::Core::Statistic::MagicalAttack: return _magicalAttack;
case CreatureLib::Core::Statistic::MagicalDefense: return _magicalDefense;
case CreatureLib::Core::Statistic::Speed: return _speed;
default: throw NotReachableException();
}
}
inline void SetStat(Statistic stat, T value) {
switch (stat) {
case CreatureLib::Core::Statistic::Health: _health = value; break;
case CreatureLib::Core::Statistic::PhysicalAttack: _physicalAttack = value; break;
case CreatureLib::Core::Statistic::PhysicalDefense: _physicalDefense = value; break;
case CreatureLib::Core::Statistic::MagicalAttack: _magicalAttack = value; break;
case CreatureLib::Core::Statistic::MagicalDefense: _magicalDefense = value; break;
case CreatureLib::Core::Statistic::Speed: _speed = value; break;
default: throw NotReachableException();
}
}
inline void IncreaseStatBy(Statistic stat, T amount) {
switch (stat) {
case CreatureLib::Core::Statistic::Health: _health += amount; break;
case CreatureLib::Core::Statistic::PhysicalAttack: _physicalAttack += amount; break;
case CreatureLib::Core::Statistic::PhysicalDefense: _physicalDefense += amount; break;
case CreatureLib::Core::Statistic::MagicalAttack: _magicalAttack += amount; break;
case CreatureLib::Core::Statistic::MagicalDefense: _magicalDefense += amount; break;
case CreatureLib::Core::Statistic::Speed: _speed += amount; break;
default: throw NotReachableException();
}
}
inline void DecreaseStatBy(Statistic stat, T amount) {
switch (stat) {
case CreatureLib::Core::Statistic::Health: _health -= amount; break;
case CreatureLib::Core::Statistic::PhysicalAttack: _physicalAttack -= amount; break;
case CreatureLib::Core::Statistic::PhysicalDefense: _physicalDefense -= amount; break;
case CreatureLib::Core::Statistic::MagicalAttack: _magicalAttack -= amount; break;
case CreatureLib::Core::Statistic::MagicalDefense: _magicalDefense -= amount; break;
case CreatureLib::Core::Statistic::Speed: _speed -= amount; break;
default: throw NotReachableException();
}
}
};
}
#endif // CREATURELIB_STATISTICSET_HPP

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

@ -8,7 +8,7 @@ size_t CreatureLib::Library::SpeciesVariant::GetTypeCount() const { return _type
uint8_t CreatureLib::Library::SpeciesVariant::GetType(size_t index) const { return _types[index]; }
uint32_t CreatureLib::Library::SpeciesVariant::GetStatistic(CreatureLib::Core::Statistic stat) const {
uint32_t CreatureLib::Library::SpeciesVariant::GetStatistic(CreatureLib::Library::Statistic stat) const {
return _baseStatistics.GetStat(stat);
}
@ -37,7 +37,7 @@ const CreatureLib::Library::LearnableAttacks* CreatureLib::Library::SpeciesVaria
CreatureLib::Library::SpeciesVariant::SpeciesVariant(ConstString name, float height, float weight,
uint32_t baseExperience, std::vector<uint8_t> types,
CreatureLib::Core::StatisticSet<uint16_t> baseStats,
CreatureLib::Library::StatisticSet<uint16_t> baseStats,
std::vector<ConstString> talents,
std::vector<ConstString> secretTalents,
const LearnableAttacks* attacks)

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

@ -4,7 +4,7 @@
#include <Arbutils/Random.hpp>
#include <string>
#include <vector>
#include "../../Core/StatisticSet.hpp"
#include "../StatisticSet.hpp"
#include "CreatureMoves.hpp"
#include "LearnableAttacks.hpp"
#include "TalentIndex.hpp"
@ -23,14 +23,14 @@ namespace CreatureLib::Library {
private:
std::vector<uint8_t> _types;
const Core::StatisticSet<uint16_t> _baseStatistics;
const Library::StatisticSet<uint16_t> _baseStatistics;
std::vector<ConstString> _talents;
std::vector<ConstString> _secretTalents;
const LearnableAttacks* _attacks;
public:
SpeciesVariant(ConstString name, float height, float weight, uint32_t baseExperience,
std::vector<uint8_t> types, Core::StatisticSet<uint16_t> baseStats,
std::vector<uint8_t> types, Library::StatisticSet<uint16_t> baseStats,
std::vector<ConstString> talents, std::vector<ConstString> secretTalents,
const LearnableAttacks* attacks);
@ -44,7 +44,7 @@ namespace CreatureLib::Library {
[[nodiscard]] size_t GetTypeCount() const;
[[nodiscard]] uint8_t GetType(size_t index) const;
[[nodiscard]] const std::vector<uint8_t>& GetTypes() const;
[[nodiscard]] uint32_t GetStatistic(Core::Statistic stat) const;
[[nodiscard]] uint32_t GetStatistic(Library::Statistic stat) const;
[[nodiscard]] const size_t GetTalentCount() const { return _talents.size(); }
[[nodiscard]] const size_t GetSecretTalentCount() const { return _secretTalents.size(); }
[[nodiscard]] const ConstString& GetTalent(const TalentIndex& index) const {

0
src/Core/Exceptions/CreatureException.hpp → src/Library/Exceptions/CreatureException.hpp
View File

0
src/Core/Exceptions/NotImplementedException.hpp → src/Library/Exceptions/NotImplementedException.hpp
View File

0
src/Core/Exceptions/NotReachableException.hpp → src/Library/Exceptions/NotReachableException.hpp
View File

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

@ -1,5 +1,5 @@
#include "GrowthRateLibrary.hpp"
#include "../../Core/Exceptions/CreatureException.hpp"
#include "../Exceptions/CreatureException.hpp"
uint8_t CreatureLib::Library::GrowthRateLibrary::CalculateLevel(const ConstString& growthRate,
uint32_t experience) const {

2
src/Core/Statistic.hpp → src/Library/Statistic.hpp
View File

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

81
src/Library/StatisticSet.hpp Normal file
View File

@ -0,0 +1,81 @@
#ifndef CREATURELIB_STATISTICSET_HPP
#define CREATURELIB_STATISTICSET_HPP
#include <exception>
#include <stdint.h>
#include "Exceptions/NotReachableException.hpp"
#include "Statistic.hpp"
namespace CreatureLib::Library {
template <class T> class StatisticSet {
protected:
T _health;
T _physicalAttack;
T _physicalDefense;
T _magicalAttack;
T _magicalDefense;
T _speed;
public:
StatisticSet(T health, T physicalAttack, T physicalDefense, T magicalAttack, T magicalDefense, T speed)
: _health(health), _physicalAttack(physicalAttack), _physicalDefense(physicalDefense),
_magicalAttack(magicalAttack), _magicalDefense(magicalDefense), _speed(speed) {}
StatisticSet()
: _health(0), _physicalAttack(0), _physicalDefense(0), _magicalAttack(0), _magicalDefense(0), _speed(0) {}
inline T GetHealth() const { return _health; }
inline T GetPhysicalAttack() const { return _physicalAttack; }
inline T GetPhysicalDefense() const { return _physicalDefense; }
inline T GetMagicalAttack() const { return _magicalAttack; }
inline T GetMagicalDefense() const { return _magicalDefense; }
inline T GetSpeed() const { return _speed; }
[[nodiscard]] inline T GetStat(Statistic stat) const {
switch (stat) {
case CreatureLib::Library::Statistic::Health: return _health;
case CreatureLib::Library::Statistic::PhysicalAttack: return _physicalAttack;
case CreatureLib::Library::Statistic::PhysicalDefense: return _physicalDefense;
case CreatureLib::Library::Statistic::MagicalAttack: return _magicalAttack;
case CreatureLib::Library::Statistic::MagicalDefense: return _magicalDefense;
case CreatureLib::Library::Statistic::Speed: return _speed;
default: throw NotReachableException();
}
}
inline void SetStat(Statistic stat, T value) {
switch (stat) {
case CreatureLib::Library::Statistic::Health: _health = value; break;
case CreatureLib::Library::Statistic::PhysicalAttack: _physicalAttack = value; break;
case CreatureLib::Library::Statistic::PhysicalDefense: _physicalDefense = value; break;
case CreatureLib::Library::Statistic::MagicalAttack: _magicalAttack = value; break;
case CreatureLib::Library::Statistic::MagicalDefense: _magicalDefense = value; break;
case CreatureLib::Library::Statistic::Speed: _speed = value; break;
default: throw NotReachableException();
}
}
inline void IncreaseStatBy(Statistic stat, T amount) {
switch (stat) {
case CreatureLib::Library::Statistic::Health: _health += amount; break;
case CreatureLib::Library::Statistic::PhysicalAttack: _physicalAttack += amount; break;
case CreatureLib::Library::Statistic::PhysicalDefense: _physicalDefense += amount; break;
case CreatureLib::Library::Statistic::MagicalAttack: _magicalAttack += amount; break;
case CreatureLib::Library::Statistic::MagicalDefense: _magicalDefense += amount; break;
case CreatureLib::Library::Statistic::Speed: _speed += amount; break;
default: throw NotReachableException();
}
}
inline void DecreaseStatBy(Statistic stat, T amount) {
switch (stat) {
case CreatureLib::Library::Statistic::Health: _health -= amount; break;
case CreatureLib::Library::Statistic::PhysicalAttack: _physicalAttack -= amount; break;
case CreatureLib::Library::Statistic::PhysicalDefense: _physicalDefense -= amount; break;
case CreatureLib::Library::Statistic::MagicalAttack: _magicalAttack -= amount; break;
case CreatureLib::Library::Statistic::MagicalDefense: _magicalDefense -= amount; break;
case CreatureLib::Library::Statistic::Speed: _speed -= amount; break;
default: throw NotReachableException();
}
}
};
}
#endif // CREATURELIB_STATISTICSET_HPP

2
tests/ExceptionTests.cpp
View File

@ -1,7 +1,7 @@
#ifdef TESTS_BUILD
#include <cstring>
#include "../extern/catch.hpp"
#include "../src/Core/Exceptions/CreatureException.hpp"
#include "../src/Library/Exceptions/CreatureException.hpp"
TEST_CASE("When throwing exception, what() is readable", "[Utilities]") {
bool hasCaught = false;

4
tests/Integration/BattleIntegrations.cpp
View File

@ -205,8 +205,8 @@ TEST_CASE("Switch Creature in, but have attack aimed at it. Attack should hit ne
battle.TrySetChoice(new SwitchTurnChoice(c1, c2));
battle.TrySetChoice(new AttackTurnChoice(c3, c3->GetAttacks()[0], CreatureIndex(0, 0)));
REQUIRE(c2->GetCurrentHealth() < c2->GetBoostedStat(Core::Statistic::Health));
REQUIRE(c1->GetCurrentHealth() == c1->GetBoostedStat(Core::Statistic::Health));
REQUIRE(c2->GetCurrentHealth() < c2->GetBoostedStat(Library::Statistic::Health));
REQUIRE(c1->GetCurrentHealth() == c1->GetBoostedStat(Library::Statistic::Health));
}
TEST_CASE("Switch Creature in, mark as seen opponent for opponent", "[Integrations]") {

4
tests/LibraryTests/CreatureTests.cpp
View File

@ -41,8 +41,8 @@ TEST_CASE("Get creature nickname when unset", "[Library]") {
TEST_CASE("Increase creature stat boost", "[Library]") {
auto library = TestLibrary::Get();
auto creature = CreateCreature(library, "testSpecies1", 1).Create();
creature->ChangeStatBoost(CreatureLib::Core::Statistic::PhysicalAttack, 6);
REQUIRE(creature->GetStatBoost(CreatureLib::Core::Statistic::PhysicalAttack) == 6);
creature->ChangeStatBoost(CreatureLib::Library::Statistic::PhysicalAttack, 6);
REQUIRE(creature->GetStatBoost(CreatureLib::Library::Statistic::PhysicalAttack) == 6);
delete creature;
}

1
tests/TestLibrary/TestLibrary.cpp
View File

@ -3,7 +3,6 @@
#include "TestLibrary.hpp"
#include "../../src/Library/GrowthRates/LookupGrowthRate.hpp"
using namespace CreatureLib::Core;
using namespace CreatureLib::Library;
using namespace CreatureLib::Battling;
BattleLibrary* TestLibrary::_library = nullptr;

1
tests/TestLibrary/TestLibrary.hpp
View File

@ -5,7 +5,6 @@
#include "../../src/Battling/Library/BattleLibrary.hpp"
using namespace CreatureLib::Core;
using namespace CreatureLib::Library;
using namespace CreatureLib::Battling;