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

Remove GetProperty macro, as it wasn't that intuitive, and caused issues later.
continuous-integration/drone/push Build is passing Details

This commit is contained in:
Deukhoofd 2020-01-12 17:04:42 +01:00
parent 779f0b08cf
commit b02577554f
Signed by: Deukhoofd
GPG Key ID: ADF2E9256009EDCE
12 changed files with 95 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -10,20 +10,20 @@ Battling::Creature::Creature(const BattleLibrary* library, const Library::Creatu
const Library::SpeciesVariant* variant, uint8_t level, uint32_t experience, uint32_t uid,
Library::Gender gender, uint8_t coloring, const Library::Item* heldItem,
std::string nickname, int8_t talent, std::vector<LearnedAttack*> attacks)
: _library(library), __Species(species), __Variant(variant), __Level(level), __Experience(experience),
__UniqueIdentifier(uid), __Gender(gender), __Coloring(coloring), __HeldItem(heldItem),
_nickname(std::move(nickname)), _talentIndex(talent), _hasOverridenTalent(false), _attacks(std::move(attacks)) {
: _library(library), _species(species), _variant(variant), _level(level), _experience(experience),
_uniqueIdentifier(uid), _gender(gender), _coloring(coloring), _heldItem(heldItem), _nickname(std::move(nickname)),
_talentIndex(talent), _hasOverridenTalent(false), _attacks(std::move(attacks)) {
_activeTalent = _library->LoadScript(ScriptResolver::ScriptCategory::Talent, GetActiveTalent());
}
void Battling::Creature::ChangeLevel(int8_t amount) {
this->__Level += amount;
this->_level += amount;
RecalculateFlatStats();
}
const std::string& Battling::Creature::GetNickname() const {
if (_nickname.empty())
return __Species->GetName();
return _species->GetName();
return _nickname;
}
@ -31,7 +31,7 @@ const std::string& Battling::Creature::GetActiveTalent() const {
if (_hasOverridenTalent) {
return _overridenTalentName;
}
return __Variant->GetTalent(_talentIndex);
return _variant->GetTalent(_talentIndex);
}
void Battling::Creature::SetBattleData(Battling::Battle* battle, Battling::BattleSide* side) {
@ -53,7 +53,7 @@ uint32_t Battling::Creature::GetFlatStat(Core::Statistic stat) const { return _f
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); }
int8_t Battling::Creature::GetStatBoost(Core::Statistic stat) const { return _statBoost.GetStat(stat); }
@ -83,7 +83,7 @@ Battling::Battle* Battling::Creature::GetBattle() const { return _battle; }
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::OnFaint() {
// HOOK: On Faint
@ -96,13 +96,13 @@ void Battling::Creature::OnFaint() {
}
void Battling::Creature::Damage(uint32_t damage, Battling::DamageSource source) {
if (damage > __CurrentHealth) {
damage = __CurrentHealth;
if (damage > _currentHealth) {
damage = _currentHealth;
}
// HOOK: On Damage
auto newHealth = __CurrentHealth - damage;
this->GetBattle()->TriggerEventListener(new DamageEvent(this, source, __CurrentHealth, newHealth));
__CurrentHealth = newHealth;
auto newHealth = _currentHealth - damage;
this->GetBattle()->TriggerEventListener(new DamageEvent(this, source, _currentHealth, newHealth));
_currentHealth = newHealth;
if (IsFainted() && damage > 0) {
OnFaint();
@ -117,7 +117,7 @@ void Battling::Creature::OverrideActiveTalent(const std::string& talent) {
const std::vector<uint8_t>& Battling::Creature::GetTypes() const {
// HOOK: override types.
return this->__Variant->GetTypes();
return this->_variant->GetTypes();
}
bool Battling::Creature::HasType(uint8_t type) const {
@ -134,24 +134,24 @@ void Battling::Creature::GetActiveScripts(std::vector<ScriptWrapper>& scripts) {
void Battling::Creature::ClearVolatileScripts() { _volatile.Clear(); }
void Battling::Creature::AddExperience(uint32_t amount) {
auto maxLevel = _library->GetSettings().GetMaximalLevel();
if (__Level >= maxLevel) {
if (_level >= maxLevel) {
return;
}
auto exp = __Experience + amount;
auto exp = _experience + amount;
auto level = _library->GetGrowthRateLibrary()->CalculateLevel(this->GetSpecies()->GetGrowthRate(), exp);
if (level >= maxLevel) {
exp = _library->GetGrowthRateLibrary()->CalculateExperience(this->GetSpecies()->GetGrowthRate(), maxLevel);
}
__Experience = exp;
__Level = level;
_experience = exp;
_level = level;
}
const Library::CreatureSpecies* Battling::Creature::GetDisplaySpecies() {
auto species = __Species;
auto species = _species;
HOOK(OverrideDisplaySpecies, this, this, &species);
return species;
}
const Library::SpeciesVariant* Battling::Creature::GetDisplayVariant() {
auto variant = __Variant;
auto variant = _variant;
HOOK(OverrideDisplayVariant, this, this, &variant);
return variant;
}

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

@ -1,7 +1,6 @@
#ifndef CREATURELIB_BATTLECREATURE_HPP
#define CREATURELIB_BATTLECREATURE_HPP
#include "../../GenericTemplates.hpp"
#include "../../Library/CreatureData/CreatureSpecies.hpp"
#include "../../Library/Items/Item.hpp"
#include "../ScriptHandling/ScriptAggregator.hpp"
@ -20,18 +19,17 @@ namespace CreatureLib::Battling {
protected:
const BattleLibrary* _library;
GetProperty(const Library::CreatureSpecies*, Species);
GetProperty(const Library::SpeciesVariant*, Variant);
const Library::CreatureSpecies* _species;
const Library::SpeciesVariant* _variant;
GetProperty(uint8_t, Level);
GetProperty(uint32_t, Experience);
GetProperty(uint32_t, UniqueIdentifier);
GetProperty(Library::Gender, Gender);
GetProperty(uint8_t, Coloring);
GetProperty(const Library::Item*, HeldItem);
GetProperty(uint32_t, CurrentHealth);
uint8_t _level;
uint32_t _experience;
uint32_t _uniqueIdentifier;
Library::Gender _gender;
uint8_t _coloring;
const Library::Item* _heldItem;
uint32_t _currentHealth;
protected:
Core::StatisticSet<int8_t> _statBoost;
Core::StatisticSet<uint32_t> _flatStats;
Core::StatisticSet<uint32_t> _boostedStats;
@ -70,9 +68,18 @@ namespace CreatureLib::Battling {
virtual void Initialize() {
RecalculateFlatStats();
__CurrentHealth = GetBoostedStat(Core::Statistic::Health);
_currentHealth = GetBoostedStat(Core::Statistic::Health);
}
inline const Library::CreatureSpecies* GetSpecies() const { return _species; }
inline const Library::SpeciesVariant* GetVariant() const { return _variant; }
inline uint8_t GetLevel() const { return _level; }
inline uint32_t GetExperience() const { return _experience; }
inline Library::Gender GetGender() const { return _gender; }
inline uint8_t GetColoring() const { return _coloring; }
inline const Library::Item* GetHeldItem() const { return _heldItem; }
inline uint32_t GetCurrentHealth() const { return _currentHealth; }
void SetBattleData(Battle* battle, BattleSide* side);
Battle* GetBattle() const;
BattleSide* GetBattleSide() const;

1
src/Core/StatisticSet.hpp
View File

@ -2,7 +2,6 @@
#define CREATURELIB_STATISTICSET_HPP
#include <exception>
#include <stdint.h>
#include "../GenericTemplates.hpp"
#include "Exceptions/NotReachableException.hpp"
#include "Statistic.hpp"

23
src/GenericTemplates.hpp
View File

@ -1,23 +0,0 @@
/*!
\brief GetProperty creates a simple wrapper for a field, creating a private field, and a public getter method.
*/
#define GetProperty(type, name) \
protected: \
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; };

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

@ -6,8 +6,8 @@ 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 {
return this->_flags.find(key) != this->_flags.end();

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

@ -3,28 +3,35 @@
#include <string>
#include <unordered_set>
#include "../../GenericTemplates.hpp"
#include "AttackCategory.hpp"
#include "AttackTarget.hpp"
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(AttackTarget, Target);
GetProperty(uint8_t, Priority);
private:
protected:
const std::string _name;
const std::string _type;
AttackCategory _category;
uint8_t _basePower;
uint8_t _accuracy;
uint8_t _baseUsages;
AttackTarget _target;
int8_t _priority;
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);
inline const std::string& GetName() const { return _name; }
inline const std::string& GetType() const { return _type; }
inline AttackCategory GetCategory() const { return _category; }
inline uint8_t GetBasePower() const { return _basePower; }
inline uint8_t GetAccuracy() const { return _accuracy; }
inline uint8_t GetBaseUsages() const { return _baseUsages; }
inline AttackTarget GetTarget() const { return _target; }
inline int8_t GetPriority() const { return _priority; }
bool HasFlag(const std::string& key) const;
};
}

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

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

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

@ -12,10 +12,10 @@ namespace CreatureLib::Library {
creatures with.
*/
class CreatureSpecies {
GetProperty(uint16_t, Id);
GetProperty(float, GenderRate);
GetProperty(std::string, GrowthRate);
GetProperty(uint8_t, CaptureRate);
uint16_t _id;
float _genderRate;
std::string _growthRate;
uint8_t _captureRate;
private:
std::unordered_map<std::string, const SpeciesVariant*> _variants;
@ -31,6 +31,11 @@ namespace CreatureLib::Library {
_variants.clear();
}
inline uint16_t GetId() const { return _id; }
inline float GetGenderRate() const { return _genderRate; }
inline const std::string& GetGrowthRate() const { return _growthRate; }
inline uint8_t GetCaptureRate() const { return _captureRate; }
[[nodiscard]] const SpeciesVariant* GetVariant(const std::string& key) const;
[[nodiscard]] Gender GetRandomGender(Core::Random& rand) const;
[[nodiscard]] const std::string& GetName() const;

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

@ -50,7 +50,7 @@ CreatureLib::Library::SpeciesVariant::SpeciesVariant(std::string name, float hei
std::vector<std::string> talents,
std::vector<std::string> secretTalents,
const LearnableAttacks* attacks)
: __Name(std::move(name)), __Height(height), __Weight(weight), __BaseExperience(baseExperience),
: _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) {}

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

@ -5,7 +5,6 @@
#include <vector>
#include "../../Core/Random.hpp"
#include "../../Core/StatisticSet.hpp"
#include "../../GenericTemplates.hpp"
#include "CreatureMoves.hpp"
#include "LearnableAttacks.hpp"
@ -14,10 +13,11 @@ namespace CreatureLib::Library {
\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);
protected:
std::string _name;
float _height;
float _weight;
uint32_t _baseExperience;
private:
std::vector<uint8_t> _types;
@ -34,6 +34,11 @@ namespace CreatureLib::Library {
~SpeciesVariant();
inline const std::string& GetName() const { return _name; }
inline float GetHeight() const { return _height; }
inline float GetWeight() const { return _weight; }
inline uint32_t GetBaseExperience() const { return _baseExperience; }
[[nodiscard]] size_t GetTypeCount() const;
[[nodiscard]] uint8_t GetType(size_t index) const;
[[nodiscard]] const std::vector<uint8_t>& GetTypes() const;

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

@ -3,3 +3,7 @@
bool CreatureLib::Library::Item::HasFlag(const std::string& flag) const {
return this->_flags.find(flag) != this->_flags.end();
}
CreatureLib::Library::Item::Item(std::string name, CreatureLib::Library::ItemCategory category,
CreatureLib::Library::BattleItemCategory battleCategory, int32_t price,
std::unordered_set<std::string> flags)
: _name(name), _category(category), _battleCategory(battleCategory), _price(price), _flags(flags) {}

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

@ -3,24 +3,27 @@
#include <string>
#include <unordered_set>
#include "../../GenericTemplates.hpp"
#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);
private:
protected:
std::string _name;
ItemCategory _category;
BattleItemCategory _battleCategory;
int32_t _price;
std::unordered_set<std::string> _flags;
public:
Item(std::string name, ItemCategory category, BattleItemCategory battleCategory, int32_t price,
std::unordered_set<std::string> flags);
inline const std::string GetName() const { return _name; }
inline ItemCategory GetCategory() const { return _category; }
inline BattleItemCategory GetBattleCategory() const { return _battleCategory; }
inline const int32_t GetPrice() const { return _price; }
bool HasFlag(const std::string& flag) const;
};
}