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

More aggressive sanitization. Loads of integer definition fixes
All checks were successful
continuous-integration/drone/push Build is passing
Details

Browse Source
This commit is contained in:
Deukhoofd
2022-03-25 19:08:42 +01:00
parent f6625a0bdf
commit 1b14f31bd7
68 changed files with 371 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/Battling/Battle/Battle.hpp
View File

@@ -13,8 +13,9 @@ namespace PkmnLib::Battling {
std::unique_ptr<CreatureLib::Battling::BattleScript> _weatherScript = nullptr;
public:
Battle(const BattleLibrary* library, const ArbUt::List<CreatureLib::Battling::BattleParty*>& parties,
bool canFlee = true, uint8_t numberOfSides = 2, uint8_t creaturesPerSide = 1,
Battle(const BattleLibrary* non_null library,
const ArbUt::List<CreatureLib::Battling::BattleParty * non_null>& parties, bool canFlee = true,
u8 numberOfSides = 2, u8 creaturesPerSide = 1,
uint_fast32_t randomSeed = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch())
.count())
@@ -48,7 +49,7 @@ namespace PkmnLib::Battling {
CreatureLib::Battling::ScriptWrapper::FromScript(&_weatherScript)));
}
Battle* Clone() const override;
Battle* non_null Clone() const override;
};
}

2
src/Battling/EventHooks/PkmnEventKind.hpp
View File

@@ -2,6 +2,6 @@
#define PKMNLIB_PKMNEVENTKIND_HPP
#include <CreatureLib/Battling/EventHooks/EventDataKind.hpp>
ENUM_WITH_START_VALUE(PkmnEventDataKind, uint8_t, 128, WeatherChange)
ENUM_WITH_START_VALUE(PkmnEventDataKind, u8, 128, WeatherChange)
#endif // PKMNLIB_PKMNEVENTKIND_HPP

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

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

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

@@ -12,9 +12,10 @@
namespace PkmnLib::Battling {
class BattleLibrary final : public CreatureLib::Battling::BattleLibrary {
public:
BattleLibrary(Library::PokemonLibrary* staticLib, StatCalculator* statCalculator, DamageLibrary* damageLibrary,
PkmnLib::Battling::ExperienceLibrary* experienceLibrary, ScriptResolver* scriptResolver,
PkmnLib::Battling::MiscLibrary* miscLibrary)
BattleLibrary(Library::PokemonLibrary* non_null staticLib, StatCalculator* non_null statCalculator,
DamageLibrary* non_null damageLibrary,
PkmnLib::Battling::ExperienceLibrary* non_null experienceLibrary,
ScriptResolver* non_null scriptResolver, PkmnLib::Battling::MiscLibrary* non_null miscLibrary)
: CreatureLib::Battling::BattleLibrary(staticLib, statCalculator, damageLibrary, experienceLibrary,
scriptResolver, miscLibrary) {}
@@ -43,7 +44,7 @@ namespace PkmnLib::Battling {
return GetStaticLib()->GetNatureLibrary();
}
static PkmnLib::Battling::ScriptResolver* CreateScriptResolver();
static PkmnLib::Battling::ScriptResolver* non_null CreateScriptResolver();
};
}
#endif // PKMNLIB_BATTLELIBRARY_HPP

4
src/Battling/Library/CaptureLibrary.cpp
View File

@@ -3,8 +3,8 @@
#include "../PkmnScriptHook.hpp"
namespace PkmnLib::Battling {
CaptureLibrary::CaptureResult CaptureLibrary::TryCatch(Pokemon* pokemon, Library::Item* catchItem,
ArbUt::Random* random) const {
CaptureLibrary::CaptureResult CaptureLibrary::TryCatch(Pokemon* non_null pokemon, Library::Item* non_null catchItem,
ArbUt::Random* non_null random) const {
auto hpMax = pokemon->GetMaxHealth();
auto hpCurrent = pokemon->GetCurrentHealth();
auto rate = pokemon->GetSpecies()->GetCaptureRate();

4
src/Battling/Library/CaptureLibrary.hpp
View File

@@ -12,9 +12,9 @@ namespace PkmnLib::Battling {
bool WasCritical;
};
CaptureResult TryCatch(Pokemon* pokemon, Library::Item* catchItem, ArbUt::Random* random) const;
CaptureResult TryCatch(Pokemon* non_null pokemon, Library::Item* non_null catchItem,
ArbUt::Random* non_null random) const;
};
}
#endif // PKMNLIB_CAPTURELIBRARY_HPP

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

@@ -9,18 +9,18 @@ namespace PkmnLib::Battling {
public:
explicit DamageLibrary(bool hasRandomness = true) : _hasRandomness(hasRandomness) {}
uint32_t GetDamage(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
uint8_t hitIndex,
uint32_t GetDamage(CreatureLib::Battling::ExecutingAttack* non_null attack,
CreatureLib::Battling::Creature* non_null target, uint8_t hitIndex,
const CreatureLib::Battling::ExecutingAttack::HitData& hitData) const override;
uint8_t GetBasePower(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
uint8_t hitIndex,
uint8_t GetBasePower(CreatureLib::Battling::ExecutingAttack* non_null attack,
CreatureLib::Battling::Creature* non_null target, uint8_t hitIndex,
const CreatureLib::Battling::ExecutingAttack::HitData& hitData) const override;
float GetStatModifier(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
uint8_t hitIndex,
float GetStatModifier(CreatureLib::Battling::ExecutingAttack* non_null attack,
CreatureLib::Battling::Creature* non_null target, uint8_t hitIndex,
const CreatureLib::Battling::ExecutingAttack::HitData& hitData) const override;
float GetDamageModifier(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
uint8_t hitIndex,
float GetDamageModifier(CreatureLib::Battling::ExecutingAttack* non_null attack,
CreatureLib::Battling::Creature* non_null target, uint8_t hitIndex,
const CreatureLib::Battling::ExecutingAttack::HitData& hitData) const override;
};
}

2
src/Battling/Library/ExperienceLibrary.hpp
View File

@@ -8,7 +8,7 @@ namespace PkmnLib::Battling {
class ExperienceLibrary final : public CreatureLib::Battling::ExperienceLibrary {
public:
void HandleExperienceGain(
CreatureLib::Battling::Creature* faintedMon,
CreatureLib::Battling::Creature* non_null faintedMon,
const std::unordered_set<ArbUt::BorrowedPtr<CreatureLib::Battling::Creature>>& opponents) const override;
};
}

11
src/Battling/Library/MiscLibrary.cpp
View File

@@ -6,8 +6,8 @@
#include "../Pokemon/LearnedMove.hpp"
#include "../Pokemon/Pokemon.hpp"
bool PkmnLib::Battling::MiscLibrary::IsCritical(CreatureLib::Battling::ExecutingAttack* attack,
CreatureLib::Battling::Creature* target, uint8_t hit) const {
bool PkmnLib::Battling::MiscLibrary::IsCritical(CreatureLib::Battling::ExecutingAttack* non_null attack,
CreatureLib::Battling::Creature* non_null target, uint8_t hit) const {
bool preventCrit = false;
PKMN_HOOK(PreventIncomingCritical, target, attack, target, hit, &preventCrit);
if (preventCrit) {
@@ -26,13 +26,12 @@ bool PkmnLib::Battling::MiscLibrary::IsCritical(CreatureLib::Battling::Executing
}
}
bool PkmnLib::Battling::MiscLibrary::CanFlee(CreatureLib::Battling::FleeTurnChoice* switchChoice) const {
bool PkmnLib::Battling::MiscLibrary::CanFlee(CreatureLib::Battling::FleeTurnChoice* non_null switchChoice) const {
return CreatureLib::Battling::MiscLibrary::CanFlee(switchChoice);
}
CreatureLib::Battling::BaseTurnChoice*
PkmnLib::Battling::MiscLibrary::ReplacementAttack(CreatureLib::Battling::Creature* user,
CreatureLib::Battling::CreatureIndex target) const {
CreatureLib::Battling::BaseTurnChoice* non_null PkmnLib::Battling::MiscLibrary::ReplacementAttack(
CreatureLib::Battling::Creature* non_null user, CreatureLib::Battling::CreatureIndex target) const {
return new CreatureLib::Battling::AttackTurnChoice(user, GetReplacementAttack(), target);
}

11
src/Battling/Library/MiscLibrary.hpp
View File

@@ -30,12 +30,11 @@ namespace PkmnLib::Battling {
MiscLibrary(std::function<PkmnLib::Library::TimeOfDay()> getTime) : _getTime(getTime) {}
~MiscLibrary() override = default;
bool IsCritical(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
uint8_t hit) const override;
bool CanFlee(CreatureLib::Battling::FleeTurnChoice* switchChoice) const override;
CreatureLib::Battling::BaseTurnChoice*
ReplacementAttack(CreatureLib::Battling::Creature* user,
CreatureLib::Battling::CreatureIndex target) const override;
bool IsCritical(CreatureLib::Battling::ExecutingAttack* non_null attack,
CreatureLib::Battling::Creature* non_null target, uint8_t hit) const override;
bool CanFlee(CreatureLib::Battling::FleeTurnChoice* non_null switchChoice) const override;
CreatureLib::Battling::BaseTurnChoice* non_null ReplacementAttack(
CreatureLib::Battling::Creature* non_null user, CreatureLib::Battling::CreatureIndex target) const override;
bool CanEvolveFromLevelUp(const ArbUt::BorrowedPtr<const PkmnLib::Library::EvolutionData>& evolution,
const ArbUt::BorrowedPtr<const Pokemon>& pokemon);

61
src/Battling/Library/StatCalculator.cpp
View File

@@ -1,21 +1,21 @@
#include "StatCalculator.hpp"
#include "../Pokemon/Pokemon.hpp"
uint32_t PkmnLib::Battling::StatCalculator::CalculateHealthStat(const Pokemon* pkmn) const {
uint32_t base = pkmn->GetBaseStat(Library::Statistic::HealthPoints);
uint32_t iv = pkmn->GetIndividualValue(Library::Statistic::HealthPoints);
uint32_t ev = pkmn->GetEffortValue(Library::Statistic::HealthPoints);
u32 PkmnLib::Battling::StatCalculator::CalculateHealthStat(const Pokemon* pkmn) const {
u32 base = pkmn->GetBaseStat(Library::Statistic::HealthPoints);
u32 iv = pkmn->GetIndividualValue(Library::Statistic::HealthPoints);
u32 ev = pkmn->GetEffortValue(Library::Statistic::HealthPoints);
uint8_t level = pkmn->GetLevel();
return static_cast<uint32_t>(((2 * base + iv + static_cast<uint32_t>(ev / 4)) * level) / 100) + level + 10;
return static_cast<u32>(((2 * base + iv + static_cast<u32>(ev / 4)) * level) / 100) + level + 10;
}
uint32_t PkmnLib::Battling::StatCalculator::CalculateOtherStat(const Pokemon* pkmn,
CreatureLib::Library::Statistic stat) const {
uint32_t base = pkmn->GetBaseStat(stat);
uint32_t iv = pkmn->GetIndividualValue(stat);
uint32_t ev = pkmn->GetEffortValue(stat);
u32 PkmnLib::Battling::StatCalculator::CalculateOtherStat(const Pokemon* pkmn,
CreatureLib::Library::Statistic stat) const {
u32 base = pkmn->GetBaseStat(stat);
u32 iv = pkmn->GetIndividualValue(stat);
u32 ev = pkmn->GetEffortValue(stat);
uint8_t level = pkmn->GetLevel();
uint32_t unmodified = static_cast<uint32_t>(((2 * base + iv + static_cast<uint32_t>(ev / 4)) * level) / 100) + 5;
return static_cast<uint32_t>(unmodified * pkmn->GetNature()->GetStatModifier(stat));
u32 unmodified = static_cast<u32>(((2 * base + iv + static_cast<u32>(ev / 4)) * level) / 100) + 5;
return static_cast<u32>(unmodified * pkmn->GetNature()->GetStatModifier(stat));
}
float PkmnLib::Battling::StatCalculator::GetStatBoostModifier(const CreatureLib::Battling::Creature* pkmn,
CreatureLib::Library::Statistic stat) const {
@@ -37,33 +37,32 @@ float PkmnLib::Battling::StatCalculator::GetStatBoostModifier(const CreatureLib:
default: throw ArbUt::Exception("Stat boost was out of expected range of -6 till 6.");
}
}
CreatureLib::Library::StatisticSet<uint32_t>
CreatureLib::Library::StatisticSet<u32>
PkmnLib::Battling::StatCalculator::CalculateFlatStats(CreatureLib::Battling::Creature* creature) const {
auto pkmn = dynamic_cast<Pokemon*>(creature);
return CreatureLib::Library::StatisticSet<uint32_t>(CalculateHealthStat(pkmn),
CalculateOtherStat(pkmn, Library::Statistic::PhysicalAttack),
CalculateOtherStat(pkmn, Library::Statistic::PhysicalDefense),
CalculateOtherStat(pkmn, Library::Statistic::SpecialAttack),
CalculateOtherStat(pkmn, Library::Statistic::SpecialDefense),
CalculateOtherStat(pkmn, Library::Statistic::Speed));
return CreatureLib::Library::StatisticSet<u32>(CalculateHealthStat(pkmn),
CalculateOtherStat(pkmn, Library::Statistic::PhysicalAttack),
CalculateOtherStat(pkmn, Library::Statistic::PhysicalDefense),
CalculateOtherStat(pkmn, Library::Statistic::SpecialAttack),
CalculateOtherStat(pkmn, Library::Statistic::SpecialDefense),
CalculateOtherStat(pkmn, Library::Statistic::Speed));
}
CreatureLib::Library::StatisticSet<uint32_t>
CreatureLib::Library::StatisticSet<u32>
PkmnLib::Battling::StatCalculator::CalculateBoostedStats(CreatureLib::Battling::Creature* creature) const {
return CreatureLib::Library::StatisticSet<uint32_t>(
CalculateBoostedStat(creature, Library::Statistic::HealthPoints),
CalculateBoostedStat(creature, Library::Statistic::PhysicalAttack),
CalculateBoostedStat(creature, Library::Statistic::PhysicalDefense),
CalculateBoostedStat(creature, Library::Statistic::SpecialAttack),
CalculateBoostedStat(creature, Library::Statistic::SpecialDefense),
CalculateBoostedStat(creature, Library::Statistic::Speed));
return CreatureLib::Library::StatisticSet<u32>(CalculateBoostedStat(creature, Library::Statistic::HealthPoints),
CalculateBoostedStat(creature, Library::Statistic::PhysicalAttack),
CalculateBoostedStat(creature, Library::Statistic::PhysicalDefense),
CalculateBoostedStat(creature, Library::Statistic::SpecialAttack),
CalculateBoostedStat(creature, Library::Statistic::SpecialDefense),
CalculateBoostedStat(creature, Library::Statistic::Speed));
}
uint32_t PkmnLib::Battling::StatCalculator::CalculateFlatStat(CreatureLib::Battling::Creature* creature,
CreatureLib::Library::Statistic stat) const {
u32 PkmnLib::Battling::StatCalculator::CalculateFlatStat(CreatureLib::Battling::Creature* creature,
CreatureLib::Library::Statistic stat) const {
if (stat == Library::Statistic::HealthPoints)
return CalculateHealthStat(dynamic_cast<Pokemon*>(creature));
return CalculateOtherStat(dynamic_cast<Pokemon*>(creature), stat);
}
uint32_t PkmnLib::Battling::StatCalculator::CalculateBoostedStat(CreatureLib::Battling::Creature* creature,
CreatureLib::Library::Statistic stat) const {
u32 PkmnLib::Battling::StatCalculator::CalculateBoostedStat(CreatureLib::Battling::Creature* creature,
CreatureLib::Library::Statistic stat) const {
return creature->GetFlatStat(stat) * GetStatBoostModifier(creature, stat);
}

22
src/Battling/Library/StatCalculator.hpp
View File

@@ -9,24 +9,24 @@ namespace PkmnLib::Battling {
class StatCalculator final : public CreatureLib::Battling::BattleStatCalculator {
protected:
virtual uint32_t CalculateHealthStat(const Pokemon* pkmn) const;
virtual uint32_t CalculateOtherStat(const Pokemon* pkmn, CreatureLib::Library::Statistic stat) const;
virtual float GetStatBoostModifier(const CreatureLib::Battling::Creature* pkmn,
virtual u32 CalculateHealthStat(const Pokemon* non_null pkmn) const;
virtual u32 CalculateOtherStat(const Pokemon* non_null pkmn, CreatureLib::Library::Statistic stat) const;
virtual float GetStatBoostModifier(const CreatureLib::Battling::Creature* non_null pkmn,
CreatureLib::Library::Statistic stat) const;
public:
~StatCalculator() override = default;
CreatureLib::Library::StatisticSet<uint32_t>
CalculateFlatStats(CreatureLib::Battling::Creature* creature) const override;
CreatureLib::Library::StatisticSet<u32>
CalculateFlatStats(CreatureLib::Battling::Creature* non_null creature) const override;
CreatureLib::Library::StatisticSet<uint32_t>
CalculateBoostedStats(CreatureLib::Battling::Creature* creature) const override;
CreatureLib::Library::StatisticSet<u32>
CalculateBoostedStats(CreatureLib::Battling::Creature* non_null creature) const override;
uint32_t CalculateFlatStat(CreatureLib::Battling::Creature* creature,
CreatureLib::Library::Statistic stat) const override;
u32 CalculateFlatStat(CreatureLib::Battling::Creature* non_null creature,
CreatureLib::Library::Statistic stat) const override;
uint32_t CalculateBoostedStat(CreatureLib::Battling::Creature* creature,
CreatureLib::Library::Statistic stat) const override;
u32 CalculateBoostedStat(CreatureLib::Battling::Creature* non_null creature,
CreatureLib::Library::Statistic stat) const override;
};
}

3
src/Battling/PkmnDamageSource.hpp
View File

@@ -3,6 +3,5 @@
#include <CreatureLib/Battling/Models/DamageSource.hpp>
ENUM_WITH_START_VALUE(PkmnDamageSource, uint8_t, ((uint8_t)CreatureLib::Battling::DamageSourceHelper::Highest()) + 1,
Struggle);
ENUM_WITH_START_VALUE(PkmnDamageSource, u8, ((u8)CreatureLib::Battling::DamageSourceHelper::Highest()) + 1, Struggle);
#endif // PKMNLIB_PKMNDAMAGESOURCE_HPP

2
src/Battling/PkmnItemUseScript.hpp
View File

@@ -7,7 +7,7 @@ namespace PkmnLib::Battling {
class PkmnItemUseScript : public CreatureLib::Battling::ItemUseScript {
public:
virtual void ModifyPokeballCatchBonus(Pokemon* pokemon, u8* catchBonus) const {
virtual void ModifyPokeballCatchBonus(Pokemon* non_null pokemon, u8* non_null catchBonus) const {
(void)pokemon;
(void)catchBonus;
}

47
src/Battling/PkmnScript.hpp
View File

@@ -16,28 +16,35 @@ namespace PkmnLib::Battling {
public:
PkmnScript(const ArbUt::OptionalBorrowedPtr<void>& owner) : CreatureLib::Battling::BattleScript(owner) {}
virtual void PreventIncomingCritical(CreatureLib::Battling::ExecutingAttack* attack,
CreatureLib::Battling::Creature* target, uint8_t hit, bool* preventCrit){};
virtual void ModifyCriticalStage(CreatureLib::Battling::ExecutingAttack* attack,
CreatureLib::Battling::Creature* target, uint8_t hit, uint8_t* critStage){};
virtual void OverrideCriticalModifier(CreatureLib::Battling::ExecutingAttack* attack,
CreatureLib::Battling::Creature* target, uint8_t hit,
float* critModifier){};
virtual void OverrideSTABModifier(CreatureLib::Battling::ExecutingAttack* attack,
CreatureLib::Battling::Creature* target, uint8_t hit, float* stabModifier){};
virtual void PreventIncomingCritical(CreatureLib::Battling::ExecutingAttack* non_null attack,
CreatureLib::Battling::Creature* non_null target, u8 hit,
bool* non_null preventCrit){};
virtual void ModifyCriticalStage(CreatureLib::Battling::ExecutingAttack* non_null attack,
CreatureLib::Battling::Creature* non_null target, u8 hit,
u8* non_null critStage){};
virtual void OverrideCriticalModifier(CreatureLib::Battling::ExecutingAttack* non_null attack,
CreatureLib::Battling::Creature* non_null target, u8 hit,
float* non_null critModifier){};
virtual void OverrideSTABModifier(CreatureLib::Battling::ExecutingAttack* non_null attack,
CreatureLib::Battling::Creature* non_null target, u8 hit,
float* non_null stabModifier){};
virtual void ModifyExperienceGain(CreatureLib::Battling::Creature* faintedMon,
CreatureLib::Battling::Creature* winningMon, uint32_t* experienceGain){};
virtual void DoesShareExperience(CreatureLib::Battling::Creature* faintedMon,
CreatureLib::Battling::Creature* winningMon, bool* shareExperience){};
virtual void BlockWeather(CreatureLib::Battling::Battle* battle, bool* blockWeather){};
virtual void ModifyExperienceGain(CreatureLib::Battling::Creature* non_null faintedMon,
CreatureLib::Battling::Creature* non_null winningMon,
uint32_t* non_null experienceGain){};
virtual void DoesShareExperience(CreatureLib::Battling::Creature* non_null faintedMon,
CreatureLib::Battling::Creature* non_null winningMon,
bool* non_null shareExperience){};
virtual void BlockWeather(CreatureLib::Battling::Battle* non_null battle, bool* non_null blockWeather){};
virtual void ModifyOffensiveStatValue(CreatureLib::Battling::ExecutingAttack* attack,
CreatureLib::Battling::Creature* target, u8 hitIndex, float* modifier){};
virtual void ModifyDefensiveStatValue(CreatureLib::Battling::ExecutingAttack* attack,
CreatureLib::Battling::Creature* target, u8 hitIndex, float* modifier){};
virtual void ModifyCaptureRateBonus(CreatureLib::Battling::Creature* pokemon,
CreatureLib::Library::Item* catchItem, u8* modifier){};
virtual void ModifyOffensiveStatValue(CreatureLib::Battling::ExecutingAttack* non_null attack,
CreatureLib::Battling::Creature* non_null target, u8 hitIndex,
float* non_null modifier){};
virtual void ModifyDefensiveStatValue(CreatureLib::Battling::ExecutingAttack* non_null attack,
CreatureLib::Battling::Creature* non_null target, u8 hitIndex,
float* non_null modifier){};
virtual void ModifyCaptureRateBonus(CreatureLib::Battling::Creature* non_null pokemon,
CreatureLib::Library::Item* non_null catchItem, u8* non_null modifier){};
};
}

2
src/Battling/PkmnScriptCategory.hpp
View File

@@ -2,6 +2,6 @@
#define PKMNLIB_PKMNSCRIPTCATEGORY_HPP
#include <CreatureLib/Battling/ScriptHandling/ScriptCategory.hpp>
ENUM_WITH_START_VALUE(PkmnScriptCategory, uint8_t, 128, Weather)
ENUM_WITH_START_VALUE(PkmnScriptCategory, u8, 128, Weather)
#endif // PKMNLIB_PKMNSCRIPTCATEGORY_HPP

22
src/Battling/Pokemon/CreatePokemon.cpp
View File

@@ -1,6 +1,6 @@
#include "CreatePokemon.hpp"
namespace PkmnLib::Battling {
CreatePokemon& CreatePokemon::WithRandomIndividualValues(ArbUt::Random rand) {
CreatePokemon& CreatePokemon::WithRandomIndividualValues(ArbUt::Random& rand) {
_ivHp = rand.Get(0, 32);
_ivAttack = rand.Get(0, 32);
_ivDefense = rand.Get(0, 32);
@@ -10,7 +10,7 @@ namespace PkmnLib::Battling {
return *this;
}
CreatePokemon& CreatePokemon::WithIndividualValue(CreatureLib::Library::Statistic stat, uint8_t value) {
CreatePokemon& CreatePokemon::WithIndividualValue(CreatureLib::Library::Statistic stat, u8 value) {
switch (stat) {
case PkmnLib::Library::Statistic::HealthPoints: _ivHp = value; break;
case PkmnLib::Library::Statistic::PhysicalAttack: _ivAttack = value; break;
@@ -22,7 +22,7 @@ namespace PkmnLib::Battling {
return *this;
}
CreatePokemon& CreatePokemon::WithEffortValue(CreatureLib::Library::Statistic stat, uint8_t value) {
CreatePokemon& CreatePokemon::WithEffortValue(CreatureLib::Library::Statistic stat, u8 value) {
switch (stat) {
case PkmnLib::Library::Statistic::HealthPoints: _evHp = value; break;
case PkmnLib::Library::Statistic::PhysicalAttack: _evAttack = value; break;
@@ -55,7 +55,7 @@ namespace PkmnLib::Battling {
}
auto identifier = this->_identifier;
if (identifier == 0) {
identifier = rand.Get();
identifier = rand.GetUnsigned();
}
auto gender = this->_gender;
if (gender == static_cast<CreatureLib::Library::Gender>(-1)) {
@@ -80,10 +80,10 @@ namespace PkmnLib::Battling {
attacks[i] = new LearnedMove(move.GetValue(), kv.LearnMethod);
}
}
auto ivs = CreatureLib::Library::ClampedStatisticSet<uint8_t, 0, 31>(_ivHp, _ivAttack, _ivDefense, _ivSpAtt,
_ivSpDef, _ivSpeed);
auto evs = CreatureLib::Library::ClampedStatisticSet<uint8_t, 0, 252>(_evHp, _evAttack, _evDefense, _evSpAtt,
_evSpDef, _evSpeed);
auto ivs = CreatureLib::Library::ClampedStatisticSet<u8, 0, 31>(_ivHp, _ivAttack, _ivDefense, _ivSpAtt,
_ivSpDef, _ivSpeed);
auto evs = CreatureLib::Library::ClampedStatisticSet<u8, 0, 252>(_evHp, _evAttack, _evDefense, _evSpAtt,
_evSpDef, _evSpeed);
if (_nature.IsEmpty()) {
_nature = _library->GetNatureLibrary()->GetRandomNatureName(rand);
@@ -106,8 +106,7 @@ namespace PkmnLib::Battling {
_nature = nature;
return *this;
}
CreatePokemon& CreatePokemon::WithIndividualValues(uint8_t hp, uint8_t att, uint8_t def, uint8_t spAtt,
uint8_t spDef, uint8_t speed) {
CreatePokemon& CreatePokemon::WithIndividualValues(u8 hp, u8 att, u8 def, u8 spAtt, u8 spDef, u8 speed) {
_ivHp = hp;
_ivAttack = att;
_ivDefense = def;
@@ -116,8 +115,7 @@ namespace PkmnLib::Battling {
_ivSpeed = speed;
return *this;
}
CreatePokemon& CreatePokemon::WithEffortValues(uint8_t hp, uint8_t att, uint8_t def, uint8_t spAtt, uint8_t spDef,
uint8_t speed) {
CreatePokemon& CreatePokemon::WithEffortValues(u8 hp, u8 att, u8 def, u8 spAtt, u8 spDef, u8 speed) {
_evHp = hp;
_evAttack = att;
_evDefense = def;

42
src/Battling/Pokemon/CreatePokemon.hpp
View File

@@ -15,7 +15,7 @@ namespace PkmnLib::Battling {
ArbUt::StringView _nature;
CreatureLib::Library::Gender _gender = static_cast<CreatureLib::Library::Gender>(-1);
ArbUt::StringView _heldItem = ""_cnc;
uint32_t _identifier = 0;
u32 _identifier = 0;
struct ToLearnMethod {
ArbUt::OptionalBorrowedPtr<const Library::MoveData> Move;
@@ -25,28 +25,28 @@ namespace PkmnLib::Battling {
: Move(move), LearnMethod(method){};
};
ArbUt::List<ToLearnMethod> _attacks;
uint8_t _currentMove = 0;
u8 _currentMove = 0;
uint8_t _ivHp = 0;
uint8_t _ivAttack = 0;
uint8_t _ivDefense = 0;
uint8_t _ivSpAtt = 0;
uint8_t _ivSpDef = 0;
uint8_t _ivSpeed = 0;
u8 _ivHp = 0;
u8 _ivAttack = 0;
u8 _ivDefense = 0;
u8 _ivSpAtt = 0;
u8 _ivSpDef = 0;
u8 _ivSpeed = 0;
uint8_t _evHp = 0;
uint8_t _evAttack = 0;
uint8_t _evDefense = 0;
uint8_t _evSpAtt = 0;
uint8_t _evSpDef = 0;
uint8_t _evSpeed = 0;
u8 _evHp = 0;
u8 _evAttack = 0;
u8 _evDefense = 0;
u8 _evSpAtt = 0;
u8 _evSpDef = 0;
u8 _evSpeed = 0;
bool _shininessSet = false;
bool _isShiny = false;
bool _allowedExperienceGain = true;
public:
CreatePokemon(const BattleLibrary* library, const ArbUt::StringView& species, uint8_t level)
CreatePokemon(const BattleLibrary* library, const ArbUt::StringView& species, u8 level)
: _library(library), _species(species), _level(level),
_attacks(library->GetSettings()->GetMaximalAttacks()) {}
@@ -56,13 +56,11 @@ namespace PkmnLib::Battling {
CreatePokemon& WithHeldItem(const ArbUt::StringView& item);
CreatePokemon& LearnMove(const ArbUt::StringView& move, CreatureLib::Battling::AttackLearnMethod method);
CreatePokemon& WithRandomIndividualValues(ArbUt::Random rand = ArbUt::Random());
CreatePokemon& WithIndividualValue(CreatureLib::Library::Statistic stat, uint8_t value);
CreatePokemon& WithIndividualValues(uint8_t hp, uint8_t att, uint8_t def, uint8_t spAtt, uint8_t spDef,
uint8_t speed);
CreatePokemon& WithEffortValue(CreatureLib::Library::Statistic stat, uint8_t value);
CreatePokemon& WithEffortValues(uint8_t hp, uint8_t att, uint8_t def, uint8_t spAtt, uint8_t spDef,
uint8_t speed);
CreatePokemon& WithRandomIndividualValues(ArbUt::Random& rand);
CreatePokemon& WithIndividualValue(CreatureLib::Library::Statistic stat, u8 value);
CreatePokemon& WithIndividualValues(u8 hp, u8 att, u8 def, u8 spAtt, u8 spDef, u8 speed);
CreatePokemon& WithEffortValue(CreatureLib::Library::Statistic stat, u8 value);
CreatePokemon& WithEffortValues(u8 hp, u8 att, u8 def, u8 spAtt, u8 spDef, u8 speed);
CreatePokemon& WithNature(const ArbUt::StringView& nature);
CreatePokemon& IsAllowedExperienceGain(bool value);

1
src/Battling/Pokemon/LearnedMove.cpp
View File

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

2
src/Battling/Pokemon/LearnedMove.hpp
View File

@@ -14,7 +14,7 @@ namespace PkmnLib::Battling {
return GetAttack().ForceAs<const Library::MoveData>();
}
LearnedAttack* Clone() const override {
LearnedAttack* non_null Clone() const override {
auto move = new LearnedMove(GetAttack().ForceAs<const Library::MoveData>(), GetLearnMethod());
move->DecreaseUses(GetMaxUses() - GetRemainingUses());
return move;

34
src/Battling/Pokemon/Pokemon.hpp
View File

@@ -10,23 +10,23 @@
namespace PkmnLib::Battling {
class Pokemon : public CreatureLib::Battling::Creature {
private:
CreatureLib::Library::ClampedStatisticSet<uint8_t, 0, 31> _individualValues;
CreatureLib::Library::ClampedStatisticSet<uint8_t, 0, 252> _effortValues;
CreatureLib::Library::ClampedStatisticSet<u8, 0, 31> _individualValues;
CreatureLib::Library::ClampedStatisticSet<u8, 0, 252> _effortValues;
ArbUt::BorrowedPtr<const PkmnLib::Library::Nature> _nature;
uint8_t _friendship = 0;
u8 _friendship = 0;
bool _isEgg;
public:
Pokemon(ArbUt::BorrowedPtr<const BattleLibrary> library,
const ArbUt::BorrowedPtr<const Library::PokemonSpecies>& species,
const ArbUt::BorrowedPtr<const Library::PokemonForme>& forme, level_int_t level, uint32_t experience,
uint32_t uid, CreatureLib::Library::Gender gender, uint8_t coloring,
const ArbUt::BorrowedPtr<const Library::PokemonForme>& forme, level_int_t level, u32 experience,
u32 uid, CreatureLib::Library::Gender gender, u8 coloring,
ArbUt::OptionalBorrowedPtr<const Library::Item> heldItem, const std::optional<std::string>& nickname,
const CreatureLib::Library::TalentIndex& talent,
const std::vector<CreatureLib::Battling::LearnedAttack*>& moves,
CreatureLib::Library::ClampedStatisticSet<uint8_t, 0, 31> individualValues,
CreatureLib::Library::ClampedStatisticSet<uint8_t, 0, 252> effortValues,
CreatureLib::Library::ClampedStatisticSet<u8, 0, 31> individualValues,
CreatureLib::Library::ClampedStatisticSet<u8, 0, 252> effortValues,
ArbUt::BorrowedPtr<const PkmnLib::Library::Nature> nature, bool allowedExperienceGain = true,
bool isEgg = false)
: CreatureLib::Battling::Creature(
@@ -48,16 +48,14 @@ namespace PkmnLib::Battling {
}
inline const ArbUt::BorrowedPtr<const PkmnLib::Library::Nature>& GetNature() const noexcept { return _nature; }
inline uint8_t GetIndividualValue(CreatureLib::Library::Statistic stat) const {
inline u8 GetIndividualValue(CreatureLib::Library::Statistic stat) const {
return _individualValues.GetStat(stat);
}
inline void SetIndividualValue(CreatureLib::Library::Statistic stat, uint8_t value) {
inline void SetIndividualValue(CreatureLib::Library::Statistic stat, u8 value) {
return _individualValues.SetStat(stat, value);
}
inline uint8_t GetEffortValue(CreatureLib::Library::Statistic stat) const {
return _effortValues.GetStat(stat);
}
inline void SetEffortValue(CreatureLib::Library::Statistic stat, uint8_t value) {
inline u8 GetEffortValue(CreatureLib::Library::Statistic stat) const { return _effortValues.GetStat(stat); }
inline void SetEffortValue(CreatureLib::Library::Statistic stat, u8 value) {
return _effortValues.SetStat(stat, value);
}
inline bool IsEgg() const noexcept { return _isEgg; }
@@ -70,10 +68,10 @@ namespace PkmnLib::Battling {
void Evolve(ArbUt::BorrowedPtr<const Library::PokemonSpecies> mon,
ArbUt::BorrowedPtr<const Library::PokemonForme> forme);
uint8_t GetFriendship() const noexcept { return _friendship; }
void SetFriendship(uint8_t value) noexcept { _friendship = value; }
void ChangeFriendship(int8_t amount) noexcept {
uint8_t newValue;
u8 GetFriendship() const noexcept { return _friendship; }
void SetFriendship(u8 value) noexcept { _friendship = value; }
void ChangeFriendship(i8 amount) noexcept {
u8 newValue;
if (__builtin_add_overflow(_friendship, amount, &newValue)) {
if (amount < 0)
newValue = 0;
@@ -85,7 +83,7 @@ namespace PkmnLib::Battling {
bool IsUsable() const noexcept override;
Creature* Clone() const override;
Creature* non_null Clone() const override;
};
}

6
src/Battling/Pokemon/PokemonParty.hpp
View File

@@ -6,9 +6,9 @@
namespace PkmnLib::Battling {
class PokemonParty : public CreatureLib::Battling::CreatureParty {
public:
PokemonParty(ArbUt::List<CreatureLib::Battling::Creature*> party)
PokemonParty(ArbUt::List<CreatureLib::Battling::Creature * nullable> party)
: CreatureLib::Battling::CreatureParty(std::move(party)) {}
PokemonParty(std::initializer_list<CreatureLib::Battling::Creature*> party)
PokemonParty(std::initializer_list<CreatureLib::Battling::Creature* nullable> party)
: CreatureLib::Battling::CreatureParty(party) {}
PokemonParty(size_t size) : CreatureLib::Battling::CreatureParty(size) {}
@@ -16,7 +16,7 @@ namespace PkmnLib::Battling {
return CreatureLib::Battling::CreatureParty::GetAtIndex(index).As<Pokemon>();
}
CreatureParty* Clone() const override {
CreatureParty* non_null Clone() const override {
auto party = new PokemonParty(GetParty().Count());
auto i = 0;
for (auto c : GetParty()) {