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

Used ClangFormat style guide I'm happy with.
continuous-integration/drone/push Build is passing Details

This commit is contained in:
Deukhoofd 2019-11-28 12:55:22 +01:00
parent 3b685ae782
commit a8730d983f
Signed by: Deukhoofd
GPG Key ID: ADF2E9256009EDCE
91 changed files with 946 additions and 1121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
.clang-format Normal file
View File

@ -0,0 +1,121 @@
# ClangFormatConfigureSource: 'LLVM'
---
Language: Cpp
# BasedOnStyle: LLVM
AccessModifierOffset: -4
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Right
AlignOperands: true
AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: true
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: MultiLine
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
AfterClass: false
AfterControlStatement: false
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Attach
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 120
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: false
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Merge
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
Priority: 1
- Regex: '.*'
Priority: 3
IncludeIsMainRegex: '(Test)?$'
IndentCaseLabels: true
IndentPPDirectives: None
IndentWidth: 4
IndentWrappedFunctionNames: false
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: true
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: All
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Left
ReflowComments: true
SortIncludes: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Cpp11
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 8
UseTab: Never
...

19
src/Battling/Flow/ChoiceQueue.hpp
View File

@ -5,31 +5,26 @@
#include <vector>
#include "../TurnChoices/BaseTurnChoice.hpp"
namespace CreatureLib::Battling{
namespace CreatureLib::Battling {
class ChoiceQueue {
std::vector<BaseTurnChoice*> _queue;
size_t _current = 0;
public:
bool HasCompletedQueue = false;
explicit ChoiceQueue(std::vector<BaseTurnChoice*> queue)
:_queue(std::move(queue)){}
explicit ChoiceQueue(std::vector<BaseTurnChoice*> queue) : _queue(std::move(queue)) {}
BaseTurnChoice* Dequeue(){
BaseTurnChoice* Dequeue() {
auto b = _queue[_current];
_current++;
return b;
}
[[nodiscard]] bool HasNext() const{
return _current < _queue.size();
}
[[nodiscard]] bool HasNext() const { return _current < _queue.size(); }
std::vector<BaseTurnChoice*>& GetInnerQueue(){
return _queue;
}
std::vector<BaseTurnChoice*>& GetInnerQueue() { return _queue; }
};
}
#endif //CREATURELIB_CHOICEQUEUE_HPP
#endif // CREATURELIB_CHOICEQUEUE_HPP

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

@ -1,16 +1,16 @@
#include "TurnHandler.hpp"
#include "../Models/Battle.hpp"
#include "../../Core/Exceptions/NotImplementedException.hpp"
#include "../Models/Battle.hpp"
#include "../ScriptHandling/ScriptMacros.cpp"
using namespace CreatureLib::Battling;
void TurnHandler::RunTurn(Battle* battle, ChoiceQueue* queue) {
for (auto choice: queue->GetInnerQueue()){
for (auto choice : queue->GetInnerQueue()) {
HOOK(OnBeforeTurn, choice, choice);
}
while (queue->HasNext()){
if (!battle->HasRecalledSlots()){
while (queue->HasNext()) {
if (!battle->HasRecalledSlots()) {
return;
}
auto item = queue->Dequeue();
@ -20,9 +20,8 @@ void TurnHandler::RunTurn(Battle* battle, ChoiceQueue* queue) {
queue->HasCompletedQueue = true;
}
void TurnHandler::ExecuteChoice(BaseTurnChoice *choice) {
if (choice == nullptr)
{
void TurnHandler::ExecuteChoice(BaseTurnChoice* choice) {
if (choice == nullptr) {
return;
}
auto choiceKind = choice->GetKind();
@ -31,35 +30,33 @@ void TurnHandler::ExecuteChoice(BaseTurnChoice *choice) {
}
auto user = choice->GetUser();
// If the user is fainted, we don't want to execute its choice.
if (user->IsFainted()){
if (user->IsFainted()) {
return;
}
auto battle = user->GetBattle();
// If the user is not in the field, we don't want to execute its choice.
if (!battle->CreatureInField(user)){
if (!battle->CreatureInField(user)) {
return;
}
// If the choice is not valid, we don't want to execute it.
if (!battle->CanUse(choice)){
if (!battle->CanUse(choice)) {
return;
}
switch (choiceKind){
switch (choiceKind) {
case TurnChoiceKind::Pass: throw NotReachableException();
case TurnChoiceKind::Attack:
return ExecuteAttackChoice(dynamic_cast<AttackTurnChoice*>(choice));
case TurnChoiceKind::Attack: return ExecuteAttackChoice(dynamic_cast<AttackTurnChoice*>(choice));
case TurnChoiceKind::Item:
case TurnChoiceKind::Switch:
case TurnChoiceKind::RunAway:
throw NotImplementedException();
case TurnChoiceKind::RunAway: throw NotImplementedException();
}
}
void TurnHandler::ExecuteAttackChoice(AttackTurnChoice *choice) {
void TurnHandler::ExecuteAttackChoice(AttackTurnChoice* choice) {
auto attackName = choice->GetAttack()->GetAttack()->GetName();
HOOK(ChangeAttack, choice, choice, attackName);
if (attackName != choice->GetAttack()->GetAttack()->GetName()){
//TODO: Change attack
if (attackName != choice->GetAttack()->GetAttack()->GetName()) {
// TODO: Change attack
}
// FIXME: Resolve all targets
@ -69,36 +66,37 @@ void TurnHandler::ExecuteAttackChoice(AttackTurnChoice *choice) {
auto attack = new ExecutingAttack(targets, 1, choice->GetUser(), choice->GetAttack(), choice->GetAttackScript());
bool prevented = false;
HOOK(PreventAttack, attack, attack, prevented);
if (prevented){
if (prevented) {
return;
}
//HOOK: override targets
// HOOK: override targets
if (!choice->GetAttack()->TryUse(1)){
if (!choice->GetAttack()->TryUse(1)) {
return;
}
//HOOK: check if attack fails
// HOOK: check if attack fails
bool fail = false;
HOOK(FailAttack, attack, attack, fail);
if (fail){
//TODO: Fail handling.
if (fail) {
// TODO: Fail handling.
return;
}
HOOK(StopBeforeAttack, attack, attack);
HOOK(OnBeforeAttack, attack, attack);
for (auto& kv: attack->GetTargets()){
for (auto& kv : attack->GetTargets()) {
HandleAttackForTarget(attack, kv.first, kv.second);
}
//TODO: We currently delete this, but we probably want to store this in a log, so scripts can look it up.
// TODO: We currently delete this, but we probably want to store this in a log, so scripts can look it up.
delete attack;
}
void TurnHandler::HandleAttackForTarget(ExecutingAttack* attack, Creature *target, const ExecutingAttack::TargetData &targetData) {
void TurnHandler::HandleAttackForTarget(ExecutingAttack* attack, Creature* target,
const ExecutingAttack::TargetData& targetData) {
auto user = attack->GetUser();
ScriptSource* targetSource = target;
@ -106,19 +104,19 @@ void TurnHandler::HandleAttackForTarget(ExecutingAttack* attack, Creature *targe
bool fail = false;
HOOK(FailIncomingAttack, targetSource, attack, target, fail);
if (fail){
//TODO: Fail handling.
if (fail) {
// TODO: Fail handling.
return;
}
bool invulnerable = fail;
HOOK(IsInvulnerable, targetSource, attack, target, invulnerable);
if (invulnerable){
//TODO: We should probably do something when a target is invulnerable.
if (invulnerable) {
// TODO: We should probably do something when a target is invulnerable.
return;
}
if (!targetData.IsHit()){
if (!targetData.IsHit()) {
HOOK(OnAttackMiss, targetSource, attack, target);
return;
}
@ -129,11 +127,11 @@ void TurnHandler::HandleAttackForTarget(ExecutingAttack* attack, Creature *targe
auto attackData = attack->GetAttack()->GetAttack();
auto library = user->GetBattle()->GetLibrary();
auto dmgLibrary = library->GetDamageLibrary();
for (uint8_t hitIndex = 0; hitIndex < numHits; hitIndex++){
if (user->IsFainted()){
for (uint8_t hitIndex = 0; hitIndex < numHits; hitIndex++) {
if (user->IsFainted()) {
break;
}
if (target->IsFainted()){
if (target->IsFainted()) {
// STOP, STOP! HE'S ALREADY DEAD ;_;
break;
}
@ -146,28 +144,27 @@ void TurnHandler::HandleAttackForTarget(ExecutingAttack* attack, Creature *targe
hit.SetBasePower(dmgLibrary->GetBasePower(attack, target, hitIndex));
hit.SetDamage(dmgLibrary->GetDamage(attack, target, hitIndex));
if (attackData->GetCategory() == Library::AttackCategory::Status){
if (attackData->GetCategory() == Library::AttackCategory::Status) {
HOOK(OnStatusMove, userSource, attack, target, hitIndex);
}
else{
} else {
auto damage = hit.GetDamage();
if (damage > target->GetCurrentHealth()){
if (damage > target->GetCurrentHealth()) {
damage = target->GetCurrentHealth();
hit.SetDamage(damage);
}
if (damage > 0){
if (damage > 0) {
target->Damage(damage, DamageSource::AttackDamage);
bool preventSecondary = false;
HOOK(PreventSecondaryEffects, targetSource, attack, target, hitIndex, preventSecondary);
if (!preventSecondary){
if (!preventSecondary) {
HOOK(OnSecondaryEffect, userSource, attack, target, hitIndex);
}
}
}
}
if (!user->IsFainted()){
if (!user->IsFainted()) {
HOOK(OnAfterHits, userSource, attack, target);
}
}

10
src/Battling/Flow/TurnHandler.hpp
View File

@ -1,9 +1,9 @@
#ifndef CREATURELIB_TURNHANDLER_HPP
#define CREATURELIB_TURNHANDLER_HPP
#include "ChoiceQueue.hpp"
#include "../TurnChoices/AttackTurnChoice.hpp"
#include "../Models/ExecutingAttack.hpp"
#include "../TurnChoices/AttackTurnChoice.hpp"
#include "ChoiceQueue.hpp"
namespace CreatureLib::Battling {
class Battle;
@ -12,10 +12,12 @@ namespace CreatureLib::Battling {
static void ExecuteChoice(BaseTurnChoice* choice);
static void ExecuteAttackChoice(AttackTurnChoice* choice);
static void HandleAttackForTarget(ExecutingAttack* attack, Creature* target, const ExecutingAttack::TargetData& targetData);
static void HandleAttackForTarget(ExecutingAttack* attack, Creature* target,
const ExecutingAttack::TargetData& targetData);
public:
static void RunTurn(Battle* battle, ChoiceQueue* queue);
};
}
#endif //CREATURELIB_TURNHANDLER_HPP
#endif // CREATURELIB_TURNHANDLER_HPP

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

@ -1,18 +1,17 @@
#include "TurnOrdering.hpp"
#include "../TurnChoices/AttackTurnChoice.hpp"
#include "../Models/Battle.hpp"
#include <algorithm>
#include "../Models/Battle.hpp"
#include "../TurnChoices/AttackTurnChoice.hpp"
using namespace CreatureLib;
using namespace Battling;
bool ___ChoiceOrderFunc(const BaseTurnChoice* a, const BaseTurnChoice* b, Core::Random& rand){
bool ___ChoiceOrderFunc(const BaseTurnChoice* a, const BaseTurnChoice* b, Core::Random& rand) {
auto aKind = a->GetKind();
auto bKind = b->GetKind();
if (aKind != bKind)
return aKind > bKind;
if (aKind == TurnChoiceKind::Attack){
if (aKind == TurnChoiceKind::Attack) {
auto aPriority = dynamic_cast<const AttackTurnChoice*>(a)->GetPriority();
auto bPriority = dynamic_cast<const AttackTurnChoice*>(b)->GetPriority();
if (aPriority != bPriority)
@ -27,9 +26,9 @@ bool ___ChoiceOrderFunc(const BaseTurnChoice* a, const BaseTurnChoice* b, Core::
return randomValue == 0;
}
void TurnOrdering::OrderChoices(std::vector<BaseTurnChoice *> &vec, Core::Random& rand) {
auto comp = [&](const BaseTurnChoice * a,const BaseTurnChoice * b)-> bool {
return ___ChoiceOrderFunc(a,b,rand);
void TurnOrdering::OrderChoices(std::vector<BaseTurnChoice*>& vec, Core::Random& rand) {
auto comp = [&](const BaseTurnChoice* a, const BaseTurnChoice* b) -> bool {
return ___ChoiceOrderFunc(a, b, rand);
};
std::sort(vec.begin(), vec.end(), comp);
}

6
src/Battling/Flow/TurnOrdering.hpp
View File

@ -1,9 +1,9 @@
#ifndef CREATURELIB_TURNORDERING_HPP
#define CREATURELIB_TURNORDERING_HPP
#include "../TurnChoices/BaseTurnChoice.hpp"
#include "../../Core/Random.hpp"
#include <vector>
#include "../../Core/Random.hpp"
#include "../TurnChoices/BaseTurnChoice.hpp"
namespace CreatureLib::Battling {
class TurnOrdering {
@ -12,4 +12,4 @@ namespace CreatureLib::Battling {
};
}
#endif //CREATURELIB_TURNORDERING_HPP
#endif // CREATURELIB_TURNORDERING_HPP

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

@ -1,16 +1,13 @@
#include <cassert>
#include "BattleLibrary.hpp"
#include <cassert>
using namespace CreatureLib::Battling;
BattleLibrary::BattleLibrary(CreatureLib::Library::DataLibrary *staticLib,
BattleStatCalculator *statCalculator,
DamageLibrary* damageLibrary,
CriticalLibrary* criticalLibrary, ScriptResolver* scriptResolver)
: _staticLib(staticLib), _statCalculator(statCalculator),
_damageLibrary(damageLibrary), _criticalLibrary(criticalLibrary),
_scriptResolver(scriptResolver)
{}
BattleLibrary::BattleLibrary(CreatureLib::Library::DataLibrary* staticLib, BattleStatCalculator* statCalculator,
DamageLibrary* damageLibrary, CriticalLibrary* criticalLibrary,
ScriptResolver* scriptResolver)
: _staticLib(staticLib), _statCalculator(statCalculator), _damageLibrary(damageLibrary),
_criticalLibrary(criticalLibrary), _scriptResolver(scriptResolver) {}
BattleLibrary::~BattleLibrary() {
delete _staticLib;
@ -20,40 +17,27 @@ BattleLibrary::~BattleLibrary() {
delete _scriptResolver;
}
const CreatureLib::Library::LibrarySettings& BattleLibrary::GetSettings() const {
return _staticLib->GetSettings();
}
const CreatureLib::Library::LibrarySettings& BattleLibrary::GetSettings() const { return _staticLib->GetSettings(); }
const BattleStatCalculator *BattleLibrary::GetStatCalculator() const {
return _statCalculator;
}
const BattleStatCalculator* BattleLibrary::GetStatCalculator() const { return _statCalculator; }
const CreatureLib::Library::SpeciesLibrary* BattleLibrary::GetSpeciesLibrary() const {
return _staticLib->GetSpeciesLibrary();
}
const CreatureLib::Library::ItemLibrary* BattleLibrary::GetItemLibrary() const {
return _staticLib->GetItemLibrary();
}
const CreatureLib::Library::ItemLibrary* BattleLibrary::GetItemLibrary() const { return _staticLib->GetItemLibrary(); }
const CreatureLib::Library::AttackLibrary *BattleLibrary::GetAttackLibrary() const {
const CreatureLib::Library::AttackLibrary* BattleLibrary::GetAttackLibrary() const {
return _staticLib->GetAttackLibrary();
}
const CreatureLib::Library::TypeLibrary *BattleLibrary::GetTypeLibrary() const {
return _staticLib->GetTypeLibrary();
}
const CreatureLib::Library::TypeLibrary* BattleLibrary::GetTypeLibrary() const { return _staticLib->GetTypeLibrary(); }
const DamageLibrary *BattleLibrary::GetDamageLibrary() const {
return _damageLibrary;
}
const DamageLibrary* BattleLibrary::GetDamageLibrary() const { return _damageLibrary; }
const CriticalLibrary *BattleLibrary::GetCriticalLibrary() const {
return _criticalLibrary;
}
const CriticalLibrary* BattleLibrary::GetCriticalLibrary() const { return _criticalLibrary; }
Script* BattleLibrary::LoadScript(ScriptResolver::ScriptCategory category, const std::string &scriptName) {
Script* BattleLibrary::LoadScript(ScriptResolver::ScriptCategory category, const std::string& scriptName) {
assert(this->_scriptResolver != nullptr);
return _scriptResolver->LoadScript(category, scriptName);
}

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

@ -1,11 +1,11 @@
#ifndef CREATURELIB_BATTLELIBRARY_HPP
#define CREATURELIB_BATTLELIBRARY_HPP
#include "BattleStatCalculator.hpp"
#include "../../Library/DataLibrary.hpp"
#include "DamageLibrary.hpp"
#include "CriticalLibrary.hpp"
#include "../ScriptHandling/ScriptResolver.hpp"
#include "BattleStatCalculator.hpp"
#include "CriticalLibrary.hpp"
#include "DamageLibrary.hpp"
namespace CreatureLib::Battling {
class BattleLibrary {
@ -14,9 +14,10 @@ namespace CreatureLib::Battling {
DamageLibrary* _damageLibrary;
CriticalLibrary* _criticalLibrary;
ScriptResolver* _scriptResolver;
public:
BattleLibrary(Library::DataLibrary* staticLib, BattleStatCalculator* statCalculator, DamageLibrary* damageLibrary,
CriticalLibrary* criticalLibrary, ScriptResolver* scriptResolver);
BattleLibrary(Library::DataLibrary* staticLib, BattleStatCalculator* statCalculator,
DamageLibrary* damageLibrary, CriticalLibrary* criticalLibrary, ScriptResolver* scriptResolver);
~BattleLibrary();
[[nodiscard]] const Library::LibrarySettings& GetSettings() const;
@ -33,4 +34,4 @@ namespace CreatureLib::Battling {
};
}
#endif //CREATURELIB_BATTLELIBRARY_HPP
#endif // CREATURELIB_BATTLELIBRARY_HPP

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

@ -1,54 +1,49 @@
#include "BattleStatCalculator.hpp"
#include "../Models/Creature.hpp"
#include "../../Core/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),
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)
);
CalculateFlatStat(creature, Core::Statistic::Speed));
}
Core::StatisticSet<uint32_t>
Battling::BattleStatCalculator::CalculateBoostedStats(Battling::Creature *creature) const {
return Core::StatisticSet<uint32_t>(
CalculateBoostedStat(creature, Core::Statistic::Health),
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)
);
CalculateBoostedStat(creature, Core::Statistic::Speed));
}
uint32_t CalculateHealthStat(Battling::Creature *creature){
uint32_t CalculateHealthStat(Battling::Creature* creature) {
auto level = creature->GetLevel();
auto a = (creature->GetBaseStat(Core::Statistic::Health) + creature->GetStatPotential(Core::Statistic::Health)) * 2 +
auto a =
(creature->GetBaseStat(Core::Statistic::Health) + creature->GetStatPotential(Core::Statistic::Health)) * 2 +
floor(sqrt(creature->GetStatExperience(Core::Statistic::Health) / 4)) * level;
return floor(a / 100) + level + 10;
}
uint32_t CalculateOtherStat(Battling::Creature *creature, Core::Statistic stat){
uint32_t CalculateOtherStat(Battling::Creature* creature, Core::Statistic stat) {
auto level = creature->GetLevel();
auto a = (creature->GetBaseStat(stat) + creature->GetStatPotential(stat)) * 2 +
floor(sqrt(creature->GetStatExperience(stat) / 4)) * level;
return floor(a / 100) + 10;
}
uint32_t Battling::BattleStatCalculator::CalculateFlatStat(Battling::Creature *creature, Core::Statistic stat) const{
uint32_t Battling::BattleStatCalculator::CalculateFlatStat(Battling::Creature* creature, Core::Statistic stat) const {
if (stat == Core::Statistic::Health)
return CalculateHealthStat(creature);
return CalculateOtherStat(creature, stat);
}
uint32_t Battling::BattleStatCalculator::CalculateBoostedStat(Battling::Creature *creature, Core::Statistic stat) const{
uint32_t Battling::BattleStatCalculator::CalculateBoostedStat(Battling::Creature* creature,
Core::Statistic stat) const {
throw NotImplementedException();
}

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

@ -4,18 +4,18 @@
#include "../../Core/StatisticSet.hpp"
namespace CreatureLib::Battling {
//predeclare BattleCreature class
// predeclare BattleCreature class
class Creature;
class BattleStatCalculator {
public:
virtual ~BattleStatCalculator() = default;
virtual Core::StatisticSet<uint32_t > CalculateFlatStats(Creature* creature) const;
virtual Core::StatisticSet<uint32_t > CalculateBoostedStats(Creature* creature) const;
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;
};
}
#endif //CREATURELIB_BATTLESTATCALCULATOR_HPP
#endif // CREATURELIB_BATTLESTATCALCULATOR_HPP

6
src/Battling/Library/CriticalLibrary.cpp
View File

@ -1,9 +1,9 @@
#include "CriticalLibrary.hpp"
#include "../Models/Battle.hpp"
bool CreatureLib::Battling::CriticalLibrary::IsCritical(CreatureLib::Battling::ExecutingAttack *attack,
CreatureLib::Battling::Creature *target, uint8_t hit) const {
bool CreatureLib::Battling::CriticalLibrary::IsCritical(CreatureLib::Battling::ExecutingAttack* attack,
CreatureLib::Battling::Creature* target, uint8_t hit) const {
auto rand = target->GetBattle()->GetRandom();
//HOOK: Increase chance for critical hits.
// HOOK: Increase chance for critical hits.
return rand.Get(10) <= 0;
}

3
src/Battling/Library/CriticalLibrary.hpp
View File

@ -11,5 +11,4 @@ namespace CreatureLib::Battling {
};
}
#endif //CREATURELIB_CRITICALLIBRARY_HPP
#endif // CREATURELIB_CRITICALLIBRARY_HPP

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

@ -1,66 +1,64 @@
#include "DamageLibrary.hpp"
using namespace CreatureLib::Battling;
int DamageLibrary::GetDamage(ExecutingAttack *attack, Creature *target, uint8_t hitIndex) const{
int DamageLibrary::GetDamage(ExecutingAttack* attack, Creature* target, uint8_t hitIndex) const {
auto levelMod = static_cast<float>(2 * attack->GetUser()->GetLevel());
auto hit = attack->GetAttackDataForTarget(target).GetHit(hitIndex);
auto bp = hit.GetBasePower();
auto statMod = GetStatModifier(attack, target, hitIndex);
//HOOK: Modify stat modifier
int damage = static_cast<int>((((levelMod * static_cast<float>(bp) * statMod) / 50) + 2)
* GetDamageModifier(attack, target, hitIndex));
//HOOK: Override damage
// HOOK: Modify stat modifier
int damage = static_cast<int>((((levelMod * static_cast<float>(bp) * statMod) / 50) + 2) *
GetDamageModifier(attack, target, hitIndex));
// HOOK: Override damage
return damage;
}
int DamageLibrary::GetBasePower(ExecutingAttack *attack, Creature *target, uint8_t hitIndex) const{
int DamageLibrary::GetBasePower(ExecutingAttack* attack, Creature* target, uint8_t hitIndex) const {
auto bp = attack->GetAttack()->GetAttack()->GetBasePower();
//HOOK: modify base power.
// HOOK: modify base power.
return bp;
}
float DamageLibrary::GetStatModifier(ExecutingAttack *attack, Creature *target, uint8_t hitIndex) const{
float DamageLibrary::GetStatModifier(ExecutingAttack* attack, Creature* target, uint8_t hitIndex) const {
auto user = attack->GetUser();
//HOOK: allow overriding for which users stat we use.
// HOOK: allow overriding for which users stat we use.
auto hit = attack->GetAttackDataForTarget(target).GetHit(hitIndex);
Core::Statistic offensiveStat;
Core::Statistic defensiveStat;
if (attack->GetAttack()->GetAttack()->GetCategory() == Library::AttackCategory::Physical){
if (attack->GetAttack()->GetAttack()->GetCategory() == Library::AttackCategory::Physical) {
offensiveStat = Core::Statistic::PhysicalAttack;
defensiveStat = Core::Statistic::PhysicalDefense;
}
else{
} else {
offensiveStat = Core::Statistic::MagicalAttack;
defensiveStat = Core::Statistic::MagicalDefense;
}
auto bypassDefensive = hit.IsCritical() && target->GetStatBoost(defensiveStat) > 0;
//HOOK: allow bypassing defensive stat modifiers.
// HOOK: allow bypassing defensive stat modifiers.
auto bypassOffensive = hit.IsCritical() && user->GetStatBoost(offensiveStat) < 0;
//HOOK: Allow bypassing offensive stat modifiers.
// HOOK: Allow bypassing offensive stat modifiers.
float offensiveValue;
float defensiveValue;
if (bypassOffensive){
if (bypassOffensive) {
offensiveValue = user->GetFlatStat(offensiveStat);
} else{
} else {
offensiveValue = user->GetBoostedStat(offensiveStat);
}
if (bypassDefensive){
if (bypassDefensive) {
defensiveValue = target->GetFlatStat(defensiveStat);
} else{
} else {
defensiveValue = target->GetBoostedStat(defensiveStat);
}
return offensiveValue / defensiveValue;
}
float DamageLibrary::GetDamageModifier(ExecutingAttack *attack, Creature *target, uint8_t hitIndex) const{
float DamageLibrary::GetDamageModifier(ExecutingAttack* attack, Creature* target, uint8_t hitIndex) const {
float mod = 1;
auto hit = attack->GetAttackDataForTarget(target).GetHit(hitIndex);
mod *= hit.GetEffectiveness();
//HOOK: Modify damage modifier.
// HOOK: Modify damage modifier.
return mod;
}

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

@ -4,7 +4,7 @@
#include "../Models/Creature.hpp"
#include "../Models/ExecutingAttack.hpp"
namespace CreatureLib::Battling{
namespace CreatureLib::Battling {
class DamageLibrary {
public:
virtual ~DamageLibrary() = default;
@ -16,5 +16,4 @@ namespace CreatureLib::Battling{
};
}
#endif //CREATURELIB_DAMAGELIBRARY_HPP
#endif // CREATURELIB_DAMAGELIBRARY_HPP

7
src/Battling/Models/AttackLearnMethod.hpp
View File

@ -2,10 +2,7 @@
#define CREATURELIB_ATTACKLEARNMETHOD_HPP
namespace CreatureLib::Battling {
enum class AttackLearnMethod {
Unknown,
Level
};
enum class AttackLearnMethod { Unknown, Level };
}
#endif //CREATURELIB_ATTACKLEARNMETHOD_HPP
#endif // CREATURELIB_ATTACKLEARNMETHOD_HPP

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

@ -1,25 +1,22 @@
#include "Battle.hpp"
#include "../Flow/TurnHandler.hpp"
#include "../TurnChoices/AttackTurnChoice.hpp"
#include "../Flow/TurnOrdering.hpp"
#include "../../Core/Exceptions/NotImplementedException.hpp"
#include "../Flow/TurnHandler.hpp"
#include "../Flow/TurnOrdering.hpp"
using namespace CreatureLib;
using namespace CreatureLib::Battling;
const BattleLibrary *Battle::GetLibrary() const {
return _library;
}
const BattleLibrary* Battle::GetLibrary() const { return _library; }
bool Battle::CanUse(const BaseTurnChoice *choice) {
if (choice->GetKind() == TurnChoiceKind::Attack){
//HOOK: change number of uses needed.
bool Battle::CanUse(const BaseTurnChoice* choice) {
if (choice->GetKind() == TurnChoiceKind::Attack) {
// HOOK: change number of uses needed.
return dynamic_cast<const AttackTurnChoice*>(choice)->GetAttack()->GetRemainingUses() > 1;
}
return true;
}
bool Battle::TrySetChoice(BaseTurnChoice *choice) {
bool Battle::TrySetChoice(BaseTurnChoice* choice) {
if (!CanUse(choice))
return false;
choice->GetUser()->GetBattleSide()->SetChoice(choice);
@ -28,24 +25,24 @@ bool Battle::TrySetChoice(BaseTurnChoice *choice) {
}
void Battle::CheckChoicesSetAndRun() {
for (auto side: _sides){
if (!side->AllChoicesSet()){
for (auto side : _sides) {
if (!side->AllChoicesSet()) {
return;
}
}
auto choices = std::vector<BaseTurnChoice*>(_numberOfSides * _creaturesPerSide);
auto i = 0;
for (auto side: _sides){
for (BaseTurnChoice* choice: side->GetChoices()){
if (choice->GetKind() == TurnChoiceKind::Attack){
for (auto side : _sides) {
for (BaseTurnChoice* choice : side->GetChoices()) {
if (choice->GetKind() == TurnChoiceKind::Attack) {
auto attack = dynamic_cast<const AttackTurnChoice*>(choice)->GetAttack();
uint8_t uses = 1;
//HOOK: change number of uses needed.
if (attack->GetRemainingUses() < uses){
//TODO: Implement default move
// HOOK: change number of uses needed.
if (attack->GetRemainingUses() < uses) {
// TODO: Implement default move
throw NotImplementedException("Not enough remaining uses, change to default move.");
}
//HOOK: Check if we need to change the move
// HOOK: Check if we need to change the move
}
choices[i] = choice;
i++;
@ -60,39 +57,31 @@ void Battle::CheckChoicesSetAndRun() {
_currentTurnQueue = nullptr;
}
ChoiceQueue* Battle::GetCurrentTurnQueue() const {
return _currentTurnQueue;
}
ChoiceQueue* Battle::GetCurrentTurnQueue() const { return _currentTurnQueue; }
Core::Random &Battle::GetRandom(){
return _random;
}
Core::Random& Battle::GetRandom() { return _random; }
bool Battle::CreatureInField(const Creature *creature) const {
for (auto s: _sides){
bool Battle::CreatureInField(const Creature* creature) const {
for (auto s : _sides) {
if (s->CreatureOnSide(creature))
return true;
}
return false;
}
bool Battle::HasRecalledSlots() const {
return _numberOfRecalledSlots > 0;
}
bool Battle::HasRecalledSlots() const { return _numberOfRecalledSlots > 0; }
void Battle::ForceRecall(uint8_t side, uint8_t index) {
_numberOfRecalledSlots++;
//TODO: Switch out.
// TODO: Switch out.
}
void Battle::FillRecall(uint8_t side, uint8_t, Creature *c) {
void Battle::FillRecall(uint8_t side, uint8_t, Creature* c) {
_numberOfRecalledSlots--;
//TODO: switch in.
if (_numberOfRecalledSlots == 0 && _currentTurnQueue != nullptr){
// TODO: switch in.
if (_numberOfRecalledSlots == 0 && _currentTurnQueue != nullptr) {
TurnHandler::RunTurn(this, _currentTurnQueue);
}
}
void Battle::GetActiveScripts(std::vector<ScriptWrapper> &scripts) {
scripts.emplace_back(&_volatile);
}
void Battle::GetActiveScripts(std::vector<ScriptWrapper>& scripts) { scripts.emplace_back(&_volatile); }

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

@ -2,14 +2,14 @@
#define CREATURELIB_BATTLE_HPP
#include <vector>
#include "BattleSide.hpp"
#include "../Flow/ChoiceQueue.hpp"
#include "../Library/BattleLibrary.hpp"
#include "../TurnChoices/BaseTurnChoice.hpp"
#include "../Flow/ChoiceQueue.hpp"
#include "BattleSide.hpp"
#include "Target.hpp"
namespace CreatureLib::Battling {
class Battle : public ScriptSource{
class Battle : public ScriptSource {
const BattleLibrary* _library;
uint8_t _numberOfSides;
uint8_t _creaturesPerSide;
@ -19,6 +19,7 @@ namespace CreatureLib::Battling {
uint8_t _numberOfRecalledSlots = 0;
ScriptSet _volatile;
public:
[[nodiscard]] const BattleLibrary* GetLibrary() const;
@ -32,7 +33,7 @@ namespace CreatureLib::Battling {
bool CreatureInField(const Creature* creature) const;
Creature* GetTarget(const Target& target){
Creature* GetTarget(const Target& target) {
return _sides[target.GetSideIndex()]->GetCreature(target.GetCreatureIndex());
}
@ -42,9 +43,8 @@ namespace CreatureLib::Battling {
void FillRecall(uint8_t side, uint8_t, Creature* c);
void GetActiveScripts(std::vector<ScriptWrapper> &scripts) override;
void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override;
};
}
#endif //CREATURELIB_BATTLE_HPP
#endif // CREATURELIB_BATTLE_HPP

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

@ -1,47 +1,39 @@
#include "BattleSide.hpp"
#include "../../Core/Exceptions/CreatureException.hpp"
#include <algorithm>
#include "../../Core/Exceptions/CreatureException.hpp"
#include "Battle.hpp"
using namespace CreatureLib::Battling;
bool BattleSide::AllChoicesSet() const {
return _choicesSet == _creaturesPerSide;
}
bool BattleSide::AllChoicesSet() const { return _choicesSet == _creaturesPerSide; }
void BattleSide::ResetChoices() {
_choicesSet = 0;
for (uint8_t i = 0; i < _creaturesPerSide; i++){
for (uint8_t i = 0; i < _creaturesPerSide; i++) {
_choices[i] = nullptr;
}
}
const std::vector<BaseTurnChoice *>& BattleSide::GetChoices() const{
return _choices;
}
const std::vector<BaseTurnChoice*>& BattleSide::GetChoices() const { return _choices; }
void BattleSide::SetChoice(BaseTurnChoice *choice) {
void BattleSide::SetChoice(BaseTurnChoice* choice) {
auto find = std::find(_creatures.begin(), _creatures.end(), choice->GetUser());
if (find ==_creatures.end())
if (find == _creatures.end())
throw CreatureException("User not found");
uint8_t index = std::distance(_creatures.begin(),find);
uint8_t index = std::distance(_creatures.begin(), find);
_choices[index] = choice;
_choicesSet++;
}
void BattleSide::SetCreature(Creature *creature, uint8_t index) {
_creatures[index] = creature;
}
void BattleSide::SetCreature(Creature* creature, uint8_t index) { _creatures[index] = creature; }
bool BattleSide::CreatureOnSide(const Creature *creature) const {
bool BattleSide::CreatureOnSide(const Creature* creature) const {
return std::find(_creatures.begin(), _creatures.end(), creature) != _creatures.end();
}
Creature *BattleSide::GetCreature(uint8_t index) const {
return _creatures[index];
}
Creature* BattleSide::GetCreature(uint8_t index) const { return _creatures[index]; }
void BattleSide::GetActiveScripts(std::vector<ScriptWrapper> &scripts) {
void BattleSide::GetActiveScripts(std::vector<ScriptWrapper>& scripts) {
scripts.emplace_back(&_volatile);
_battle->GetActiveScripts(scripts);
}

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

@ -2,21 +2,22 @@
#define CREATURELIB_BATTLESIDE_HPP
#include <vector>
#include "Creature.hpp"
#include "../TurnChoices/BaseTurnChoice.hpp"
#include "Creature.hpp"
namespace CreatureLib::Battling{
class BattleSide : public ScriptSource{
namespace CreatureLib::Battling {
class BattleSide : public ScriptSource {
uint8_t _creaturesPerSide;
std::vector<Creature*> _creatures;
std::vector<BaseTurnChoice*> _choices;
uint8_t _choicesSet = 0;
ScriptSet _volatile;
Battle* _battle;
public:
explicit BattleSide(Battle* battle, uint8_t creaturesPerSide)
: _creaturesPerSide(creaturesPerSide), _creatures(creaturesPerSide), _choices(creaturesPerSide), _battle(battle)
{
: _creaturesPerSide(creaturesPerSide), _creatures(creaturesPerSide), _choices(creaturesPerSide),
_battle(battle) {
ResetChoices();
}
@ -31,10 +32,8 @@ namespace CreatureLib::Battling{
Creature* GetCreature(uint8_t index) const;
bool CreatureOnSide(const Creature* creature) const;
void GetActiveScripts(std::vector<ScriptWrapper> &scripts) override;
void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override;
};
}
#endif //CREATURELIB_BATTLESIDE_HPP
#endif // CREATURELIB_BATTLESIDE_HPP

1
src/Battling/Models/BattleTeam.cpp
View File

@ -1 +0,0 @@
#include "BattleTeam.hpp"

10
src/Battling/Models/BattleTeam.hpp
View File

@ -1,10 +0,0 @@
#ifndef CREATURELIB_BATTLETEAM_HPP
#define CREATURELIB_BATTLETEAM_HPP
class BattleTeam {
};
#endif //CREATURELIB_BATTLETEAM_HPP

61
src/Battling/Models/CreateCreature.cpp
View File

@ -1,7 +1,7 @@
#include "CreateCreature.hpp"
#include "../../Core/Exceptions/CreatureException.hpp"
#include "../Library/BattleLibrary.hpp"
#include <utility>
#include "../Library/BattleLibrary.hpp"
using namespace CreatureLib::Battling;
@ -10,24 +10,24 @@ CreateCreature* CreateCreature::WithVariant(std::string variant) {
return this;
}
CreateCreature *CreateCreature::WithNickname(std::string nickname) {
CreateCreature* CreateCreature::WithNickname(std::string nickname) {
this->_nickname = std::move(nickname);
return this;
}
CreateCreature *CreateCreature::WithStatPotential(CreatureLib::Core::Statistic stat, uint32_t value) {
switch (stat){
case Core::Health:_healthPotential = value;
CreateCreature* CreateCreature::WithStatPotential(CreatureLib::Core::Statistic stat, uint32_t value) {
switch (stat) {
case Core::Health: _healthPotential = value;
case Core::PhysicalAttack: _physAttackPotential = value;
case Core::PhysicalDefense: _physDefensePotential = value;
case Core::MagicalAttack: _magAttackPotential = value;
case Core::MagicalDefense:_magDefensePotential = value;
case Core::MagicalDefense: _magDefensePotential = value;
case Core::Speed: _speedPotential = value;
}
return this;
}
CreateCreature * CreateCreature::WithStatPotentials(uint32_t health, uint32_t physAttack, uint32_t physDefense,
CreateCreature* CreateCreature::WithStatPotentials(uint32_t health, uint32_t physAttack, uint32_t physDefense,
uint32_t magAttack, uint32_t magDefense, uint32_t speed) {
_healthPotential = health;
_physAttackPotential = physAttack;
@ -39,20 +39,19 @@ CreateCreature * CreateCreature::WithStatPotentials(uint32_t health, uint32_t ph
}
CreateCreature* CreateCreature::WithStatExperience(Core::Statistic stat, uint32_t value) {
switch (stat){
case Core::Health:_healthExperience = value;
switch (stat) {
case Core::Health: _healthExperience = value;
case Core::PhysicalAttack: _physAttackExperience = value;
case Core::PhysicalDefense: _physDefenseExperience = value;
case Core::MagicalAttack: _magAttackExperience = value;
case Core::MagicalDefense:_magDefenseExperience = value;
case Core::MagicalDefense: _magDefenseExperience = value;
case Core::Speed: _speedExperience = value;
}
return this;
}
CreateCreature *
CreateCreature::WithStatExperiences(uint32_t health, uint32_t physAttack, uint32_t physDefense, uint32_t magAttack,
uint32_t magDefense, uint32_t speed) {
CreateCreature* CreateCreature::WithStatExperiences(uint32_t health, uint32_t physAttack, uint32_t physDefense,
uint32_t magAttack, uint32_t magDefense, uint32_t speed) {
_healthExperience = health;
_physAttackExperience = physAttack;
_physDefenseExperience = physDefense;
@ -62,12 +61,12 @@ CreateCreature::WithStatExperiences(uint32_t health, uint32_t physAttack, uint32
return this;
}
CreateCreature *CreateCreature::WithGender(Library::Gender gender) {
CreateCreature* CreateCreature::WithGender(Library::Gender gender) {
this->_gender = gender;
return this;
}
CreateCreature *CreateCreature::WithAttack(const std::string& attackName, AttackLearnMethod learnMethod) {
CreateCreature* CreateCreature::WithAttack(const std::string& attackName, AttackLearnMethod learnMethod) {
if (_attacks.size() >= _library->GetSettings().GetMaximalMoves())
throw CreatureException("You have already set the maximum amount of allowed moves.");
@ -76,44 +75,42 @@ CreateCreature *CreateCreature::WithAttack(const std::string& attackName, Attack
return this;
}
Creature *CreateCreature::Create() {
Creature* CreateCreature::Create() {
_hasCreated = true;
auto rand = Core::Random();
auto species = this->_library->GetSpeciesLibrary()->GetSpecies(this->_species);
auto variant = species->GetVariant(this->_variant);
int8_t talent;
if (this->_talent.empty()){
if (this->_talent.empty()) {
talent = variant->GetRandomTalent(&rand);
}
else{
} else {
talent = variant->GetTalentIndex(this->_talent);
}
auto identifier = this->_identifier;
if (identifier == 0){
if (identifier == 0) {
identifier = rand.Get();
}
auto gender = this->_gender;
if (gender == static_cast<Library::Gender >(-1)){
if (gender == static_cast<Library::Gender>(-1)) {
gender = species->GetRandomGender(rand);
}
const Library::Item* heldItem = nullptr;
if (!this->_heldItem.empty()){
if (!this->_heldItem.empty()) {
heldItem = _library->GetItemLibrary()->GetItem(this->_heldItem);
}
//FIXME: implement experience
// FIXME: implement experience
auto experience = 0;
auto statExperience = Core::StatisticSet(_healthExperience, _physAttackExperience,_physDefenseExperience, _magAttackExperience,
_magDefenseExperience, _speedExperience);
auto statPotential = Core::StatisticSet(_healthPotential, _physAttackPotential,_physDefensePotential, _magAttackPotential,
_magDefensePotential, _speedPotential);
auto statExperience = Core::StatisticSet(_healthExperience, _physAttackExperience, _physDefenseExperience,
_magAttackExperience, _magDefenseExperience, _speedExperience);
auto statPotential = Core::StatisticSet(_healthPotential, _physAttackPotential, _physDefensePotential,
_magAttackPotential, _magDefensePotential, _speedPotential);
auto attacks = std::vector<LearnedAttack*>(_attacks.size());
for (auto kv: _attacks){
for (auto kv : _attacks) {
attacks.push_back(new LearnedAttack(std::get<0>(kv), std::get<1>(kv)));
}
return new Creature(species, variant, _level, experience, statExperience,statPotential, identifier,gender, _coloring,
heldItem, _nickname, talent, attacks);
return new Creature(species, variant, _level, experience, statExperience, statPotential, identifier, gender,
_coloring, heldItem, _nickname, talent, attacks);
}

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

@ -1,13 +1,12 @@
#ifndef CREATURELIB_CREATECREATURE_HPP
#define CREATURELIB_CREATECREATURE_HPP
#include "../../Library/DataLibrary.hpp"
#include "Creature.hpp"
namespace CreatureLib::Battling {
class CreateCreature {
const BattleLibrary *_library;
const BattleLibrary* _library;
std::string _species;
std::string _variant = "default";
uint8_t _level;
@ -37,26 +36,22 @@ namespace CreatureLib::Battling {
bool _hasCreated;
public:
CreateCreature(const BattleLibrary *library, std::string species, uint8_t level)
: _library(library), _species(std::move(species)), _level(level)
{
}
CreateCreature(const BattleLibrary* library, std::string species, uint8_t level)
: _library(library), _species(std::move(species)), _level(level) {}
CreateCreature* WithVariant(std::string variant);
CreateCreature* WithNickname(std::string nickname);
CreateCreature* WithStatPotential(Core::Statistic stat, uint32_t value);
CreateCreature* WithStatPotentials(uint32_t health, uint32_t physAttack, uint32_t physDefense, uint32_t magAttack,
uint32_t magDefense,uint32_t speed);
CreateCreature* WithStatPotentials(uint32_t health, uint32_t physAttack, uint32_t physDefense,
uint32_t magAttack, uint32_t magDefense, uint32_t speed);
CreateCreature* WithStatExperience(Core::Statistic stat, uint32_t value);
CreateCreature* WithStatExperiences(uint32_t health, uint32_t physAttack, uint32_t physDefense, uint32_t magAttack,
uint32_t magDefense,uint32_t speed);
CreateCreature* WithStatExperiences(uint32_t health, uint32_t physAttack, uint32_t physDefense,
uint32_t magAttack, uint32_t magDefense, uint32_t speed);
CreateCreature* WithGender(Library::Gender gender);
CreateCreature* WithAttack(const std::string& attackName, AttackLearnMethod learnMethod);
Creature* Create();
};
}
#endif //CREATURELIB_CREATECREATURE_HPP
#endif // CREATURELIB_CREATECREATURE_HPP

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

@ -1,6 +1,6 @@
#include "Creature.hpp"
#include <algorithm>
#include <utility>
#include "Creature.hpp"
#include "../Models/Battle.hpp"
using namespace CreatureLib;
@ -8,64 +8,48 @@ using namespace CreatureLib;
Battling::Creature::Creature(const Library::CreatureSpecies* species, const Library::SpeciesVariant* variant,
uint8_t level, uint32_t experience, Core::StatisticSet<uint8_t> statExp,
Core::StatisticSet<uint8_t> statPotential, uint32_t uid, Library::Gender gender,
uint8_t coloring, const Library::Item *heldItem, std::string nickname, int8_t talent,
std::vector<LearnedAttack *> attacks)
:
__Species(species),
__Variant(variant),
__Level(level),
__Experience(experience),
__StatExperience(statExp),
__StatPotential(statPotential),
__UniqueIdentifier(uid),
__Gender(gender),
__Coloring(coloring),
__HeldItem(heldItem),
_nickname(std::move(nickname)),
_talentIndex(talent),
_hasOverridenTalent(false),
_attacks(std::move(attacks))
{
uint8_t coloring, const Library::Item* heldItem, std::string nickname, int8_t talent,
std::vector<LearnedAttack*> attacks)
: __Species(species), __Variant(variant), __Level(level), __Experience(experience), __StatExperience(statExp),
__StatPotential(statPotential), __UniqueIdentifier(uid), __Gender(gender), __Coloring(coloring),
__HeldItem(heldItem), _nickname(std::move(nickname)), _talentIndex(talent), _hasOverridenTalent(false),
_attacks(std::move(attacks)) {
__CurrentHealth = GetBoostedStat(Core::Statistic::Health);
}
void Battling::Creature::ChangeLevel(int8_t amount) {
this->__Level += amount;
RecalculateFlatStats();
}
void Battling::Creature::SetBattle(Battling::Battle *battle) {
this->_battle = battle;
}
void Battling::Creature::SetBattle(Battling::Battle* battle) { this->_battle = battle; }
void Battling::Creature::SetBattleLibrary(Battling::BattleLibrary *library) {
void Battling::Creature::SetBattleLibrary(Battling::BattleLibrary* library) {
this->_library = library;
_activeTalent = _library->LoadScript(ScriptResolver::ScriptCategory::Talent, GetActiveTalent());
}
const std::string &Battling::Creature::GetNickname() const {
const std::string& Battling::Creature::GetNickname() const {
if (_nickname.empty())
return __Species->GetName();
return _nickname;
}
const std::string &Battling::Creature::GetActiveTalent() const {
if (_hasOverridenTalent){
const std::string& Battling::Creature::GetActiveTalent() const {
if (_hasOverridenTalent) {
return _overridenTalentName;
}
return __Variant->GetTalent(_talentIndex);
}
void Battling::Creature::SetBattleData(Battling::Battle *battle, Battling::BattleSide *side) {
void Battling::Creature::SetBattleData(Battling::Battle* battle, Battling::BattleSide* side) {
_battle = battle;
_side = side;
}
//region Stat APIs
// region Stat APIs
void Battling::Creature::ChangeStatBoost(Core::Statistic stat, int8_t diffAmount){
void Battling::Creature::ChangeStatBoost(Core::Statistic stat, int8_t diffAmount) {
if (diffAmount > 0)
this->_statBoost.IncreaseStatBy(stat, diffAmount);
else
@ -73,29 +57,17 @@ 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(Core::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(Core::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(Core::Statistic stat) const { return __Variant->GetStatistic(stat); }
uint32_t Battling::Creature::GetStatPotential(Core::Statistic stat) const {
return __StatPotential.GetStat(stat);
}
uint32_t Battling::Creature::GetStatPotential(Core::Statistic stat) const { return __StatPotential.GetStat(stat); }
uint32_t Battling::Creature::GetStatExperience(Core::Statistic stat) const {
return __StatExperience.GetStat(stat);
}
uint32_t Battling::Creature::GetStatExperience(Core::Statistic stat) const { return __StatExperience.GetStat(stat); }
int8_t Battling::Creature::GetStatBoost(Core::Statistic stat) const {
return _statBoost.GetStat(stat);
}
int8_t Battling::Creature::GetStatBoost(Core::Statistic stat) const { return _statBoost.GetStat(stat); }
void Battling::Creature::RecalculateFlatStats() {
this->_flatStats = this->_library->GetStatCalculator()->CalculateFlatStats(this);
@ -116,36 +88,30 @@ void Battling::Creature::RecalculateBoostedStat(Core::Statistic stat) {
this->_boostedStats.SetStat(stat, s);
}
//endregion
// endregion
Battling::Battle *Battling::Creature::GetBattle() const{
return _battle;
}
Battling::Battle* Battling::Creature::GetBattle() const { return _battle; }
Battling::BattleSide *Battling::Creature::GetBattleSide() const {
return _side;
}
Battling::BattleSide* Battling::Creature::GetBattleSide() const { return _side; }
bool Battling::Creature::IsFainted() const {
return this->__CurrentHealth <= 0;
}
bool Battling::Creature::IsFainted() const { return this->__CurrentHealth <= 0; }
void Battling::Creature::Damage(uint32_t damage, Battling::DamageSource source) {
if (damage > __CurrentHealth){
if (damage > __CurrentHealth) {
damage = __CurrentHealth;
}
// HOOK: On Damage
__CurrentHealth -= damage;
}
void Battling::Creature::OverrideActiveTalent(const std::string& talent){
void Battling::Creature::OverrideActiveTalent(const std::string& talent) {
_hasOverridenTalent = true;
_overridenTalentName = talent;
_activeTalent = this->_library->LoadScript(ScriptResolver::ScriptCategory::Talent, talent);
}
const std::vector<uint8_t>& Battling::Creature::GetTypes() const {
//HOOK: override types.
// HOOK: override types.
return this->__Variant->GetTypes();
}
@ -154,7 +120,7 @@ bool Battling::Creature::HasType(uint8_t type) const {
return std::find(t.begin(), t.end(), type) != t.end();
}
void Battling::Creature::GetActiveScripts(std::vector<ScriptWrapper> &scripts) {
void Battling::Creature::GetActiveScripts(std::vector<ScriptWrapper>& scripts) {
scripts.emplace_back(&_activeTalent);
scripts.emplace_back(&_status);
scripts.emplace_back(&_volatile);

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

@ -4,37 +4,36 @@
#include "../../GenericTemplates.cpp"
#include "../../Library/CreatureData/CreatureSpecies.hpp"
#include "../../Library/Items/Item.hpp"
#include "LearnedAttack.hpp"
#include "DamageSource.hpp"
#include "../ScriptHandling/ScriptSet.hpp"
#include "../ScriptHandling/ScriptAggregator.hpp"
#include "../ScriptHandling/ScriptSet.hpp"
#include "../ScriptHandling/ScriptSource.hpp"
#include "DamageSource.hpp"
#include "LearnedAttack.hpp"
namespace CreatureLib::Battling{
namespace CreatureLib::Battling {
// Forward declare battle class
class Battle;
class BattleSide;
class BattleLibrary;
class Creature : public ScriptSource{
class Creature : public ScriptSource {
GetProperty(const Library::CreatureSpecies*, Species);
GetProperty(const Library::SpeciesVariant*, Variant)
GetProperty(const Library::SpeciesVariant*, Variant);
GetProperty(uint8_t, Level);
GetProperty(uint32_t, Experience);
GetProperty(Core::StatisticSet<uint8_t >, StatExperience);
GetProperty(Core::StatisticSet<uint8_t >, StatPotential);
GetProperty(Core::StatisticSet<uint8_t>, StatExperience);
GetProperty(Core::StatisticSet<uint8_t>, StatPotential);
GetProperty(uint32_t, UniqueIdentifier);
GetProperty(Library::Gender, Gender);
GetProperty(uint8_t, Coloring);
GetProperty(const Library::Item*, HeldItem);
GetProperty(uint32_t, CurrentHealth);
private:
Core::StatisticSet<int8_t > _statBoost;
Core::StatisticSet<uint32_t > _flatStats;
Core::StatisticSet<uint32_t > _boostedStats;
Core::StatisticSet<int8_t> _statBoost;
Core::StatisticSet<uint32_t> _flatStats;
Core::StatisticSet<uint32_t> _boostedStats;
Battle* _battle;
BattleSide* _side;
@ -54,9 +53,9 @@ namespace CreatureLib::Battling{
public:
Creature(const Library::CreatureSpecies* species, const Library::SpeciesVariant* variant, uint8_t level,
uint32_t experience, Core::StatisticSet<uint8_t > statExp, Core::StatisticSet<uint8_t > statPotential,
uint32_t uid, Library::Gender gender, uint8_t coloring, const Library::Item* heldItem, std::string nickname,
int8_t talent, std::vector<LearnedAttack*> attacks);
uint32_t experience, Core::StatisticSet<uint8_t> statExp, Core::StatisticSet<uint8_t> statPotential,
uint32_t uid, Library::Gender gender, uint8_t coloring, const Library::Item* heldItem,
std::string nickname, int8_t talent, std::vector<LearnedAttack*> attacks);
virtual ~Creature() = default;
@ -75,10 +74,9 @@ namespace CreatureLib::Battling{
void Damage(uint32_t damage, DamageSource source);
void OverrideActiveTalent(const std::string& talent);
void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override;
void GetActiveScripts(std::vector<ScriptWrapper> &scripts) override;
//region Stat APIs
// region Stat APIs
void SetBattle(Battle* battle);
void SetBattleLibrary(BattleLibrary* library);
@ -95,11 +93,8 @@ namespace CreatureLib::Battling{
void RecalculateFlatStat(Core::Statistic);
void RecalculateBoostedStat(Core::Statistic);
//endregion
// endregion
};
}
#endif //CREATURELIB_CREATURE_HPP
#endif // CREATURELIB_CREATURE_HPP

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

@ -4,29 +4,27 @@
#include <array>
#include "Creature.hpp"
namespace CreatureLib::Battling{
template <int max>
class CreatureParty {
namespace CreatureLib::Battling {
template <int max> class CreatureParty {
std::array<Creature*, max> _party;
public:
CreatureParty(std::array<Creature*, max> party) : _party(party){
}
CreatureParty(std::array<Creature*, max> party) : _party(party) {}
Creature* GetAtIndex(int index) const{
return _party[index];
}
Creature* GetAtIndex(int index) const { return _party[index]; }
void Switch(int a, int b){
void Switch(int a, int b) {
auto ca = _party[a];
_party[a] = _party[b];
_party[b] = ca;
}
bool HasAvailableCreatures() const{
for (Creature* c: _party){
if (c == nullptr) continue;
if (c->IsFainted()) continue;
bool HasAvailableCreatures() const {
for (Creature* c : _party) {
if (c == nullptr)
continue;
if (c->IsFainted())
continue;
return true;
}
return false;
@ -34,5 +32,4 @@ namespace CreatureLib::Battling{
};
}
#endif //CREATURELIB_CREATUREPARTY_HPP
#endif // CREATURELIB_CREATUREPARTY_HPP

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

@ -9,4 +9,4 @@ namespace CreatureLib::Battling {
};
}
#endif //CREATURELIB_DAMAGESOURCE_HPP
#endif // CREATURELIB_DAMAGESOURCE_HPP

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

@ -2,63 +2,55 @@
#define CREATURELIB_EXECUTINGATTACK_HPP
#include <cstdint>
#include <vector>
#include <unordered_map>
#include <vector>
#include "Creature.hpp"
namespace CreatureLib::Battling {
class ExecutingAttack : public ScriptSource {
public:
class HitData{
class HitData {
bool _critical = false;
uint8_t _basePower = 0;
float _effectiveness = 1;
uint32_t _damage = 0;
uint8_t _type = 0;
public:
HitData(){}
HitData() {}
[[nodiscard]] inline bool IsCritical() const{ return _critical;}
[[nodiscard]] inline uint8_t GetBasePower() const{ return _basePower;}
[[nodiscard]] inline float GetEffectiveness() const{ return _effectiveness;}
[[nodiscard]] inline uint32_t GetDamage() const{ return _damage;}
[[nodiscard]] inline uint8_t GetType() const {return _type;}
[[nodiscard]] inline bool IsCritical() const { return _critical; }
[[nodiscard]] inline uint8_t GetBasePower() const { return _basePower; }
[[nodiscard]] inline float GetEffectiveness() const { return _effectiveness; }
[[nodiscard]] inline uint32_t GetDamage() const { return _damage; }
[[nodiscard]] inline uint8_t GetType() const { return _type; }
inline void SetCritical(bool value) {_critical = value;}
inline void SetCritical(bool value) { _critical = value; }
inline void SetBasePower(uint8_t value) { _basePower = value; }
inline void SetEffectiveness(float value) {_effectiveness = value;}
inline void SetDamage(uint32_t value) { _damage = value;}
inline void SetType(uint8_t value) {_type = value;}
inline void SetEffectiveness(float value) { _effectiveness = value; }
inline void SetDamage(uint32_t value) { _damage = value; }
inline void SetType(uint8_t value) { _type = value; }
};
class TargetData {
bool _isHit = true;
std::vector<HitData> _hits;
public:
explicit TargetData(uint8_t numberOfHits) : _hits(numberOfHits)
{
for (uint8_t i = 0; i < numberOfHits; i++){
explicit TargetData(uint8_t numberOfHits) : _hits(numberOfHits) {
for (uint8_t i = 0; i < numberOfHits; i++) {
_hits[i] = HitData();
}
}
TargetData()= default;
TargetData() = default;
const HitData& GetHit(uint8_t index) const{
return _hits[index];
}
const HitData& GetHit(uint8_t index) const { return _hits[index]; }
HitData* GetHitPtr(uint8_t index){
return &_hits[index];
}
HitData* GetHitPtr(uint8_t index) { return &_hits[index]; }
uint8_t GetNumberOfHits() const{
return _hits.size();
}
bool IsHit() const{
return _isHit;
}
uint8_t GetNumberOfHits() const { return _hits.size(); }
bool IsHit() const { return _isHit; }
};
private:
@ -66,45 +58,35 @@ namespace CreatureLib::Battling {
Creature* _user;
LearnedAttack* _attack;
Script* _script;
public:
ExecutingAttack(const std::vector<Creature*>& targets, uint8_t numberHits, Creature* user, LearnedAttack* attack,
Script* script)
: _user(user), _attack(attack), _script(script)
{
ExecutingAttack(const std::vector<Creature*>& targets, uint8_t numberHits, Creature* user,
LearnedAttack* attack, Script* script)
: _user(user), _attack(attack), _script(script) {
_targets.reserve(targets.size());
for (auto target: targets){
for (auto target : targets) {
_targets.insert({target, TargetData(numberHits)});
}
}
virtual ~ExecutingAttack() = default;
TargetData& GetAttackDataForTarget(Creature* creature){
return _targets[creature];
}
TargetData& GetAttackDataForTarget(Creature* creature) { return _targets[creature]; }
bool IsCreatureTarget(Creature* creature){
return _targets.find(creature) != _targets.end();
}
bool IsCreatureTarget(Creature* creature) { return _targets.find(creature) != _targets.end(); }
const std::unordered_map<Creature*, TargetData>& GetTargets(){
return _targets;
}
const std::unordered_map<Creature*, TargetData>& GetTargets() { return _targets; }
Creature* GetUser(){
return _user;
}
Creature* GetUser() { return _user; }
LearnedAttack* GetAttack(){
return _attack;
}
LearnedAttack* GetAttack() { return _attack; }
protected:
void GetActiveScripts(std::vector<ScriptWrapper> &scripts) override {
void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override {
scripts.emplace_back(&_script);
GetUser()->GetActiveScripts(scripts);
}
};
}
#endif //CREATURELIB_EXECUTINGATTACK_HPP
#endif // CREATURELIB_EXECUTINGATTACK_HPP

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

@ -1,48 +1,32 @@
#include "LearnedAttack.hpp"
CreatureLib::Battling::LearnedAttack::LearnedAttack(CreatureLib::Library::AttackData *attack, uint8_t maxUses, AttackLearnMethod learnMethod)
:_attack(attack), _maxUses(maxUses), _remainingUses(maxUses), _learnMethod(learnMethod)
{
CreatureLib::Battling::LearnedAttack::LearnedAttack(CreatureLib::Library::AttackData* attack, uint8_t maxUses,
AttackLearnMethod learnMethod)
: _attack(attack), _maxUses(maxUses), _remainingUses(maxUses), _learnMethod(learnMethod) {}
}
CreatureLib::Battling::LearnedAttack::LearnedAttack(const CreatureLib::Library::AttackData* attack,
AttackLearnMethod learnMethod)
: _attack(attack), _maxUses(attack->GetBaseUsages()), _remainingUses(_maxUses), _learnMethod(learnMethod) {}
CreatureLib::Battling::LearnedAttack::LearnedAttack(const CreatureLib::Library::AttackData *attack, AttackLearnMethod learnMethod)
: _attack(attack), _maxUses(attack->GetBaseUsages()), _remainingUses(_maxUses), _learnMethod(learnMethod)
{}
const CreatureLib::Library::AttackData* CreatureLib::Battling::LearnedAttack::GetAttack() const { return _attack; }
uint8_t CreatureLib::Battling::LearnedAttack::GetMaxUses() const { return _maxUses; }
const CreatureLib::Library::AttackData *CreatureLib::Battling::LearnedAttack::GetAttack() const {
return _attack;
}
uint8_t CreatureLib::Battling::LearnedAttack::GetMaxUses() const {
return _maxUses;
}
uint8_t CreatureLib::Battling::LearnedAttack::GetRemainingUses() const {
return _remainingUses;
}
uint8_t CreatureLib::Battling::LearnedAttack::GetRemainingUses() const { return _remainingUses; }
CreatureLib::Battling::AttackLearnMethod CreatureLib::Battling::LearnedAttack::GetLearnMethod() const {
return _learnMethod;
}
bool CreatureLib::Battling::LearnedAttack::TryUse(uint8_t uses) {
if (uses > _remainingUses) return false;
if (uses > _remainingUses)
return false;
_remainingUses -= uses;
return true;
}
void CreatureLib::Battling::LearnedAttack::DecreaseUses(uint8_t amount) {
_remainingUses -= amount;
}
void CreatureLib::Battling::LearnedAttack::DecreaseUses(uint8_t amount) { _remainingUses -= amount; }
void CreatureLib::Battling::LearnedAttack::RestoreUses(uint8_t amount) {
_remainingUses += amount;
}
void CreatureLib::Battling::LearnedAttack::RestoreUses() {
_remainingUses = _maxUses;
}
void CreatureLib::Battling::LearnedAttack::RestoreUses(uint8_t amount) { _remainingUses += amount; }
void CreatureLib::Battling::LearnedAttack::RestoreUses() { _remainingUses = _maxUses; }

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

@ -4,12 +4,13 @@
#include "../../Library/Attacks/AttackData.hpp"
#include "AttackLearnMethod.hpp"
namespace CreatureLib::Battling{
namespace CreatureLib::Battling {
class LearnedAttack {
const Library::AttackData* _attack;
uint8_t _maxUses;
uint8_t _remainingUses;
AttackLearnMethod _learnMethod;
public:
LearnedAttack(Library::AttackData* attack, uint8_t maxUses, AttackLearnMethod learnMethod);
LearnedAttack(const Library::AttackData* attack, AttackLearnMethod learnMethod);
@ -26,5 +27,4 @@ namespace CreatureLib::Battling{
};
}
#endif //CREATURELIB_LEARNEDATTACK_HPP
#endif // CREATURELIB_LEARNEDATTACK_HPP

13
src/Battling/Models/Target.hpp
View File

@ -8,17 +8,14 @@ namespace CreatureLib::Battling {
class Target {
uint8_t _side;
uint8_t _creature;
public:
Target(uint8_t side, uint8_t creature) : _side(side), _creature(creature){}
Target(uint8_t side, uint8_t creature) : _side(side), _creature(creature) {}
uint8_t GetSideIndex() const{
return _side;
}
uint8_t GetSideIndex() const { return _side; }
uint8_t GetCreatureIndex() const{
return _creature;
}
uint8_t GetCreatureIndex() const { return _creature; }
};
}
#endif //CREATURELIB_TARGET_HPP
#endif // CREATURELIB_TARGET_HPP

19
src/Battling/ScriptHandling/Script.hpp
View File

@ -6,43 +6,42 @@
#include <utility>
#include <vector>
namespace CreatureLib::Battling{
namespace CreatureLib::Battling {
class BaseTurnChoice;
class AttackTurnChoice;
class ExecutingAttack;
class Creature;
class Script{
class Script {
const std::string _name;
public:
explicit Script(std::string name) :_name(std::move(name)){}
explicit Script(std::string name) : _name(std::move(name)) {}
virtual ~Script() = default;
virtual void Stack(){};
const std::string& GetName(){
return _name;
}
const std::string& GetName() { return _name; }
virtual void OnBeforeTurn(const BaseTurnChoice* choice){};
virtual void ChangeAttack(AttackTurnChoice* choice, std::string& attack){};
virtual void PreventAttack(ExecutingAttack* attack,bool& result){};
virtual void PreventAttack(ExecutingAttack* attack, bool& result){};
virtual void FailAttack(ExecutingAttack* attack, bool& failed){};
virtual void StopBeforeAttack(ExecutingAttack* attack){};
virtual void OnBeforeAttack(ExecutingAttack* attack){};
virtual void FailIncomingAttack(ExecutingAttack* attack, Creature* target, bool& result){};
virtual void IsInvulnerable(ExecutingAttack* attack, Creature* target , bool& result){};
virtual void IsInvulnerable(ExecutingAttack* attack, Creature* target, bool& result){};
virtual void OnAttackMiss(ExecutingAttack* attack, Creature* target){};
virtual void ChangeAttackType(ExecutingAttack* attack, Creature* target, uint8_t hitNumber, uint8_t& type){};
virtual void OnStatusMove(const ExecutingAttack* attack, Creature* target, uint8_t hitNumber){};
virtual void PreventSecondaryEffects(const ExecutingAttack* attack, Creature* target, uint8_t hitNumber, bool& result){};
virtual void PreventSecondaryEffects(const ExecutingAttack* attack, Creature* target, uint8_t hitNumber,
bool& result){};
virtual void OnSecondaryEffect(const ExecutingAttack* attack, Creature* target, uint8_t hitNumber){};
virtual void OnAfterHits(const ExecutingAttack* attack, Creature* target){};
};
}
#endif //CREATURELIB_SCRIPT_HPP
#endif // CREATURELIB_SCRIPT_HPP

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

@ -3,36 +3,34 @@
#include <any>
#include <queue>
#include "../../Core/Exceptions/NotReachableException.hpp"
#include "Script.hpp"
#include "ScriptSet.hpp"
#include "../../Core/Exceptions/NotReachableException.hpp"
#include "ScriptWrapper.hpp"
namespace CreatureLib::Battling{
class ScriptAggregator{
namespace CreatureLib::Battling {
class ScriptAggregator {
std::vector<ScriptWrapper> _scripts;
int _index = 0;
bool _isSetSet = false;
const std::vector<Script*>* _setScripts;
int _setIndex;
public:
ScriptAggregator(std::vector<ScriptWrapper> scripts) : _scripts(std::move(scripts)){
};
ScriptAggregator(std::vector<ScriptWrapper> scripts) : _scripts(std::move(scripts)){};
bool HasNext(){
return _index < _scripts.size() || (_isSetSet && _setIndex < _setScripts->size());
}
bool HasNext() { return _index < _scripts.size() || (_isSetSet && _setIndex < _setScripts->size()); }
Script* GetNext(){
Script* GetNext() {
// We can probably do this in a cleaner version once C++ 20 drops with Coroutine support.
if (_isSetSet){
if (_setIndex >= _setScripts->size()){
if (_isSetSet) {
if (_setIndex >= _setScripts->size()) {
_isSetSet = false;
return GetNext();
}
auto s = _setScripts->at(_setIndex);
_setIndex++;
if (_setIndex >= _setScripts->size()){
if (_setIndex >= _setScripts->size()) {
_isSetSet = false;
}
return s;
@ -41,13 +39,12 @@ namespace CreatureLib::Battling{
return nullptr;
auto next = _scripts[_index];
_index++;
if (!next.IsSet()){
if (!next.IsSet()) {
auto scriptPtr = next.GetScript();
if (scriptPtr == nullptr)
return GetNext();
return *scriptPtr;
}
else{
} else {
auto set = next.GetScriptSet();
if (set->Count() == 0)
return GetNext();
@ -61,4 +58,4 @@ namespace CreatureLib::Battling{
};
}
#endif //CREATURELIB_SCRIPTAGGREGATOR_HPP
#endif // CREATURELIB_SCRIPTAGGREGATOR_HPP

21
src/Battling/ScriptHandling/ScriptMacros.cpp
View File

@ -1,11 +1,10 @@
#define HOOK(hookName, source, ... ) \
{ \
auto aggregator = source -> GetScriptIterator(); \
while (aggregator.HasNext()){ \
auto next = aggregator.GetNext(); \
if (next == nullptr) continue; \
next->hookName(__VA_ARGS__); \
} \
}
#define HOOK(hookName, source, ...) \
{ \
auto aggregator = source->GetScriptIterator(); \
while (aggregator.HasNext()) { \
auto next = aggregator.GetNext(); \
if (next == nullptr) \
continue; \
next->hookName(__VA_ARGS__); \
} \
}

2
src/Battling/ScriptHandling/ScriptResolver.cpp
View File

@ -1,3 +1 @@
#include "ScriptResolver.hpp"

11
src/Battling/ScriptHandling/ScriptResolver.hpp
View File

@ -4,12 +4,12 @@
#include <string>
#include "Script.hpp"
namespace CreatureLib::Battling{
namespace CreatureLib::Battling {
class ScriptResolver {
public:
virtual ~ScriptResolver() = default;
enum class ScriptCategory{
enum class ScriptCategory {
Attack,
Talent,
Status,
@ -19,11 +19,8 @@ namespace CreatureLib::Battling{
};
virtual Script* LoadScript(ScriptCategory category, const std::string& scriptName){
return nullptr;
};
virtual Script* LoadScript(ScriptCategory category, const std::string& scriptName) { return nullptr; };
};
}
#endif //CREATURELIB_SCRIPTRESOLVER_HPP
#endif // CREATURELIB_SCRIPTRESOLVER_HPP

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

@ -5,14 +5,15 @@
#include <unordered_map>
#include "Script.hpp"
namespace CreatureLib::Battling{
class ScriptSet{
namespace CreatureLib::Battling {
class ScriptSet {
std::vector<Script*> _scripts;
std::unordered_map<std::string, size_t> _lookup;
public:
void Add(Script* script){
void Add(Script* script) {
auto f = _lookup.find(script->GetName());
if (f != _lookup.end()){
if (f != _lookup.end()) {
_scripts[f.operator*().second]->Stack();
return;
}
@ -20,22 +21,18 @@ namespace CreatureLib::Battling{
_lookup.insert({script->GetName(), _scripts.size() - 1});
}
void Remove(const std::string& key){
void Remove(const std::string& key) {
auto find = _lookup.find(key);
if (find != _lookup.end()){
if (find != _lookup.end()) {
_scripts.erase(_scripts.begin() + find.operator*().second);
_lookup.erase(key);
}
}
size_t Count() const{
return _scripts.size();
}
size_t Count() const { return _scripts.size(); }
const std::vector<Script *> * GetIterator() const{
return &_scripts;
}
const std::vector<Script*>* GetIterator() const { return &_scripts; }
};
}
#endif //CREATURELIB_SCRIPTSET_HPP
#endif // CREATURELIB_SCRIPTSET_HPP

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

@ -5,15 +5,17 @@
#include "ScriptAggregator.hpp"
namespace CreatureLib::Battling{
namespace CreatureLib::Battling {
class ScriptSource {
bool _areScriptsInitialized = false;
std::vector<ScriptWrapper> _scripts;
protected:
virtual void GetActiveScripts(std::vector<ScriptWrapper>& scripts) = 0;
public:
ScriptAggregator GetScriptIterator(){
if (!_areScriptsInitialized){
ScriptAggregator GetScriptIterator() {
if (!_areScriptsInitialized) {
GetActiveScripts(_scripts);
_areScriptsInitialized = true;
}
@ -22,4 +24,4 @@ namespace CreatureLib::Battling{
};
}
#endif //CREATURELIB_SCRIPTSOURCE_HPP
#endif // CREATURELIB_SCRIPTSOURCE_HPP

2
src/Battling/ScriptHandling/ScriptWrapper.cpp
View File

@ -1,3 +1 @@
#include "ScriptWrapper.hpp"

24
src/Battling/ScriptHandling/ScriptWrapper.hpp
View File

@ -1,5 +1,3 @@
#ifndef CREATURELIB_SCRIPTWRAPPER_HPP
#define CREATURELIB_SCRIPTWRAPPER_HPP
@ -7,27 +5,21 @@
#include "Script.hpp"
#include "ScriptSet.hpp"
namespace CreatureLib::Battling{
namespace CreatureLib::Battling {
class ScriptWrapper {
std::variant<Script**, ScriptSet*> _value;
bool _isSet;
public:
ScriptWrapper(Script** s) : _value(s), _isSet(false){}
ScriptWrapper(ScriptSet* s) : _value(s), _isSet(true){}
ScriptWrapper(Script** s) : _value(s), _isSet(false) {}
ScriptWrapper(ScriptSet* s) : _value(s), _isSet(true) {}
bool IsSet() const{
return _isSet;
}
bool IsSet() const { return _isSet; }
Script** GetScript() const{
return std::get<Script**>(_value);
}
Script** GetScript() const { return std::get<Script**>(_value); }
ScriptSet* GetScriptSet() const{
return std::get<ScriptSet*>(_value);
}
ScriptSet* GetScriptSet() const { return std::get<ScriptSet*>(_value); }
};
}
#endif //CREATURELIB_SCRIPTWRAPPER_HPP
#endif // CREATURELIB_SCRIPTWRAPPER_HPP

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

@ -1,48 +1,39 @@
#ifndef CREATURELIB_ATTACKTURNCHOICE_HPP
#define CREATURELIB_ATTACKTURNCHOICE_HPP
#include "BaseTurnChoice.hpp"
#include "../Models/LearnedAttack.hpp"
#include "../Models/Target.hpp"
#include "BaseTurnChoice.hpp"
namespace CreatureLib::Battling{
namespace CreatureLib::Battling {
class AttackTurnChoice : public BaseTurnChoice {
LearnedAttack* _attack;
Target _target;
Script* _attackScript;
public:
AttackTurnChoice(Creature* user, LearnedAttack* attack, const Target& target)
: BaseTurnChoice(user), _attack(attack), _target(target){}
: BaseTurnChoice(user), _attack(attack), _target(target) {}
inline LearnedAttack* GetAttack() const{
return _attack;
}
inline LearnedAttack* GetAttack() const { return _attack; }
TurnChoiceKind GetKind() const override {
return TurnChoiceKind ::Attack;
}
TurnChoiceKind GetKind() const override { return TurnChoiceKind ::Attack; }
int8_t GetPriority() const{
//HOOK: Change priority
int8_t GetPriority() const {
// HOOK: Change priority
return _attack->GetAttack()->GetPriority();
}
const Target& GetTarget() const{
return _target;
}
const Target& GetTarget() const { return _target; }
Script* GetAttackScript(){
return _attackScript;
}
Script* GetAttackScript() { return _attackScript; }
protected:
void GetActiveScripts(std::vector<ScriptWrapper> &scripts) override {
void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override {
scripts.emplace_back(&_attackScript);
GetUser()->GetActiveScripts(scripts);
}
};
}
#endif //CREATURELIB_ATTACKTURNCHOICE_HPP
#endif // CREATURELIB_ATTACKTURNCHOICE_HPP

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

@ -1,24 +1,23 @@
#ifndef CREATURELIB_BASETURNCHOICE_HPP
#define CREATURELIB_BASETURNCHOICE_HPP
#include "TurnChoiceKind.hpp"
#include "../ScriptHandling/ScriptSource.hpp"
#include "TurnChoiceKind.hpp"
namespace CreatureLib::Battling{
namespace CreatureLib::Battling {
class Creature;
class BaseTurnChoice : public ScriptSource {
Creature* _user;
protected:
BaseTurnChoice(Creature* user) : _user(user){};
public:
virtual ~BaseTurnChoice() = default;
[[nodiscard]] virtual TurnChoiceKind GetKind() const = 0;
[[nodiscard]] inline Creature* GetUser() const{
return _user;
}
[[nodiscard]] inline Creature* GetUser() const { return _user; }
};
}
#endif //CREATURELIB_BASETURNCHOICE_HPP
#endif // CREATURELIB_BASETURNCHOICE_HPP

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

@ -4,19 +4,15 @@
#include "BaseTurnChoice.hpp"
namespace CreatureLib::Battling {
class PassTurnChoice : public BaseTurnChoice{
class PassTurnChoice : public BaseTurnChoice {
public:
PassTurnChoice(Creature* c) : BaseTurnChoice(c){}
PassTurnChoice(Creature* c) : BaseTurnChoice(c) {}
TurnChoiceKind GetKind() const override {
return TurnChoiceKind ::Pass;
}
TurnChoiceKind GetKind() const override { return TurnChoiceKind ::Pass; }
protected:
void GetActiveScripts(std::vector<ScriptWrapper> &scripts) override {
GetUser()->GetActiveScripts(scripts);
}
void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override { GetUser()->GetActiveScripts(scripts); }
};
}
#endif //CREATURELIB_PASSTURNCHOICE_HPP
#endif // CREATURELIB_PASSTURNCHOICE_HPP

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

@ -4,12 +4,6 @@
#include <cstdint>
namespace CreatureLib::Battling {
enum class TurnChoiceKind : uint8_t {
Pass,
Attack,
Item,
Switch,
RunAway
};
enum class TurnChoiceKind : uint8_t { Pass, Attack, Item, Switch, RunAway };
}
#endif //CREATURELIB_TURNCHOICEKIND_HPP
#endif // CREATURELIB_TURNCHOICEKIND_HPP

14
src/Core/Exceptions/CreatureException.hpp
View File

@ -4,15 +4,13 @@
#include <exception>
#include <string>
class CreatureException : std::exception{
class CreatureException : std::exception {
std::string _error;
public:
CreatureException(std::string error){}
const char *what() const noexcept override {
return _error.c_str();
}
public:
CreatureException(std::string error) {}
const char* what() const noexcept override { return _error.c_str(); }
};
#endif //CREATURELIB_CREATUREEXCEPTION_HPP
#endif // CREATURELIB_CREATUREEXCEPTION_HPP

8
src/Core/Exceptions/NotImplementedException.hpp
View File

@ -3,10 +3,10 @@
#include "CreatureException.hpp"
class NotImplementedException : CreatureException{
class NotImplementedException : CreatureException {
public:
NotImplementedException(std::string error) : CreatureException(error){}
NotImplementedException() : CreatureException("Not Implemented"){}
NotImplementedException(std::string error) : CreatureException(error) {}
NotImplementedException() : CreatureException("Not Implemented") {}
};
#endif //CREATURELIB_NOTIMPLEMENTEDEXCEPTION_HPP
#endif // CREATURELIB_NOTIMPLEMENTEDEXCEPTION_HPP

4
src/Core/Exceptions/NotReachableException.hpp
View File

@ -3,9 +3,9 @@
#include "CreatureException.hpp"
class NotReachableException : CreatureException{
class NotReachableException : CreatureException {
public:
NotReachableException() : CreatureException("Not Reachable"){};
};
#endif //CREATURELIB_NOTREACHABLEEXCEPTION_HPP
#endif // CREATURELIB_NOTREACHABLEEXCEPTION_HPP

14
src/Core/Random.cpp
View File

@ -2,7 +2,8 @@
#include <limits>
// Seed parameterless constructor with current milliseconds since epoch.
CreatureLib::Core::Random::Random() : _rng(std::mt19937(duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count())){}
CreatureLib::Core::Random::Random()
: _rng(std::mt19937(duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count())) {}
float CreatureLib::Core::Random::GetFloat() {
return static_cast<float>(_rng()) / (static_cast<float>(std::mt19937::max() - std::mt19937::min()) - 0.5f);
@ -13,18 +14,13 @@ double CreatureLib::Core::Random::GetDouble() {
}
int32_t CreatureLib::Core::Random::Get() {
return static_cast<int32_t >(GetDouble() * static_cast<float>(std::numeric_limits<int32_t >::max()));
return static_cast<int32_t>(GetDouble() * static_cast<float>(std::numeric_limits<int32_t>::max()));
}
int32_t CreatureLib::Core::Random::Get(int32_t max) {
return static_cast<int32_t >(GetDouble() * static_cast<float>(max));
return static_cast<int32_t>(GetDouble() * static_cast<float>(max));
}
int32_t CreatureLib::Core::Random::Get(int32_t min, int32_t max) {
return static_cast<int32_t >(GetDouble() * static_cast<float>(max - min) + min);
return static_cast<int32_t>(GetDouble() * static_cast<float>(max - min) + min);
}

5
src/Core/Random.hpp
View File

@ -1,13 +1,14 @@
#ifndef CREATURELIB_RANDOM_HPP
#define CREATURELIB_RANDOM_HPP
#include <cstdint>
#include <chrono>
#include <cstdint>
#include <random>
using namespace std::chrono;
namespace CreatureLib::Core {
class Random {
private:
std::mt19937 _rng;
public:
Random();
explicit Random(int32_t seed) : _rng(seed){};
@ -20,4 +21,4 @@ namespace CreatureLib::Core {
};
}
#endif //CREATURELIB_RANDOM_HPP
#endif // CREATURELIB_RANDOM_HPP

4
src/Core/Statistic.hpp
View File

@ -3,7 +3,7 @@
#include <cstdint>
namespace CreatureLib::Core{
namespace CreatureLib::Core {
enum Statistic : uint8_t {
Health,
PhysicalAttack,
@ -14,4 +14,4 @@ namespace CreatureLib::Core{
};
}
#endif //CREATURELIB_STATISTIC_HPP
#endif // CREATURELIB_STATISTIC_HPP

45
src/Core/StatisticSet.hpp
View File

@ -1,12 +1,12 @@
#ifndef CREATURELIB_STATISTICSET_HPP
#define CREATURELIB_STATISTICSET_HPP
#include <stdint.h>
#include <exception>
#include "Statistic.hpp"
#include <stdint.h>
#include "../GenericTemplates.cpp"
#include "Exceptions/NotReachableException.hpp"
#include "Statistic.hpp"
namespace CreatureLib::Core{
namespace CreatureLib::Core {
template <class T>
class StatisticSet {
protected:
@ -16,25 +16,23 @@ namespace CreatureLib::Core{
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){}
: _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)
{}
: _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; }
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){
[[nodiscard]] inline T GetStat(Statistic stat) const {
switch (stat) {
case Health: return _health;
case PhysicalAttack: return _physicalAttack;
case PhysicalDefense: return _physicalDefense;
@ -45,8 +43,8 @@ namespace CreatureLib::Core{
throw NotReachableException();
}
inline void SetStat(Statistic stat, T value){
switch (stat){
inline void SetStat(Statistic stat, T value) {
switch (stat) {
case Health: _health = value;
case PhysicalAttack: _physicalAttack = value;
case PhysicalDefense: _physicalDefense = value;
@ -57,8 +55,8 @@ namespace CreatureLib::Core{
throw NotReachableException();
}
inline void IncreaseStatBy(Statistic stat, T amount){
switch (stat){
inline void IncreaseStatBy(Statistic stat, T amount) {
switch (stat) {
case Health: _health += amount;
case PhysicalAttack: _physicalAttack += amount;
case PhysicalDefense: _physicalDefense += amount;
@ -68,8 +66,8 @@ namespace CreatureLib::Core{
}
throw NotReachableException();
}
inline void DecreaseStatBy(Statistic stat, T amount){
switch (stat){
inline void DecreaseStatBy(Statistic stat, T amount) {
switch (stat) {
case Health: _health -= amount;
case PhysicalAttack: _physicalAttack -= amount;
case PhysicalDefense: _physicalDefense -= amount;
@ -82,5 +80,4 @@ namespace CreatureLib::Core{
};
}
#endif //CREATURELIB_STATISTICSET_HPP

19
src/GenericTemplates.cpp
View File

@ -2,15 +2,22 @@
\brief GetProperty creates a simple wrapper for a field, creating a private field, and a public getter method.
*/
#define GetProperty(type, name) \
private: type __##name; \
public: [[nodiscard]] inline type Get##name() const{ return __##name; };
private: \
type __##name; \
\
public: \
[[nodiscard]] inline type Get##name() const { return __##name; };
/*!
\brief GetProperty creates a simple wrapper for a field, creating a private field, a public getter method, and a public
setter method.
*/
#define GetSetProperty(type, name) \
private: type __##name; \
public: [[nodiscard]] inline type Get##name() const{ return __##name; }; \
public: inline void Set##name(type value) { __##name = value; };
private: \
type __##name; \
\
public: \
[[nodiscard]] inline type Get##name() const { return __##name; }; \
\
public: \
inline void Set##name(type value) { __##name = value; };

12
src/Library/AttackLibrary.cpp
View File

@ -1,20 +1,16 @@
#include "AttackLibrary.hpp"
const CreatureLib::Library::AttackData *CreatureLib::Library::AttackLibrary::GetAttack(const std::string &name) const {
const CreatureLib::Library::AttackData* CreatureLib::Library::AttackLibrary::GetAttack(const std::string& name) const {
return this->_attacks.at(name);
}
const CreatureLib::Library::AttackData *CreatureLib::Library::AttackLibrary::operator[](const std::string &name) const {
const CreatureLib::Library::AttackData* CreatureLib::Library::AttackLibrary::operator[](const std::string& name) const {
return GetAttack(name);
}
void CreatureLib::Library::AttackLibrary::LoadAttack(const std::string &name,
void CreatureLib::Library::AttackLibrary::LoadAttack(const std::string& name,
const CreatureLib::Library::AttackData* attack) {
this->_attacks.insert({name, attack});
}
void CreatureLib::Library::AttackLibrary::DeleteAttack(const std::string &name) {
this->_attacks.erase(name);
}
void CreatureLib::Library::AttackLibrary::DeleteAttack(const std::string& name) { this->_attacks.erase(name); }

9
src/Library/AttackLibrary.hpp
View File

@ -9,22 +9,23 @@ namespace CreatureLib::Library {
class AttackLibrary {
private:
std::unordered_map<std::string, const AttackData*> _attacks;
public:
AttackLibrary() = default;
~AttackLibrary(){
for (auto attack: _attacks){
~AttackLibrary() {
for (auto attack : _attacks) {
delete attack.second;
}
_attacks.clear();
}
[[nodiscard]] const AttackData* GetAttack(const std::string& name) const;
[[nodiscard]] const AttackData* operator[] (const std::string& name) const;
[[nodiscard]] const AttackData* operator[](const std::string& name) const;
void LoadAttack(const std::string& name, const AttackData* attack);
void DeleteAttack(const std::string& name);
};
}
#endif //CREATURELIB_ATTACKLIBRARY_HPP
#endif // CREATURELIB_ATTACKLIBRARY_HPP

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

@ -4,11 +4,7 @@
#include <cstdint>
namespace CreatureLib::Library {
enum class AttackCategory : uint8_t {
Physical,
Magical,
Status
};
enum class AttackCategory : uint8_t { Physical, Magical, Status };
}
#endif //CREATURELIB_ATTACKCATEGORY_HPP
#endif // CREATURELIB_ATTACKCATEGORY_HPP

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

@ -1,5 +1,4 @@
#include "AttackData.hpp"
#include <utility>
CreatureLib::Library::AttackData::AttackData(std::string name, std::string type,
@ -7,19 +6,9 @@ CreatureLib::Library::AttackData::AttackData(std::string name, std::string type,
uint8_t accuracy, uint8_t baseUsage,
CreatureLib::Library::AttackTarget target, uint8_t priority,
std::unordered_set<std::string> flags)
:
__Name(std::move(name)),
__Type(std::move(type)),
__Category(category),
__BasePower(power),
__Accuracy(accuracy),
__BaseUsages(baseUsage),
__Target(target),
__Priority(priority),
_flags(std::move(flags))
{}
: __Name(std::move(name)), __Type(std::move(type)), __Category(category), __BasePower(power), __Accuracy(accuracy),
__BaseUsages(baseUsage), __Target(target), __Priority(priority), _flags(std::move(flags)) {}
bool CreatureLib::Library::AttackData::HasFlag(const std::string& key) const{
bool CreatureLib::Library::AttackData::HasFlag(const std::string& key) const {
return this->_flags.find(key) != this->_flags.end();
}

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

@ -3,23 +3,24 @@
#include <string>
#include <unordered_set>
#include "../../GenericTemplates.cpp"
#include "AttackCategory.hpp"
#include "AttackTarget.hpp"
#include "../../GenericTemplates.cpp"
namespace CreatureLib::Library {
class AttackData {
GetProperty(std::string, Name);
GetProperty(std::string, Type);
GetProperty(AttackCategory , Category);
GetProperty(uint8_t , BasePower);
GetProperty(uint8_t , Accuracy);
GetProperty(uint8_t , BaseUsages);
GetProperty(AttackCategory, Category);
GetProperty(uint8_t, BasePower);
GetProperty(uint8_t, Accuracy);
GetProperty(uint8_t, BaseUsages);
GetProperty(AttackTarget, Target);
GetProperty(uint8_t , Priority);
GetProperty(uint8_t, Priority);
private:
std::unordered_set<std::string> _flags;
public:
AttackData(std::string name, std::string type, AttackCategory category, uint8_t power, uint8_t accuracy,
uint8_t baseUsage, AttackTarget target, uint8_t priority, std::unordered_set<std::string> flags);
@ -28,5 +29,4 @@ namespace CreatureLib::Library {
};
}
#endif //CREATURELIB_ATTACKDATA_HPP
#endif // CREATURELIB_ATTACKDATA_HPP

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

@ -4,7 +4,7 @@
#include <cstdint>
namespace CreatureLib::Library {
enum class AttackTarget : uint8_t{
enum class AttackTarget : uint8_t {
Adjacent,
AdjacentAlly,
AdjacentAllySelf,
@ -23,4 +23,4 @@ namespace CreatureLib::Library {
};
}
#endif //CREATURELIB_ATTACKTARGET_HPP
#endif // CREATURELIB_ATTACKTARGET_HPP

14
src/Library/CreatureData/CreatureMoves.cpp
View File

@ -1,16 +1,8 @@
#include "CreatureMoves.hpp"
#include <utility>
CreatureLib::Library::LevelMove::LevelMove(uint8_t level, std::string name)
:_level(level),
_name(std::move(name))
{}
CreatureLib::Library::LevelMove::LevelMove(uint8_t level, std::string name) : _level(level), _name(std::move(name)) {}
uint8_t CreatureLib::Library::LevelMove::GetLevel() const {
return this->_level;
}
std::string CreatureLib::Library::LevelMove::GetName() const {
return this->_name;
}
uint8_t CreatureLib::Library::LevelMove::GetLevel() const { return this->_level; }
std::string CreatureLib::Library::LevelMove::GetName() const { return this->_name; }

11
src/Library/CreatureData/CreatureMoves.hpp
View File

@ -5,11 +5,12 @@
#include <string>
#include <vector>
namespace CreatureLib::Library{
class LevelMove{
namespace CreatureLib::Library {
class LevelMove {
private:
uint8_t _level;
std::string _name;
public:
LevelMove(uint8_t level, std::string name);
[[nodiscard]] inline uint8_t GetLevel() const;
@ -23,10 +24,10 @@ namespace CreatureLib::Library{
std::vector<std::string> _machineMoves;
std::vector<std::string> _tutorMoves;
std::vector<std::string> _variantDependentMoves;
public:
//TODO: Public API funcs
// TODO: Public API funcs
};
}
#endif //CREATURELIB_CREATUREMOVES_HPP
#endif // CREATURELIB_CREATUREMOVES_HPP

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

@ -2,30 +2,19 @@
using namespace CreatureLib::Library;
CreatureSpecies::CreatureSpecies(uint16_t id, std::string name, const SpeciesVariant* defaultVariant,
float genderRatio, std::string growthRate, uint8_t captureRate, uint8_t baseHappiness)
:
__Id(id),
__GenderRate(genderRatio),
__GrowthRate(std::move(growthRate)),
__CaptureRate(captureRate),
__BaseHappiness(baseHappiness),
_variants({{"default", defaultVariant}}),
_name(std::move(name))
{}
CreatureSpecies::CreatureSpecies(uint16_t id, std::string name, const SpeciesVariant* defaultVariant, float genderRatio,
std::string growthRate, uint8_t captureRate, uint8_t baseHappiness)
: __Id(id), __GenderRate(genderRatio), __GrowthRate(std::move(growthRate)), __CaptureRate(captureRate),
__BaseHappiness(baseHappiness), _variants({{"default", defaultVariant}}), _name(std::move(name)) {}
const SpeciesVariant *CreatureSpecies::GetVariant(const std::string& key) const {
return _variants.at(key);
}
const SpeciesVariant* CreatureSpecies::GetVariant(const std::string& key) const { return _variants.at(key); }
Gender CreatureSpecies::GetRandomGender(CreatureLib::Core::Random &rand) const {
Gender CreatureSpecies::GetRandomGender(CreatureLib::Core::Random& rand) const {
// TODO: Genderless creatures
auto val = rand.GetDouble();
if (val >= this->__GenderRate) return Gender ::Female;
if (val >= this->__GenderRate)
return Gender ::Female;
return Gender ::Male;
}
const std::string &CreatureSpecies::GetName() const {
return _name;
}
const std::string& CreatureSpecies::GetName() const { return _name; }

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

@ -3,12 +3,13 @@
#include <string>
#include <unordered_map>
#include "SpeciesVariant.hpp"
#include "../Gender.hpp"
#include "SpeciesVariant.hpp"
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.
/*!
\brief This holds the data required for a species of a creature, so the general data we can describe different
creatures with.
*/
class CreatureSpecies {
GetProperty(uint16_t, Id);
@ -16,15 +17,17 @@ namespace CreatureLib::Library {
GetProperty(std::string, GrowthRate);
GetProperty(uint8_t, CaptureRate);
GetProperty(uint8_t, BaseHappiness);
private:
std::unordered_map<std::string, const SpeciesVariant*> _variants;
std::string _name;
public:
CreatureSpecies(uint16_t id, std::string name, const SpeciesVariant* defaultVariant,
float genderRatio, std::string growthRate, uint8_t captureRate, uint8_t baseHappiness);
~CreatureSpecies(){
for (auto v: _variants)
public:
CreatureSpecies(uint16_t id, std::string name, const SpeciesVariant* defaultVariant, float genderRatio,
std::string growthRate, uint8_t captureRate, uint8_t baseHappiness);
~CreatureSpecies() {
for (auto v : _variants)
delete v.second;
_variants.clear();
}
@ -35,4 +38,4 @@ namespace CreatureLib::Library {
};
}
#endif //CREATURELIB_CREATURESPECIES_HPP
#endif // CREATURELIB_CREATURESPECIES_HPP

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

@ -2,10 +2,8 @@
using namespace CreatureLib::Library;
void LearnableAttacks::AddLevelMove(uint8_t level, AttackData *attack) {
_learnedByLevel[level].push_back(attack);
}
void LearnableAttacks::AddLevelMove(uint8_t level, AttackData* attack) { _learnedByLevel[level].push_back(attack); }
const std::vector<const AttackData *> &LearnableAttacks::GetMovesForLevel(uint8_t level) const {
const std::vector<const AttackData*>& LearnableAttacks::GetMovesForLevel(uint8_t level) const {
return _learnedByLevel[level];
}

7
src/Library/CreatureData/LearnableAttacks.hpp
View File

@ -7,9 +7,9 @@
namespace CreatureLib::Library {
class LearnableAttacks {
std::vector<std::vector<const AttackData*>> _learnedByLevel;
public:
LearnableAttacks(uint8_t maxLevel)
:_learnedByLevel(std::vector<std::vector<const AttackData*>>(maxLevel)){}
LearnableAttacks(uint8_t maxLevel) : _learnedByLevel(std::vector<std::vector<const AttackData*>>(maxLevel)) {}
void AddLevelMove(uint8_t level, AttackData* attack);
@ -17,5 +17,4 @@ namespace CreatureLib::Library {
};
}
#endif //CREATURELIB_LEARNABLEATTACKS_HPP
#endif // CREATURELIB_LEARNABLEATTACKS_HPP

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

@ -2,24 +2,18 @@
#include <algorithm>
#include <utility>
const std::vector<uint8_t>& CreatureLib::Library::SpeciesVariant::GetTypes() const {
return _types;
}
const std::vector<uint8_t>& CreatureLib::Library::SpeciesVariant::GetTypes() const { return _types; }
size_t CreatureLib::Library::SpeciesVariant::GetTypeCount() const {
return _types.size();
}
size_t CreatureLib::Library::SpeciesVariant::GetTypeCount() const { return _types.size(); }
uint8_t CreatureLib::Library::SpeciesVariant::GetType(size_t index) const {
return _types[index];
}
uint8_t CreatureLib::Library::SpeciesVariant::GetType(size_t index) const { return _types[index]; }
uint32_t CreatureLib::Library::SpeciesVariant::GetStatistic(CreatureLib::Core::Statistic stat) const {
return _baseStatistics.GetStat(stat);
}
const std::string& CreatureLib::Library::SpeciesVariant::GetTalent(int32_t index) const {
if (index < 0){
if (index < 0) {
index = -index - 1;
return _secretTalents[index];
}
@ -30,42 +24,34 @@ const std::string& CreatureLib::Library::SpeciesVariant::GetTalent(int32_t index
return &_moves;
}*/
int8_t CreatureLib::Library::SpeciesVariant::GetTalentIndex(const std::string& talent) const{
int8_t CreatureLib::Library::SpeciesVariant::GetTalentIndex(const std::string& talent) const {
auto i = std::find(_talents.begin(), _talents.end(), talent);
if (i != _talents.end()){
if (i != _talents.end()) {
return std::distance(_talents.begin(), i);
}
i = std::find(_secretTalents.begin(), _secretTalents.end(), talent);
if (i != _secretTalents.end()){
if (i != _secretTalents.end()) {
return std::distance(_secretTalents.begin(), i);
}
throw CreatureException("The given talent is not a valid talent for this creature.");
}
int8_t CreatureLib::Library::SpeciesVariant::GetRandomTalent(CreatureLib::Core::Random *rand) const {
int8_t CreatureLib::Library::SpeciesVariant::GetRandomTalent(CreatureLib::Core::Random* rand) const {
return rand->Get(_talents.size());
}
const CreatureLib::Library::LearnableAttacks *CreatureLib::Library::SpeciesVariant::GetLearnableAttacks() const {
const CreatureLib::Library::LearnableAttacks* CreatureLib::Library::SpeciesVariant::GetLearnableAttacks() const {
return _attacks;
}
CreatureLib::Library::SpeciesVariant::SpeciesVariant(std::string name, float height, float weight,
uint32_t baseExperience, std::vector<uint8_t> types,
CreatureLib::Core::StatisticSet<uint16_t > baseStats,
CreatureLib::Core::StatisticSet<uint16_t> baseStats,
std::vector<std::string> talents,
std::vector<std::string> secretTalents, const LearnableAttacks* attacks)
: __Name(std::move(name)),
__Height(height),
__Weight(weight),
__BaseExperience(baseExperience),
_types(std::move(types)),
_baseStatistics(baseStats),
_talents(std::move(talents)),
_secretTalents(std::move(secretTalents)),
_attacks(attacks)
{}
std::vector<std::string> secretTalents,
const LearnableAttacks* attacks)
: __Name(std::move(name)), __Height(height), __Weight(weight), __BaseExperience(baseExperience),
_types(std::move(types)), _baseStatistics(baseStats), _talents(std::move(talents)),
_secretTalents(std::move(secretTalents)), _attacks(attacks) {}
CreatureLib::Library::SpeciesVariant::~SpeciesVariant() {
delete _attacks;
}
CreatureLib::Library::SpeciesVariant::~SpeciesVariant() { delete _attacks; }

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

@ -3,37 +3,40 @@
#include <string>
#include <vector>
#include "CreatureMoves.hpp"
#include "../../Core/Random.hpp"
#include "../../Core/StatisticSet.hpp"
#include "../../GenericTemplates.cpp"
#include "../../Core/Random.hpp"
#include "CreatureMoves.hpp"
#include "LearnableAttacks.hpp"
namespace CreatureLib::Library {
/*!
\brief A single species can have more than one variant. This class holds the data for those variants.
/*!
\brief A single species can have more than one variant. This class holds the data for those variants.
*/
class SpeciesVariant {
GetProperty(std::string, Name);
GetProperty(float, Height);
GetProperty(float, Weight);
GetProperty(uint32_t, BaseExperience);
private:
std::vector<uint8_t > _types;
const Core::StatisticSet<uint16_t > _baseStatistics;
std::vector<uint8_t> _types;
const Core::StatisticSet<uint16_t> _baseStatistics;
std::vector<std::string> _talents;
std::vector<std::string> _secretTalents;
const LearnableAttacks* _attacks;
public:
SpeciesVariant(std::string name, float height, float weight, uint32_t baseExperience,
std::vector<uint8_t> types, Core::StatisticSet<uint16_t > baseStats, std::vector<std::string> talents,
std::vector<std::string> secretTalents, const LearnableAttacks* attacks);
std::vector<uint8_t> types, Core::StatisticSet<uint16_t> baseStats,
std::vector<std::string> talents, std::vector<std::string> secretTalents,
const LearnableAttacks* attacks);
~SpeciesVariant();
[[nodiscard]] size_t GetTypeCount() const;
[[nodiscard]] uint8_t GetType(size_t index) const;
[[nodiscard]] const std::vector<uint8_t >& GetTypes() const;
[[nodiscard]] const std::vector<uint8_t>& GetTypes() const;
[[nodiscard]] uint32_t GetStatistic(Core::Statistic stat) const;
[[nodiscard]] const std::string& GetTalent(int32_t index) const;
[[nodiscard]] const LearnableAttacks* GetLearnableAttacks() const;
@ -42,4 +45,4 @@ namespace CreatureLib::Library {
};
}
#endif //CREATURELIB_SPECIESVARIANT_HPP
#endif // CREATURELIB_SPECIESVARIANT_HPP

32
src/Library/DataLibrary.cpp
View File

@ -1,39 +1,31 @@
#include "DataLibrary.hpp"
CreatureLib::Library::DataLibrary::DataLibrary(LibrarySettings settings,
CreatureLib::Library::SpeciesLibrary *species,
CreatureLib::Library::AttackLibrary *attacks,
CreatureLib::Library::ItemLibrary *items,
CreatureLib::Library::GrowthRateLibrary *growthRates,
CreatureLib::Library::DataLibrary::DataLibrary(LibrarySettings settings, CreatureLib::Library::SpeciesLibrary* species,
CreatureLib::Library::AttackLibrary* attacks,
CreatureLib::Library::ItemLibrary* items,
CreatureLib::Library::GrowthRateLibrary* growthRates,
TypeLibrary* typeLibrary)
: _settings(settings), _species(species), _attacks(attacks), _items(items),
_growthRates(growthRates), _typeLibrary(typeLibrary){
: _settings(settings), _species(species), _attacks(attacks), _items(items), _growthRates(growthRates),
_typeLibrary(typeLibrary) {}
}
const CreatureLib::Library::LibrarySettings &CreatureLib::Library::DataLibrary::GetSettings() const {
const CreatureLib::Library::LibrarySettings& CreatureLib::Library::DataLibrary::GetSettings() const {
return _settings;
}
const CreatureLib::Library::SpeciesLibrary *CreatureLib::Library::DataLibrary::GetSpeciesLibrary() const {
const CreatureLib::Library::SpeciesLibrary* CreatureLib::Library::DataLibrary::GetSpeciesLibrary() const {
return _species;
}
const CreatureLib::Library::AttackLibrary *CreatureLib::Library::DataLibrary::GetAttackLibrary() const {
const CreatureLib::Library::AttackLibrary* CreatureLib::Library::DataLibrary::GetAttackLibrary() const {
return _attacks;
}
const CreatureLib::Library::ItemLibrary *CreatureLib::Library::DataLibrary::GetItemLibrary() const {
return _items;
}
const CreatureLib::Library::ItemLibrary* CreatureLib::Library::DataLibrary::GetItemLibrary() const { return _items; }
const CreatureLib::Library::GrowthRateLibrary *CreatureLib::Library::DataLibrary::GetGrowthRates() const {
const CreatureLib::Library::GrowthRateLibrary* CreatureLib::Library::DataLibrary::GetGrowthRates() const {
return _growthRates;
}
const CreatureLib::Library::TypeLibrary *CreatureLib::Library::DataLibrary::GetTypeLibrary() const {
const CreatureLib::Library::TypeLibrary* CreatureLib::Library::DataLibrary::GetTypeLibrary() const {
return _typeLibrary;
}

24
src/Library/DataLibrary.hpp
View File

@ -1,15 +1,15 @@
#ifndef CREATURELIB_DATALIBRARY_HPP
#define CREATURELIB_DATALIBRARY_HPP
#include "SpeciesLibrary.hpp"
#include "AttackLibrary.hpp"
#include "ItemLibrary.hpp"
#include "GrowthRates/GrowthRateLibrary.hpp"
#include "ItemLibrary.hpp"
#include "LibrarySettings.hpp"
#include "SpeciesLibrary.hpp"
#include "TypeLibrary.hpp"
namespace CreatureLib::Library {
/*!
/*!
\brief The core library. This library holds all static data for a creature set.
*/
class DataLibrary {
@ -20,16 +20,13 @@ namespace CreatureLib::Library {
const ItemLibrary* _items;
const GrowthRateLibrary* _growthRates;
const TypeLibrary* _typeLibrary;
public:
DataLibrary(LibrarySettings settings,
CreatureLib::Library::SpeciesLibrary *species,
CreatureLib::Library::AttackLibrary *attacks,
CreatureLib::Library::ItemLibrary *items,
CreatureLib::Library::GrowthRateLibrary *growthRates,
TypeLibrary* typeLibrary
);
~DataLibrary(){
public:
DataLibrary(LibrarySettings settings, CreatureLib::Library::SpeciesLibrary* species,
CreatureLib::Library::AttackLibrary* attacks, CreatureLib::Library::ItemLibrary* items,
CreatureLib::Library::GrowthRateLibrary* growthRates, TypeLibrary* typeLibrary);
~DataLibrary() {
delete _species;
delete _attacks;
delete _items;
@ -46,5 +43,4 @@ namespace CreatureLib::Library {
};
}
#endif //CREATURELIB_DATALIBRARY_HPP
#endif // CREATURELIB_DATALIBRARY_HPP

10
src/Library/Gender.hpp
View File

@ -3,16 +3,12 @@
#include <cstdint>
namespace CreatureLib::Library{
namespace CreatureLib::Library {
/*!
\brief Might be somewhat controversial nowadays, but as many creature battling games only have two genders, we'll
hardcode those.
*/
enum class Gender : uint8_t {
Male,
Female,
Genderless
};
enum class Gender : uint8_t { Male, Female, Genderless };
}
#endif //CREATURELIB_GENDER_HPP
#endif // CREATURELIB_GENDER_HPP

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

@ -11,4 +11,4 @@ namespace CreatureLib::Library {
};
}
#endif //CREATURELIB_GROWTHRATE_HPP
#endif // CREATURELIB_GROWTHRATE_HPP

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

@ -1,9 +1,11 @@
#include "GrowthRateLibrary.hpp"
uint8_t CreatureLib::Library::GrowthRateLibrary::CalculateLevel(const std::string &growthRate, uint32_t experience) const {
uint8_t CreatureLib::Library::GrowthRateLibrary::CalculateLevel(const std::string& growthRate,
uint32_t experience) const {
return _growthRates.at(growthRate)->CalculateLevel(experience);
}
uint32_t CreatureLib::Library::GrowthRateLibrary::CalculateExperience(const std::string &growthRate, uint8_t level) const {
uint32_t CreatureLib::Library::GrowthRateLibrary::CalculateExperience(const std::string& growthRate,
uint8_t level) const {
return _growthRates.at(growthRate)->CalculateExperience(level);
}

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

@ -6,14 +6,15 @@
#include <unordered_map>
#include "GrowthRate.hpp"
namespace CreatureLib::Library{
namespace CreatureLib::Library {
class GrowthRateLibrary {
private:
std::unordered_map<std::string, GrowthRate*> _growthRates;
public:
[[nodiscard]] uint8_t CalculateLevel(const std::string& growthRate, uint32_t experience) const;
[[nodiscard]] uint32_t CalculateExperience(const std::string& growthRate, uint8_t level) const;
};
}
#endif //CREATURELIB_GROWTHRATELIBRARY_HPP
#endif // CREATURELIB_GROWTHRATELIBRARY_HPP

10
src/Library/ItemLibrary.cpp
View File

@ -1,17 +1,15 @@
#include "ItemLibrary.hpp"
const CreatureLib::Library::Item *CreatureLib::Library::ItemLibrary::GetItem(const std::string &name) const {
const CreatureLib::Library::Item* CreatureLib::Library::ItemLibrary::GetItem(const std::string& name) const {
return this->_items.at(name);
}
const CreatureLib::Library::Item *CreatureLib::Library::ItemLibrary::operator[](const std::string &name) const {
const CreatureLib::Library::Item* CreatureLib::Library::ItemLibrary::operator[](const std::string& name) const {
return this->GetItem(name);
}
void CreatureLib::Library::ItemLibrary::LoadItem(const std::string &name, const CreatureLib::Library::Item *item) {
void CreatureLib::Library::ItemLibrary::LoadItem(const std::string& name, const CreatureLib::Library::Item* item) {
this->_items.insert({name, item});
}
void CreatureLib::Library::ItemLibrary::DeleteItem(const std::string &name) {
this->_items.erase(name);
}
void CreatureLib::Library::ItemLibrary::DeleteItem(const std::string& name) { this->_items.erase(name); }

13
src/Library/ItemLibrary.hpp
View File

@ -8,21 +8,18 @@
namespace CreatureLib::Library {
class ItemLibrary {
private:
std::unordered_map<std::string, const Item *> _items;
std::unordered_map<std::string, const Item*> _items;
public:
ItemLibrary() = default;
~ItemLibrary(){
_items.clear();
}
~ItemLibrary() { _items.clear(); }
[[nodiscard]] const Item* GetItem(const std::string& name) const;
[[nodiscard]] const Item* operator[] (const std::string& name) const;
[[nodiscard]] const Item* operator[](const std::string& name) const;
void LoadItem(const std::string& name, const Item* item);
void DeleteItem(const std::string& name);
};
}
#endif //CREATURELIB_ITEMLIBRARY_HPP
#endif // CREATURELIB_ITEMLIBRARY_HPP

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

@ -4,13 +4,7 @@
#include <cstdint>
namespace CreatureLib::Library {
enum class BattleItemCategory : uint8_t {
None,
Healing,
StatusHealing,
CaptureDevice,
MiscBattleItem
};
enum class BattleItemCategory : uint8_t { None, Healing, StatusHealing, CaptureDevice, MiscBattleItem };
}
#endif //CREATURELIB_BATTLEITEMCATEGORY_HPP
#endif // CREATURELIB_BATTLEITEMCATEGORY_HPP

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

@ -3,18 +3,20 @@
#include <string>
#include <unordered_set>
#include "ItemCategory.hpp"
#include "BattleItemCategory.hpp"
#include "../../GenericTemplates.cpp"
#include "BattleItemCategory.hpp"
#include "ItemCategory.hpp"
namespace CreatureLib::Library {
class Item {
GetProperty(std::string, Name);
GetProperty(ItemCategory, Category);
GetProperty(BattleItemCategory, BattleCategory);
GetProperty(int32_t , Price);
GetProperty(int32_t, Price);
private:
std::unordered_set<std::string> _flags;
public:
Item(std::string name, ItemCategory category, BattleItemCategory battleCategory, int32_t price,
std::unordered_set<std::string> flags);
@ -23,4 +25,4 @@ namespace CreatureLib::Library {
};
}
#endif //CREATURELIB_ITEM_HPP
#endif // CREATURELIB_ITEM_HPP

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

@ -3,7 +3,7 @@
#include <cstdint>
namespace CreatureLib::Library{
namespace CreatureLib::Library {
enum class ItemCategory : uint8_t {
MiscItem,
CaptureDevice,
@ -16,4 +16,4 @@ namespace CreatureLib::Library{
};
}
#endif //CREATURELIB_ITEMCATEGORY_HPP
#endif // CREATURELIB_ITEMCATEGORY_HPP

15
src/Library/LibrarySettings.hpp
View File

@ -4,21 +4,18 @@
#include <cstdint>
namespace CreatureLib::Library {
class LibrarySettings{
class LibrarySettings {
uint8_t _maximalLevel;
uint8_t _maximalMoves;
public:
LibrarySettings(uint8_t maximalLevel, uint8_t maximalMoves)
: _maximalLevel(maximalLevel), _maximalMoves(maximalMoves){}
: _maximalLevel(maximalLevel), _maximalMoves(maximalMoves) {}
inline uint8_t GetMaximalLevel() const{
return _maximalLevel;
}
inline uint8_t GetMaximalLevel() const { return _maximalLevel; }
inline uint8_t GetMaximalMoves() const{
return _maximalMoves;
}
inline uint8_t GetMaximalMoves() const { return _maximalMoves; }
};
}
#endif //CREATURELIB_LIBRARYSETTINGS_HPP
#endif // CREATURELIB_LIBRARYSETTINGS_HPP

13
src/Library/SpeciesLibrary.cpp
View File

@ -1,19 +1,18 @@
#include "SpeciesLibrary.hpp"
const CreatureLib::Library::CreatureSpecies *CreatureLib::Library::SpeciesLibrary::GetSpecies(const std::string& name) const{
const CreatureLib::Library::CreatureSpecies*
CreatureLib::Library::SpeciesLibrary::GetSpecies(const std::string& name) const {
return _species.at(name);
}
const CreatureLib::Library::CreatureSpecies* CreatureLib::Library::SpeciesLibrary::operator[](const std::string &name) const{
const CreatureLib::Library::CreatureSpecies*
CreatureLib::Library::SpeciesLibrary::operator[](const std::string& name) const {
return GetSpecies(name);
}
void CreatureLib::Library::SpeciesLibrary::LoadSpecies(const std::string &name,
void CreatureLib::Library::SpeciesLibrary::LoadSpecies(const std::string& name,
const CreatureLib::Library::CreatureSpecies* species) {
_species.insert({name, species});
}
void CreatureLib::Library::SpeciesLibrary::DeleteSpecies(const std::string &name) {
_species.erase(name);
}
void CreatureLib::Library::SpeciesLibrary::DeleteSpecies(const std::string& name) { _species.erase(name); }

10
src/Library/SpeciesLibrary.hpp
View File

@ -9,22 +9,22 @@ namespace CreatureLib::Library {
class SpeciesLibrary {
private:
std::unordered_map<std::string, const CreatureSpecies*> _species;
public:
SpeciesLibrary() = default;
~SpeciesLibrary(){
for (auto s: _species)
~SpeciesLibrary() {
for (auto s : _species)
delete s.second;
_species.clear();
}
[[nodiscard]] const CreatureSpecies* GetSpecies(const std::string& name) const;
[[nodiscard]] const CreatureSpecies* operator[] (const std::string& name) const;
[[nodiscard]] const CreatureSpecies* operator[](const std::string& name) const;
void LoadSpecies(const std::string& name, const CreatureSpecies* species);
void DeleteSpecies(const std::string& name);
};
}
#endif //CREATURELIB_SPECIESLIBRARY_HPP
#endif // CREATURELIB_SPECIESLIBRARY_HPP

10
src/Library/TypeLibrary.cpp
View File

@ -2,9 +2,9 @@
using namespace CreatureLib::Library;
float TypeLibrary::GetEffectiveness(uint8_t attacking, const std::vector<uint8_t> &defensive) const {
float TypeLibrary::GetEffectiveness(uint8_t attacking, const std::vector<uint8_t>& defensive) const {
auto eff = 1;
for (auto def: defensive){
for (auto def : defensive) {
eff *= GetSingleEffectiveness(attacking, def);
}
return eff;
@ -14,14 +14,12 @@ float TypeLibrary::GetSingleEffectiveness(uint8_t attacking, uint8_t defensive)
return _effectiveness[attacking][defensive];
}
uint8_t TypeLibrary::GetTypeId(const std::string &s) const {
return _types.at(s);
}
uint8_t TypeLibrary::GetTypeId(const std::string& s) const { return _types.at(s); }
uint8_t TypeLibrary::RegisterType(const std::string& typeName) {
_types.insert({typeName, _types.size()});
_effectiveness.resize(_types.size());
for (auto & eff : _effectiveness){
for (auto& eff : _effectiveness) {
eff.resize(_types.size(), 1);
}
return _types.size() - 1;

8
src/Library/TypeLibrary.hpp
View File

@ -4,10 +4,11 @@
#include <unordered_map>
#include <vector>
namespace CreatureLib::Library{
namespace CreatureLib::Library {
class TypeLibrary {
std::unordered_map<std::string, uint8_t > _types;
std::unordered_map<std::string, uint8_t> _types;
std::vector<std::vector<float>> _effectiveness;
public:
uint8_t GetTypeId(const std::string& s) const;
float GetSingleEffectiveness(uint8_t attacking, uint8_t defensive) const;
@ -18,5 +19,4 @@ namespace CreatureLib::Library{
};
}
#endif //CREATURELIB_TYPELIBRARY_HPP
#endif // CREATURELIB_TYPELIBRARY_HPP

11
tests/BattleTests/ChoiceSetTests.cpp
View File

@ -1,13 +1,13 @@
#ifdef TESTS_BUILD
#include "../TestLibrary/TestLibrary.cpp"
#include "../../src/Battling/Models/BattleSide.hpp"
#include "../../src/Battling/Models/CreateCreature.hpp"
#include "../../src/Battling/TurnChoices/PassTurnChoice.hpp"
#include "../TestLibrary/TestLibrary.cpp"
using namespace CreatureLib::Battling;
TEST_CASE( "Set Choice one-sized side", "[Battling]" ) {
TEST_CASE("Set Choice one-sized side", "[Battling]") {
auto side = BattleSide(nullptr, 1);
auto c = CreateCreature(GetLibrary(), "testSpecies1", 5).Create();
side.SetCreature(c, 0);
@ -17,7 +17,7 @@ TEST_CASE( "Set Choice one-sized side", "[Battling]" ) {
delete c;
}
TEST_CASE( "Set Choice one-sized side, validate all choices set", "[Battling]" ) {
TEST_CASE("Set Choice one-sized side, validate all choices set", "[Battling]") {
auto side = BattleSide(nullptr, 1);
auto c = CreateCreature(GetLibrary(), "testSpecies1", 5).Create();
side.SetCreature(c, 0);
@ -29,7 +29,7 @@ TEST_CASE( "Set Choice one-sized side, validate all choices set", "[Battling]" )
delete c;
}
TEST_CASE( "Set Choice two-sized side", "[Battling]" ) {
TEST_CASE("Set Choice two-sized side", "[Battling]") {
auto side = BattleSide(nullptr, 2);
auto c1 = CreateCreature(GetLibrary(), "testSpecies1", 5).Create();
auto c2 = CreateCreature(GetLibrary(), "testSpecies1", 5).Create();
@ -45,7 +45,7 @@ TEST_CASE( "Set Choice two-sized side", "[Battling]" ) {
delete c2;
}
TEST_CASE( "Set Choice two-sized side, validate all choices set", "[Battling]" ) {
TEST_CASE("Set Choice two-sized side, validate all choices set", "[Battling]") {
auto side = BattleSide(nullptr, 2);
auto c1 = CreateCreature(GetLibrary(), "testSpecies1", 5).Create();
auto c2 = CreateCreature(GetLibrary(), "testSpecies1", 5).Create();
@ -64,5 +64,4 @@ TEST_CASE( "Set Choice two-sized side, validate all choices set", "[Battling]" )
delete c2;
}
#endif

46
tests/BattleTests/ScriptTests/ScriptAggregatorTests.cpp
View File

@ -1,31 +1,25 @@
#ifdef TESTS_BUILD
#include <utility>
#include "../../../extern/catch.hpp"
#include "../../../src/Battling/ScriptHandling/ScriptAggregator.hpp"
using namespace CreatureLib;
using namespace CreatureLib::Battling;
class TestScript : public Script{
class TestScript : public Script {
public:
explicit TestScript(std::string name) : Script(std::move(name)){};
void TestMethod(int& runCount) {
runCount++;
}
void TestMethod(int& runCount) { runCount++; }
};
TEST_CASE( "Script Aggregator properly iterates containing script.", "[Battling, Scripting]" ) {
TEST_CASE("Script Aggregator properly iterates containing script.", "[Battling, Scripting]") {
Script* script = new TestScript("test");
auto ran = 0;
auto vec = std::vector<ScriptWrapper>{&script};
auto aggr = ScriptAggregator(vec);
while (aggr.HasNext()){
while (aggr.HasNext()) {
auto next = aggr.GetNext();
REQUIRE(next != nullptr);
dynamic_cast<TestScript*>(next)->TestMethod(ran);
@ -34,14 +28,14 @@ TEST_CASE( "Script Aggregator properly iterates containing script.", "[Battling,
delete script;
}
TEST_CASE( "Script Aggregator properly iterates multiple scripts.", "[Battling, Scripting]" ) {
TEST_CASE("Script Aggregator properly iterates multiple scripts.", "[Battling, Scripting]") {
Script* script = new TestScript("test");
Script* script2 = new TestScript("test2");
Script* script3 = new TestScript("test3");
auto ran = 0;
auto vec = std::vector<ScriptWrapper>{&script, &script2, &script3};
auto aggr = ScriptAggregator(vec);
while (aggr.HasNext()){
while (aggr.HasNext()) {
auto next = aggr.GetNext();
REQUIRE(next != nullptr);
dynamic_cast<TestScript*>(next)->TestMethod(ran);
@ -52,7 +46,7 @@ TEST_CASE( "Script Aggregator properly iterates multiple scripts.", "[Battling,
delete script3;
}
TEST_CASE( "Script Aggregator properly iterates Script Set.", "[Battling, Scripting]" ) {
TEST_CASE("Script Aggregator properly iterates Script Set.", "[Battling, Scripting]") {
Script* script = new TestScript("test");
Script* script2 = new TestScript("test2");
Script* script3 = new TestScript("test3");
@ -63,7 +57,7 @@ TEST_CASE( "Script Aggregator properly iterates Script Set.", "[Battling, Script
set.Add(script3);
auto vec = std::vector<ScriptWrapper>{&set};
auto aggr = ScriptAggregator(vec);
while (aggr.HasNext()){
while (aggr.HasNext()) {
auto next = aggr.GetNext();
REQUIRE(next != nullptr);
dynamic_cast<TestScript*>(next)->TestMethod(ran);
@ -74,7 +68,7 @@ TEST_CASE( "Script Aggregator properly iterates Script Set.", "[Battling, Script
delete script3;
}
TEST_CASE( "Script Aggregator properly iterates data of Script Set and Script.", "[Battling, Scripting]" ) {
TEST_CASE("Script Aggregator properly iterates data of Script Set and Script.", "[Battling, Scripting]") {
Script* script = new TestScript("test");
Script* script2 = new TestScript("test2");
Script* script3 = new TestScript("test3");
@ -84,7 +78,7 @@ TEST_CASE( "Script Aggregator properly iterates data of Script Set and Script.",
set.Add(script3);
auto vec = std::vector<ScriptWrapper>{&set, &script};
auto aggr = ScriptAggregator(vec);
while (aggr.HasNext()){
while (aggr.HasNext()) {
auto next = aggr.GetNext();
REQUIRE(next != nullptr);
dynamic_cast<TestScript*>(next)->TestMethod(ran);
@ -95,7 +89,7 @@ TEST_CASE( "Script Aggregator properly iterates data of Script Set and Script.",
delete script3;
}
TEST_CASE( "Script Aggregator properly iterates data of Script and Script Set.", "[Battling, Scripting]" ) {
TEST_CASE("Script Aggregator properly iterates data of Script and Script Set.", "[Battling, Scripting]") {
Script* script = new TestScript("test");
Script* script2 = new TestScript("test2");
Script* script3 = new TestScript("test3");
@ -105,7 +99,7 @@ TEST_CASE( "Script Aggregator properly iterates data of Script and Script Set.",
set.Add(script3);
auto vec = std::vector<ScriptWrapper>{&script, &set};
auto aggr = ScriptAggregator(vec);
while (aggr.HasNext()){
while (aggr.HasNext()) {
auto next = aggr.GetNext();
REQUIRE(next != nullptr);
dynamic_cast<TestScript*>(next)->TestMethod(ran);
@ -116,7 +110,7 @@ TEST_CASE( "Script Aggregator properly iterates data of Script and Script Set.",
delete script3;
}
TEST_CASE( "Script Aggregator properly iterates data of Script, Script Set and Script.", "[Battling, Scripting]" ) {
TEST_CASE("Script Aggregator properly iterates data of Script, Script Set and Script.", "[Battling, Scripting]") {
Script* script = new TestScript("test");
Script* script2 = new TestScript("test2");
Script* script3 = new TestScript("test3");
@ -127,7 +121,7 @@ TEST_CASE( "Script Aggregator properly iterates data of Script, Script Set and S
set.Add(script3);
auto vec = std::vector<ScriptWrapper>{&script, &set, &script4};
auto aggr = ScriptAggregator(vec);
while (aggr.HasNext()){
while (aggr.HasNext()) {
auto next = aggr.GetNext();
REQUIRE(next != nullptr);
dynamic_cast<TestScript*>(next)->TestMethod(ran);
@ -139,22 +133,22 @@ TEST_CASE( "Script Aggregator properly iterates data of Script, Script Set and S
delete script4;
}
TEST_CASE( "Script Aggregator properly iterates when empty.", "[Battling, Scripting]" ) {
TEST_CASE("Script Aggregator properly iterates when empty.", "[Battling, Scripting]") {
auto ran = 0;
auto vec = std::vector<ScriptWrapper>{};
auto aggr = ScriptAggregator(vec);
while (aggr.HasNext()){
while (aggr.HasNext()) {
throw CreatureException("Aggregator returned a script, but should have been empty.");
}
CHECK(ran == 0);
}
TEST_CASE( "Script Aggregator properly iterates empty Script Set.", "[Battling, Scripting]" ) {
TEST_CASE("Script Aggregator properly iterates empty Script Set.", "[Battling, Scripting]") {
auto ran = 0;
auto set = ScriptSet();
auto vec = std::vector<ScriptWrapper>{&set};
auto aggr = ScriptAggregator(vec);
while (aggr.HasNext()){
while (aggr.HasNext()) {
auto next = aggr.GetNext();
REQUIRE(next == nullptr);
ran++;
@ -162,8 +156,4 @@ TEST_CASE( "Script Aggregator properly iterates empty Script Set.", "[Battling,
CHECK(ran == 1);
}
#endif

21
tests/BattleTests/ScriptTests/ScriptSetTests.cpp
View File

@ -1,20 +1,18 @@
#ifdef TESTS_BUILD
#include <utility>
#include "../../../extern/catch.hpp"
#include "../../../src/Battling/ScriptHandling/ScriptSet.hpp"
using namespace CreatureLib;
using namespace CreatureLib::Battling;
TEST_CASE( "Empty script set count == 0", "[Battling, Scripting]" ) {
TEST_CASE("Empty script set count == 0", "[Battling, Scripting]") {
auto set = ScriptSet();
REQUIRE(set.Count() == 0);
}
TEST_CASE( "Add script to script set", "[Battling, Scripting]" ) {
TEST_CASE("Add script to script set", "[Battling, Scripting]") {
auto set = ScriptSet();
auto s = new Script("foobar");
set.Add(s);
@ -22,7 +20,7 @@ TEST_CASE( "Add script to script set", "[Battling, Scripting]" ) {
delete s;
}
TEST_CASE( "Add script to script set, then retrieve it", "[Battling, Scripting]" ) {
TEST_CASE("Add script to script set, then retrieve it", "[Battling, Scripting]") {
auto set = ScriptSet();
auto s = new Script("foobar");
set.Add(s);
@ -32,7 +30,7 @@ TEST_CASE( "Add script to script set, then retrieve it", "[Battling, Scripting]"
delete s;
}
TEST_CASE( "Add two scripts to script set", "[Battling, Scripting]" ) {
TEST_CASE("Add two scripts to script set", "[Battling, Scripting]") {
auto set = ScriptSet();
auto s = new Script("foobar");
auto s2 = new Script("foobar2");
@ -43,7 +41,7 @@ TEST_CASE( "Add two scripts to script set", "[Battling, Scripting]" ) {
delete s2;
}
TEST_CASE( "Add two scripts to script set, then retrieve them", "[Battling, Scripting]" ) {
TEST_CASE("Add two scripts to script set, then retrieve them", "[Battling, Scripting]") {
auto set = ScriptSet();
auto s = new Script("foobar");
auto s2 = new Script("foobar2");
@ -58,7 +56,7 @@ TEST_CASE( "Add two scripts to script set, then retrieve them", "[Battling, Scri
delete s2;
}
TEST_CASE( "Add script to script set, then remove it", "[Battling, Scripting]" ) {
TEST_CASE("Add script to script set, then remove it", "[Battling, Scripting]") {
auto set = ScriptSet();
auto s = new Script("foobar");
set.Add(s);
@ -70,7 +68,7 @@ TEST_CASE( "Add script to script set, then remove it", "[Battling, Scripting]" )
delete s;
}
TEST_CASE( "Add two scripts to script set, then remove them", "[Battling, Scripting]" ) {
TEST_CASE("Add two scripts to script set, then remove them", "[Battling, Scripting]") {
auto set = ScriptSet();
auto s = new Script("foobar");
auto s2 = new Script("foobar2");
@ -85,9 +83,4 @@ TEST_CASE( "Add two scripts to script set, then remove them", "[Battling, Script
delete s2;
}
#endif

46
tests/BattleTests/ScriptTests/ScriptSourceTest.cpp
View File

@ -1,50 +1,44 @@
#ifdef TESTS_BUILD
#include <utility>
#include "../../../extern/catch.hpp"
#include "../../../src/Battling/ScriptHandling/ScriptSource.hpp"
#include <utility>
#include "../../../extern/catch.hpp"
#include "../../../src/Battling/ScriptHandling/ScriptAggregator.hpp"
using namespace CreatureLib;
using namespace CreatureLib::Battling;
class TestScript : public Script{
class TestScript : public Script {
public:
explicit TestScript(std::string name) : Script(std::move(name)){};
void TestMethod(int& runCount) {
runCount++;
}
void TestMethod(int& runCount) { runCount++; }
};
class ScriptSourceWithScriptPtr : public ScriptSource{
class ScriptSourceWithScriptPtr : public ScriptSource {
public:
Script* ScriptPtr = nullptr;
protected:
void GetActiveScripts(std::vector<ScriptWrapper> &scripts) override {
scripts.emplace_back(&ScriptPtr);
}
void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override { scripts.emplace_back(&ScriptPtr); }
};
class ScriptSourceWithScriptSet : public ScriptSource{
class ScriptSourceWithScriptSet : public ScriptSource {
public:
ScriptSet Set;
protected:
void GetActiveScripts(std::vector<ScriptWrapper> &scripts) override {
scripts.emplace_back(&Set);
}
void GetActiveScripts(std::vector<ScriptWrapper>& scripts) override { scripts.emplace_back(&Set); }
};
TEST_CASE( "Script source with unset script ptr.", "[Battling, Scripting]" ) {
TEST_CASE("Script source with unset script ptr.", "[Battling, Scripting]") {
auto source = ScriptSourceWithScriptPtr();
auto scripts = source.GetScriptIterator();
auto first = scripts.GetNext();
CHECK(first == nullptr);
}
TEST_CASE( "Script source with script ptr being set.", "[Battling, Scripting]" ) {
TEST_CASE("Script source with script ptr being set.", "[Battling, Scripting]") {
auto source = ScriptSourceWithScriptPtr();
source.ScriptPtr = new Script("foobar");
auto scripts = source.GetScriptIterator();
@ -53,7 +47,7 @@ TEST_CASE( "Script source with script ptr being set.", "[Battling, Scripting]" )
delete source.ScriptPtr;
}
TEST_CASE( "Script source with script ptr being set after first iteration.", "[Battling, Scripting]" ) {
TEST_CASE("Script source with script ptr being set after first iteration.", "[Battling, Scripting]") {
auto source = ScriptSourceWithScriptPtr();
auto scripts = source.GetScriptIterator();
auto first = scripts.GetNext();
@ -65,25 +59,25 @@ TEST_CASE( "Script source with script ptr being set after first iteration.", "[B
delete source.ScriptPtr;
}
TEST_CASE( "Script source with empty script set.", "[Battling, Scripting]" ) {
TEST_CASE("Script source with empty script set.", "[Battling, Scripting]") {
auto source = ScriptSourceWithScriptSet();
auto scripts = source.GetScriptIterator();
auto first = scripts.GetNext();
CHECK(first == nullptr);
}
TEST_CASE( "Script source with single item script set.", "[Battling, Scripting]" ) {
TEST_CASE("Script source with single item script set.", "[Battling, Scripting]") {
auto source = ScriptSourceWithScriptSet();
auto s = new Script("foobar");
source.Set.Add(s);
auto scripts = source.GetScriptIterator();
auto first = scripts.GetNext();
CHECK(first != nullptr);
CHECK (first->GetName() == "foobar");
CHECK(first->GetName() == "foobar");
delete s;
}
TEST_CASE( "Script source with multiple item script set.", "[Battling, Scripting]" ) {
TEST_CASE("Script source with multiple item script set.", "[Battling, Scripting]") {
auto source = ScriptSourceWithScriptSet();
auto s = new Script("foobar");
auto s2 = new Script("foobar2");
@ -92,14 +86,12 @@ TEST_CASE( "Script source with multiple item script set.", "[Battling, Scripting
auto scripts = source.GetScriptIterator();
auto first = scripts.GetNext();
CHECK(first != nullptr);
CHECK (first->GetName() == "foobar");
CHECK(first->GetName() == "foobar");
auto second = scripts.GetNext();
CHECK(second != nullptr);
CHECK (second->GetName() == "foobar2");
CHECK(second->GetName() == "foobar2");
delete s;
delete s2;
}
#endif

56
tests/BattleTests/TurnOrderTests.cpp
View File

@ -1,23 +1,23 @@
#ifdef TESTS_BUILD
#include "../TestLibrary/TestLibrary.cpp"
#include "../../src/Battling/TurnChoices/PassTurnChoice.hpp"
#include "../../src/Battling/TurnChoices/AttackTurnChoice.hpp"
#include "../../src/Battling/Flow/TurnOrdering.hpp"
#include "../../src/Battling/TurnChoices/AttackTurnChoice.hpp"
#include "../../src/Battling/TurnChoices/PassTurnChoice.hpp"
#include "../TestLibrary/TestLibrary.cpp"
using namespace CreatureLib;
using namespace CreatureLib::Battling;
TEST_CASE( "Turn ordering: Attack before pass", "[Battling]" ) {
TEST_CASE("Turn ordering: Attack before pass", "[Battling]") {
auto choice1 = new PassTurnChoice(nullptr);
auto choice2 = new AttackTurnChoice(nullptr, nullptr, Target(0,0));
auto choice2 = new AttackTurnChoice(nullptr, nullptr, Target(0, 0));
auto vec = std::vector<BaseTurnChoice*>{choice1, choice2};
auto rand = Core::Random();
TurnOrdering::OrderChoices(vec,rand);
TurnOrdering::OrderChoices(vec, rand);
CHECK(vec[0] == choice2);
CHECK(vec[1] == choice1);
vec = std::vector<BaseTurnChoice*>{choice2, choice1};
TurnOrdering::OrderChoices(vec,rand);
TurnOrdering::OrderChoices(vec, rand);
CHECK(vec[0] == choice2);
CHECK(vec[1] == choice1);
@ -25,19 +25,19 @@ TEST_CASE( "Turn ordering: Attack before pass", "[Battling]" ) {
delete choice2;
}
TEST_CASE( "Turn ordering: High priority goes before no priority", "[Battling]" ) {
TEST_CASE("Turn ordering: High priority goes before no priority", "[Battling]") {
auto l = GetLibrary()->GetAttackLibrary();
auto a1 = new LearnedAttack(l->GetAttack("standard"), AttackLearnMethod::Unknown);
auto a2 = new LearnedAttack(l->GetAttack("highPriority"), AttackLearnMethod::Unknown);
auto choice1 = new AttackTurnChoice(nullptr, a1, Target(0,0));
auto choice2 = new AttackTurnChoice(nullptr, a2, Target(0,0));
auto choice1 = new AttackTurnChoice(nullptr, a1, Target(0, 0));
auto choice2 = new AttackTurnChoice(nullptr, a2, Target(0, 0));
auto vec = std::vector<BaseTurnChoice*>{choice1, choice2};
auto rand = Core::Random();
TurnOrdering::OrderChoices(vec,rand);
TurnOrdering::OrderChoices(vec, rand);
CHECK(vec[0] == choice2);
CHECK(vec[1] == choice1);
vec = std::vector<BaseTurnChoice*>{choice2, choice1};
TurnOrdering::OrderChoices(vec,rand);
TurnOrdering::OrderChoices(vec, rand);
CHECK(vec[0] == choice2);
CHECK(vec[1] == choice1);
@ -47,19 +47,19 @@ TEST_CASE( "Turn ordering: High priority goes before no priority", "[Battling]"
delete a2;
}
TEST_CASE( "Turn ordering: Higher priority goes before high priority", "[Battling]" ) {
TEST_CASE("Turn ordering: Higher priority goes before high priority", "[Battling]") {
auto l = GetLibrary()->GetAttackLibrary();
auto a1 = new LearnedAttack(l->GetAttack("highPriority"), AttackLearnMethod::Unknown);
auto a2 = new LearnedAttack(l->GetAttack("higherPriority"), AttackLearnMethod::Unknown);
auto choice1 = new AttackTurnChoice(nullptr, a1, Target(0,0));
auto choice2 = new AttackTurnChoice(nullptr, a2, Target(0,0));
auto choice1 = new AttackTurnChoice(nullptr, a1, Target(0, 0));
auto choice2 = new AttackTurnChoice(nullptr, a2, Target(0, 0));
auto vec = std::vector<BaseTurnChoice*>{choice1, choice2};
auto rand = Core::Random();
TurnOrdering::OrderChoices(vec,rand);
TurnOrdering::OrderChoices(vec, rand);
CHECK(vec[0] == choice2);
CHECK(vec[1] == choice1);
vec = std::vector<BaseTurnChoice*>{choice2, choice1};
TurnOrdering::OrderChoices(vec,rand);
TurnOrdering::OrderChoices(vec, rand);
CHECK(vec[0] == choice2);
CHECK(vec[1] == choice1);
@ -69,19 +69,19 @@ TEST_CASE( "Turn ordering: Higher priority goes before high priority", "[Battlin
delete a2;
}
TEST_CASE( "Turn ordering: High priority goes before low priority", "[Battling]" ) {
TEST_CASE("Turn ordering: High priority goes before low priority", "[Battling]") {
auto l = GetLibrary()->GetAttackLibrary();
auto a1 = new LearnedAttack(l->GetAttack("lowPriority"), AttackLearnMethod::Unknown);
auto a2 = new LearnedAttack(l->GetAttack("higherPriority"), AttackLearnMethod::Unknown);
auto choice1 = new AttackTurnChoice(nullptr, a1, Target(0,0));
auto choice2 = new AttackTurnChoice(nullptr, a2, Target(0,0));
auto choice1 = new AttackTurnChoice(nullptr, a1, Target(0, 0));
auto choice2 = new AttackTurnChoice(nullptr, a2, Target(0, 0));
auto vec = std::vector<BaseTurnChoice*>{choice1, choice2};
auto rand = Core::Random();
TurnOrdering::OrderChoices(vec,rand);
TurnOrdering::OrderChoices(vec, rand);
CHECK(vec[0] == choice2);
CHECK(vec[1] == choice1);
vec = std::vector<BaseTurnChoice*>{choice2, choice1};
TurnOrdering::OrderChoices(vec,rand);
TurnOrdering::OrderChoices(vec, rand);
CHECK(vec[0] == choice2);
CHECK(vec[1] == choice1);
@ -91,19 +91,19 @@ TEST_CASE( "Turn ordering: High priority goes before low priority", "[Battling]"
delete a2;
}
TEST_CASE( "Turn ordering: No priority goes before low priority", "[Battling]" ) {
TEST_CASE("Turn ordering: No priority goes before low priority", "[Battling]") {
auto l = GetLibrary()->GetAttackLibrary();
auto a1 = new LearnedAttack(l->GetAttack("lowPriority"), AttackLearnMethod::Unknown);
auto a2 = new LearnedAttack(l->GetAttack("standard"), AttackLearnMethod::Unknown);
auto choice1 = new AttackTurnChoice(nullptr, a1, Target(0,0));
auto choice2 = new AttackTurnChoice(nullptr, a2, Target(0,0));
auto choice1 = new AttackTurnChoice(nullptr, a1, Target(0, 0));
auto choice2 = new AttackTurnChoice(nullptr, a2, Target(0, 0));
auto vec = std::vector<BaseTurnChoice*>{choice1, choice2};
auto rand = Core::Random();
TurnOrdering::OrderChoices(vec,rand);
TurnOrdering::OrderChoices(vec, rand);
CHECK(vec[0] == choice2);
CHECK(vec[1] == choice1);
vec = std::vector<BaseTurnChoice*>{choice2, choice1};
TurnOrdering::OrderChoices(vec,rand);
TurnOrdering::OrderChoices(vec, rand);
CHECK(vec[0] == choice2);
CHECK(vec[1] == choice1);
@ -113,6 +113,4 @@ TEST_CASE( "Turn ordering: No priority goes before low priority", "[Battling]" )
delete a2;
}
#endif

14
tests/LibraryTests/CreatureTests.cpp
View File

@ -3,41 +3,41 @@
#include "../TestLibrary/TestLibrary.cpp"
using namespace CreatureLib::Library;
TEST_CASE( "Create basic creature", "[Library]" ) {
TEST_CASE("Create basic creature", "[Library]") {
auto library = GetLibrary();
auto creature = CreateCreature(library, "testSpecies1", 1).Create();
delete creature;
}
TEST_CASE( "Get creature species", "[Library]" ) {
TEST_CASE("Get creature species", "[Library]") {
auto library = GetLibrary();
auto creature = CreateCreature(library, "testSpecies1", 1).Create();
REQUIRE(creature->GetSpecies()->GetName() == "testSpecies1");
delete creature;
}
TEST_CASE( "Get creature level", "[Library]" ) {
TEST_CASE("Get creature level", "[Library]") {
auto library = GetLibrary();
auto creature = CreateCreature(library, "testSpecies1", 1).Create();
REQUIRE(creature->GetLevel() == 1);
delete creature;
}
TEST_CASE( "Get creature variant when unset", "[Library]" ) {
TEST_CASE("Get creature variant when unset", "[Library]") {
auto library = GetLibrary();
auto creature = CreateCreature(library, "testSpecies1", 1).Create();
REQUIRE(creature->GetVariant()->GetName() == "default");
delete creature;
}
TEST_CASE( "Get creature nickname when unset", "[Library]" ) {
TEST_CASE("Get creature nickname when unset", "[Library]") {
auto library = GetLibrary();
auto creature = CreateCreature(library, "testSpecies1", 1).Create();
REQUIRE(creature->GetNickname() == "testSpecies1");
delete creature;
}
TEST_CASE( "Get creature stat potentials when unset", "[Library]" ) {
TEST_CASE("Get creature stat potentials when unset", "[Library]") {
auto library = GetLibrary();
auto creature = CreateCreature(library, "testSpecies1", 1).Create();
auto potentials = creature->GetStatPotential();
@ -50,7 +50,7 @@ TEST_CASE( "Get creature stat potentials when unset", "[Library]" ) {
delete creature;
}
TEST_CASE( "Get creature stat experience when unset", "[Library]" ) {
TEST_CASE("Get creature stat experience when unset", "[Library]") {
auto library = GetLibrary();
auto creature = CreateCreature(library, "testSpecies1", 1).Create();
auto experiences = creature->GetStatExperience();

40
tests/LibraryTests/TestLibraryTests.cpp
View File

@ -4,34 +4,34 @@
#include "../../extern/catch.hpp"
#include "../TestLibrary/TestLibrary.cpp"
TEST_CASE( "Can Create Species Library", "[Library]" ) {
auto l = BuildSpeciesLibrary();
REQUIRE(l != nullptr);
delete l;
TEST_CASE("Can Create Species Library", "[Library]") {
auto l = BuildSpeciesLibrary();
REQUIRE(l != nullptr);
delete l;
}
TEST_CASE( "Can Create Attack Library", "[Library]" ) {
auto l = BuildAttackLibrary();
REQUIRE(l != nullptr);
delete l;
TEST_CASE("Can Create Attack Library", "[Library]") {
auto l = BuildAttackLibrary();
REQUIRE(l != nullptr);
delete l;
}
TEST_CASE( "Can Create Item Library", "[Library]" ) {
auto l = BuildItemLibrary();
REQUIRE(l != nullptr);
delete l;
TEST_CASE("Can Create Item Library", "[Library]") {
auto l = BuildItemLibrary();
REQUIRE(l != nullptr);
delete l;
}
TEST_CASE( "Can Create Growthrate Library", "[Library]" ) {
auto l = BuildGrowthRateLibrary();
REQUIRE(l != nullptr);
delete l;
TEST_CASE("Can Create Growthrate Library", "[Library]") {
auto l = BuildGrowthRateLibrary();
REQUIRE(l != nullptr);
delete l;
}
TEST_CASE( "Can Create Data Library", "[Library]" ) {
auto l = BuildLibrary();
REQUIRE(l != nullptr);
delete l;
TEST_CASE("Can Create Data Library", "[Library]") {
auto l = BuildLibrary();
REQUIRE(l != nullptr);
delete l;
}
#endif

44
tests/RandomTests.cpp
View File

@ -1,9 +1,9 @@
#ifdef TESTS_BUILD
#include "../extern/catch.hpp"
#include "../src/Core/Random.hpp"
#include "../src/Core/Exceptions/CreatureException.hpp"
#include "../src/Core/Random.hpp"
TEST_CASE( "Random ints", "[Utilities]" ) {
TEST_CASE("Random ints", "[Utilities]") {
auto rand = CreatureLib::Core::Random(10);
CHECK(rand.Get() == 1656398469);
CHECK(rand.Get() == 641584702);
@ -17,7 +17,7 @@ TEST_CASE( "Random ints", "[Utilities]" ) {
CHECK(rand.Get() == 1252673902);
}
TEST_CASE( "Random ints with limit", "[Utilities]" ) {
TEST_CASE("Random ints with limit", "[Utilities]") {
auto rand = CreatureLib::Core::Random(10);
CHECK(rand.Get(10) == 7);
CHECK(rand.Get(10) == 2);
@ -39,10 +39,9 @@ TEST_CASE( "Random ints with limit", "[Utilities]" ) {
CHECK(rand.Get(2) == 0);
CHECK(rand.Get(2) == 0);
CHECK(rand.Get(2) == 0);
}
TEST_CASE( "Random ints with upper and bottom", "[Utilities]" ) {
TEST_CASE("Random ints with upper and bottom", "[Utilities]") {
auto rand = CreatureLib::Core::Random(10);
CHECK(rand.Get(10, 30) == 25);
CHECK(rand.Get(10, 30) == 15);
@ -56,55 +55,60 @@ TEST_CASE( "Random ints with upper and bottom", "[Utilities]" ) {
CHECK(rand.Get(10, 30) == 21);
}
TEST_CASE( "Random distribution (max 0, min 1)", "[Utilities]" ) {
TEST_CASE("Random distribution (max 0, min 1)", "[Utilities]") {
auto rand = CreatureLib::Core::Random(10);
const int size = 100000;
int arr[size];
for (size_t i = 0; i < size; i++){
for (size_t i = 0; i < size; i++) {
arr[i] = rand.Get(0, 1);
}
for (size_t i = 0; i < size; i++){
for (size_t i = 0; i < size; i++) {
if (arr[i] != 0)
throw CreatureException("We expected a value of 0 here, but got a " + std::to_string(arr[i]));
}
}
TEST_CASE( "Random distribution (max 0, min 2)", "[Utilities]" ) {
TEST_CASE("Random distribution (max 0, min 2)", "[Utilities]") {
auto rand = CreatureLib::Core::Random(10);
const int size = 100000;
int arr[size];
for (size_t i = 0; i < size; i++){
for (size_t i = 0; i < size; i++) {
arr[i] = rand.Get(0, 2);
}
auto numZeros = 0;
auto numOnes = 0;
for (size_t i = 0; i < size; i++){
for (size_t i = 0; i < size; i++) {
if (arr[i] != 0 && arr[i] != 1)
throw CreatureException("We expected a value of 0 or 1 here, but got a " + std::to_string(arr[i]));
if (arr[i] == 0) numZeros++;
else numOnes++;
if (arr[i] == 0)
numZeros++;
else
numOnes++;
}
auto div = static_cast<float>(numZeros) / static_cast<float>(numOnes);
INFO("Distribution: " << numZeros << "/" << numOnes);
CHECK(Approx(div).margin(0.01) == 1);
}
TEST_CASE( "Random distribution (max 0, min 3)", "[Utilities]" ) {
TEST_CASE("Random distribution (max 0, min 3)", "[Utilities]") {
auto rand = CreatureLib::Core::Random(10);
const int size = 100000;
int arr[size];
for (size_t i = 0; i < size; i++){
for (size_t i = 0; i < size; i++) {
arr[i] = rand.Get(0, 3);
}
auto numZeros = 0;
auto numOnes = 0;
auto numTwos = 0;
for (size_t i = 0; i < size; i++){
for (size_t i = 0; i < size; i++) {
if (arr[i] != 0 && arr[i] != 1 && arr[i] != 2)
throw CreatureException("We expected a value between 0 and 2 here, but got a " + std::to_string(arr[i]));
if (arr[i] == 0) numZeros++;
else if (arr[i] == 1) numOnes++;
else numTwos++;
if (arr[i] == 0)
numZeros++;
else if (arr[i] == 1)
numOnes++;
else
numTwos++;
}
INFO("Distribution: " << numZeros << "/" << numOnes << "/" << numTwos);
CHECK(Approx(static_cast<float>(numZeros) / static_cast<float>(numOnes)).margin(0.01) == 1);
@ -112,6 +116,4 @@ TEST_CASE( "Random distribution (max 0, min 3)", "[Utilities]" ) {
CHECK(Approx(static_cast<float>(numOnes) / static_cast<float>(numTwos)).margin(0.01) == 1);
}
#endif

51
tests/TestLibrary/TestLibrary.cpp
View File

@ -7,41 +7,41 @@ using namespace CreatureLib::Library;
using namespace CreatureLib::Battling;
static BattleLibrary* __library = nullptr;
static SpeciesLibrary* BuildSpeciesLibrary(){
static SpeciesLibrary* BuildSpeciesLibrary() {
auto l = new SpeciesLibrary();
l->LoadSpecies("testSpecies1", new CreatureSpecies(0, "testSpecies1",
new SpeciesVariant("default", 1,1, 10, {0, 1},
StatisticSet<uint16_t >(10,10,10,10,10,10),
{"testTalent"}, {"testSecretTalent"},
new LearnableAttacks(100)),
l->LoadSpecies("testSpecies1",
new CreatureSpecies(
0, "testSpecies1",
new SpeciesVariant("default", 1, 1, 10, {0, 1}, StatisticSet<uint16_t>(10, 10, 10, 10, 10, 10),
{"testTalent"}, {"testSecretTalent"}, new LearnableAttacks(100)),
0.5f, "testGrowthRate", 5, 100));
return l;
}
static AttackLibrary* BuildAttackLibrary(){
static AttackLibrary* BuildAttackLibrary() {
auto l = new AttackLibrary();
l->LoadAttack("standard", new AttackData("standard", "normal", AttackCategory::Physical,
20, 100, 30, AttackTarget::AdjacentOpponent,0, {}));
l->LoadAttack("highPriority", new AttackData("highPriority", "normal", AttackCategory::Physical,
20, 100, 30, AttackTarget::AdjacentOpponent,1, {}));
l->LoadAttack("higherPriority", new AttackData("higherPriority", "normal", AttackCategory::Physical,
20, 100, 30, AttackTarget::AdjacentOpponent,2, {}));
l->LoadAttack("lowPriority", new AttackData("lowPriority", "normal", AttackCategory::Physical,
20, 100, 30, AttackTarget::AdjacentOpponent,-1, {}));
l->LoadAttack("standard", new AttackData("standard", "normal", AttackCategory::Physical, 20, 100, 30,
AttackTarget::AdjacentOpponent, 0, {}));
l->LoadAttack("highPriority", new AttackData("highPriority", "normal", AttackCategory::Physical, 20, 100, 30,
AttackTarget::AdjacentOpponent, 1, {}));
l->LoadAttack("higherPriority", new AttackData("higherPriority", "normal", AttackCategory::Physical, 20, 100, 30,
AttackTarget::AdjacentOpponent, 2, {}));
l->LoadAttack("lowPriority", new AttackData("lowPriority", "normal", AttackCategory::Physical, 20, 100, 30,
AttackTarget::AdjacentOpponent, -1, {}));
return l;
}
static ItemLibrary* BuildItemLibrary(){
static ItemLibrary* BuildItemLibrary() {
auto l = new ItemLibrary();
return l;
}
static GrowthRateLibrary* BuildGrowthRateLibrary(){
static GrowthRateLibrary* BuildGrowthRateLibrary() {
auto l = new GrowthRateLibrary();
return l;
}
static TypeLibrary* BuildTypeLibrary(){
static TypeLibrary* BuildTypeLibrary() {
auto l = new TypeLibrary();
l->RegisterType("testType1");
l->RegisterType("testType2");
@ -49,17 +49,16 @@ static TypeLibrary* BuildTypeLibrary(){
return l;
}
static BattleLibrary* BuildLibrary(){
auto l = new DataLibrary(LibrarySettings(100, 4), BuildSpeciesLibrary(), BuildAttackLibrary(),
BuildItemLibrary(), BuildGrowthRateLibrary(), BuildTypeLibrary());
auto battleLib = new BattleLibrary(l, new BattleStatCalculator(), new DamageLibrary(),
new CriticalLibrary(), new ScriptResolver());
static BattleLibrary* BuildLibrary() {
auto l = new DataLibrary(LibrarySettings(100, 4), BuildSpeciesLibrary(), BuildAttackLibrary(), BuildItemLibrary(),
BuildGrowthRateLibrary(), BuildTypeLibrary());
auto battleLib = new BattleLibrary(l, new BattleStatCalculator(), new DamageLibrary(), new CriticalLibrary(),
new ScriptResolver());
return battleLib;
}
[[maybe_unused]]
static BattleLibrary* GetLibrary(){
if (__library == nullptr){
[[maybe_unused]] static BattleLibrary* GetLibrary() {
if (__library == nullptr) {
__library = BuildLibrary();
}
return __library;