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

Update to the latest CreatureLib version.

Browse Source
This commit is contained in:
Deukhoofd
2020-04-06 20:03:44 +02:00
parent 29a82a5e75
commit 48ef465c82
41 changed files with 297 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -7,7 +7,7 @@
namespace PkmnLib::Battling {
class Battle : public CreatureLib::Battling::Battle {
public:
Battle(const BattleLibrary* library, const std::vector<CreatureLib::Battling::BattleParty>& parties,
Battle(const BattleLibrary* library, const List<CreatureLib::Battling::BattleParty*>& parties,
bool canFlee = true, uint8_t numberOfSides = 2, uint8_t creaturesPerSide = 1)
: CreatureLib::Battling::Battle(library, parties, canFlee, numberOfSides, creaturesPerSide) {}
};

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

@@ -1,6 +1,6 @@
#include "DamageLibrary.hpp"
#include "../Pokemon/Pokemon.hpp"
int PkmnLib::Battling::DamageLibrary::GetDamage(CreatureLib::Battling::ExecutingAttack* attack,
uint32_t PkmnLib::Battling::DamageLibrary::GetDamage(CreatureLib::Battling::ExecutingAttack* attack,
CreatureLib::Battling::Creature* target, uint8_t hitIndex) const {
auto levelMod = static_cast<float>(2 * attack->GetUser()->GetLevel());
auto hit = attack->GetAttackDataForTarget(target)->GetHit(hitIndex);
@@ -12,7 +12,7 @@ int PkmnLib::Battling::DamageLibrary::GetDamage(CreatureLib::Battling::Executing
// HOOK: Override damage
return damage;
}
int PkmnLib::Battling::DamageLibrary::GetBasePower(CreatureLib::Battling::ExecutingAttack* attack,
uint8_t PkmnLib::Battling::DamageLibrary::GetBasePower(CreatureLib::Battling::ExecutingAttack* attack,
CreatureLib::Battling::Creature* target, uint8_t hitIndex) const {
auto bp = attack->GetAttack()->GetAttack()->GetBasePower();
// HOOK: modify base power.
@@ -24,8 +24,8 @@ float PkmnLib::Battling::DamageLibrary::GetStatModifier(CreatureLib::Battling::E
auto user = attack->GetUser();
// HOOK: allow overriding for which users stat we use.
auto hit = attack->GetAttackDataForTarget(target)->GetHit(hitIndex);
CreatureLib::Core::Statistic offensiveStat;
CreatureLib::Core::Statistic defensiveStat;
CreatureLib::Library::Statistic offensiveStat;
CreatureLib::Library::Statistic defensiveStat;
auto learnedMove = dynamic_cast<LearnedMove*>(attack->GetAttack());
auto moveData = learnedMove->GetMoveData();
if (moveData->GetCategory() == Library::MoveCategory::Physical) {

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

@@ -5,10 +5,10 @@
namespace PkmnLib::Battling {
class DamageLibrary : public CreatureLib::Battling::DamageLibrary {
public:
int GetDamage(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
uint32_t GetDamage(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
uint8_t hitIndex) const override;
int GetBasePower(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
uint8_t GetBasePower(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
uint8_t hitIndex) const override;
float GetStatModifier(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
uint8_t hitIndex) const override;

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

@@ -9,7 +9,7 @@ uint32_t PkmnLib::Battling::StatCalculator::CalculateHealthStat(const Pokemon* p
return static_cast<uint32_t>(((2 * base + iv + static_cast<uint32_t>(ev / 4)) * level) / 100) + level + 10;
}
uint32_t PkmnLib::Battling::StatCalculator::CalculateOtherStat(const Pokemon* pkmn,
CreatureLib::Core::Statistic stat) const {
CreatureLib::Library::Statistic stat) const {
uint32_t base = pkmn->GetBaseStat(stat);
uint32_t iv = pkmn->GetIndividualValue(stat);
uint32_t ev = pkmn->GetEffortValue(stat);
@@ -19,7 +19,7 @@ uint32_t PkmnLib::Battling::StatCalculator::CalculateOtherStat(const Pokemon* pk
return static_cast<uint32_t>(unmodified * pkmn->GetNature().GetStatModifier(stat));
}
float PkmnLib::Battling::StatCalculator::GetStatBoostModifier(const CreatureLib::Battling::Creature* pkmn,
CreatureLib::Core::Statistic stat) const {
CreatureLib::Library::Statistic stat) const {
int8_t boost = pkmn->GetStatBoost(stat);
switch (boost) {
case -6: return 2.0 / 8;
@@ -38,19 +38,19 @@ float PkmnLib::Battling::StatCalculator::GetStatBoostModifier(const CreatureLib:
default: throw CreatureException("Stat boost was out of expected range of -6 till 6.");
}
}
CreatureLib::Core::StatisticSet<uint32_t>
CreatureLib::Library::StatisticSet<uint32_t>
PkmnLib::Battling::StatCalculator::CalculateFlatStats(CreatureLib::Battling::Creature* creature) const {
auto pkmn = dynamic_cast<Pokemon*>(creature);
return CreatureLib::Core::StatisticSet<uint32_t>(
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));
}
CreatureLib::Core::StatisticSet<uint32_t>
CreatureLib::Library::StatisticSet<uint32_t>
PkmnLib::Battling::StatCalculator::CalculateBoostedStats(CreatureLib::Battling::Creature* creature) const {
return CreatureLib::Core::StatisticSet<uint32_t>(
return CreatureLib::Library::StatisticSet<uint32_t>(
CalculateBoostedStat(creature, Library::Statistic::HealthPoints),
CalculateBoostedStat(creature, Library::Statistic::PhysicalAttack),
CalculateBoostedStat(creature, Library::Statistic::PhysicalDefense),
@@ -59,12 +59,12 @@ PkmnLib::Battling::StatCalculator::CalculateBoostedStats(CreatureLib::Battling::
CalculateBoostedStat(creature, Library::Statistic::Speed));
}
uint32_t PkmnLib::Battling::StatCalculator::CalculateFlatStat(CreatureLib::Battling::Creature* creature,
CreatureLib::Core::Statistic stat) const {
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::Core::Statistic stat) const {
CreatureLib::Library::Statistic stat) const {
return creature->GetFlatStat(stat) * GetStatBoostModifier(creature, stat);
}

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

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

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

@@ -11,7 +11,7 @@ PkmnLib::Battling::CreatePokemon* PkmnLib::Battling::CreatePokemon::WithRandomIn
}
PkmnLib::Battling::CreatePokemon*
PkmnLib::Battling::CreatePokemon::WithIndividualValue(CreatureLib::Core::Statistic stat, uint8_t value) {
PkmnLib::Battling::CreatePokemon::WithIndividualValue(CreatureLib::Library::Statistic stat, uint8_t value) {
switch (stat) {
case PkmnLib::Library::Statistic::HealthPoints: _ivHp = value; break;
case PkmnLib::Library::Statistic::PhysicalAttack: _ivAttack = value; break;
@@ -23,7 +23,7 @@ PkmnLib::Battling::CreatePokemon::WithIndividualValue(CreatureLib::Core::Statist
return this;
}
PkmnLib::Battling::CreatePokemon* PkmnLib::Battling::CreatePokemon::WithEffortValue(CreatureLib::Core::Statistic stat,
PkmnLib::Battling::CreatePokemon* PkmnLib::Battling::CreatePokemon::WithEffortValue(CreatureLib::Library::Statistic stat,
uint8_t value) {
switch (stat) {
case PkmnLib::Library::Statistic::HealthPoints: _evHp = value; break;
@@ -50,8 +50,8 @@ PkmnLib::Battling::Pokemon* PkmnLib::Battling::CreatePokemon::Build() {
err << "Invalid forme '" << _forme << "' for species '" << _forme << "'.";
throw CreatureException(err.str());
}
int8_t ability;
if (this->_ability.empty()) {
CreatureLib::Library::TalentIndex ability;
if (this->_ability.Empty()) {
ability = forme->GetRandomTalent(&rand);
} else {
ability = forme->GetTalentIndex(this->_ability);
@@ -72,13 +72,13 @@ PkmnLib::Battling::Pokemon* PkmnLib::Battling::CreatePokemon::Build() {
}
auto experience = _library->GetGrowthRateLibrary()->CalculateExperience(species->GetGrowthRate(), _level);
auto attacks = std::vector<CreatureLib::Battling::LearnedAttack*>(_attacks.size());
for (size_t i = 0; i < attacks.size(); i++) {
auto attacks = List<CreatureLib::Battling::LearnedAttack*>(_attacks.size());
for (size_t i = 0; i < attacks.Count(); i++) {
auto kv = _attacks[i];
attacks[i] = new LearnedMove(std::get<0>(kv), std::get<1>(kv));
}
auto ivs = CreatureLib::Core::StatisticSet(_ivHp, _ivAttack, _ivDefense, _ivSpAtt, _ivSpDef, _ivSpeed);
auto evs = CreatureLib::Core::StatisticSet(_evHp, _evAttack, _evDefense, _evSpAtt, _evSpDef, _evSpeed);
auto ivs = CreatureLib::Library::StatisticSet(_ivHp, _ivAttack, _ivDefense, _ivSpAtt, _ivSpDef, _ivSpeed);
auto evs = CreatureLib::Library::StatisticSet(_evHp, _evAttack, _evDefense, _evSpAtt, _evSpDef, _evSpeed);
if (_nature == 255) {
_nature = _library->GetNatureLibrary()->GetRandomNature(rand);

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

@@ -12,7 +12,7 @@ namespace PkmnLib::Battling {
uint8_t _level;
std::string _nickname = "";
std::string _ability = "";
Arbutils::CaseInsensitiveConstString _ability = ""_cnc;
uint8_t _nature = 255;
CreatureLib::Library::Gender _gender = static_cast<CreatureLib::Library::Gender>(-1);
Arbutils::CaseInsensitiveConstString _heldItem = ""_cnc;
@@ -47,10 +47,10 @@ namespace PkmnLib::Battling {
CreatePokemon* LearnMove(const Arbutils::CaseInsensitiveConstString& move, CreatureLib::Battling::AttackLearnMethod method);
CreatePokemon* WithRandomIndividualValues(Arbutils::Random rand = Arbutils::Random());
CreatePokemon* WithIndividualValue(CreatureLib::Core::Statistic stat, uint8_t value);
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::Core::Statistic stat, uint8_t value);
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);

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

@@ -10,8 +10,8 @@
namespace PkmnLib::Battling {
class Pokemon : public CreatureLib::Battling::Creature {
private:
CreatureLib::Core::StatisticSet<uint8_t> _individualValues;
CreatureLib::Core::StatisticSet<uint8_t> _effortValues;
CreatureLib::Library::StatisticSet<uint8_t> _individualValues;
CreatureLib::Library::StatisticSet<uint8_t> _effortValues;
uint8_t _nature;
const Library::Nature* _natureCache = nullptr;
@@ -22,14 +22,14 @@ namespace PkmnLib::Battling {
Pokemon(const BattleLibrary* library, const Library::PokemonSpecies* species,
const Library::PokemonForme* forme, uint8_t level, uint32_t experience, uint32_t uid,
CreatureLib::Library::Gender gender, uint8_t coloring, const Library::Item* heldItem,
const std::string& nickname, int8_t talent, std::vector<CreatureLib::Battling::LearnedAttack*> moves,
CreatureLib::Core::StatisticSet<uint8_t> individualValues,
CreatureLib::Core::StatisticSet<uint8_t> effortValues, uint8_t nature)
const std::string& nickname, const CreatureLib::Library::TalentIndex& talent,
List<CreatureLib::Battling::LearnedAttack*> moves,
CreatureLib::Library::StatisticSet<uint8_t> individualValues,
CreatureLib::Library::StatisticSet<uint8_t> effortValues, uint8_t nature)
: CreatureLib::Battling::Creature(library, species, forme, level, experience, uid, gender, coloring,
heldItem, nickname, talent, std::move(moves)),
_individualValues(individualValues), _effortValues(effortValues), _nature(nature) {}
const Library::PokemonForme* GetForme() const {
return dynamic_cast<const Library::PokemonForme*>(GetVariant());
}
@@ -41,8 +41,10 @@ namespace PkmnLib::Battling {
}
const Library::Nature& GetNature() const;
uint8_t GetIndividualValue(CreatureLib::Core::Statistic stat) const { return _individualValues.GetStat(stat); }
uint8_t GetEffortValue(CreatureLib::Core::Statistic stat) const { return _effortValues.GetStat(stat); }
uint8_t GetIndividualValue(CreatureLib::Library::Statistic stat) const {
return _individualValues.GetStat(stat);
}
uint8_t GetEffortValue(CreatureLib::Library::Statistic stat) const { return _effortValues.GetStat(stat); }
};
}

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

@@ -9,7 +9,7 @@ namespace PkmnLib::Library {
public:
Item(const Arbutils::CaseInsensitiveConstString& name, CreatureLib::Library::ItemCategory category,
CreatureLib::Library::BattleItemCategory battleCategory, int32_t price,
std::unordered_set<Arbutils::CaseInsensitiveConstString> flags, uint8_t flingPower)
std::unordered_set<uint32_t> flags, uint8_t flingPower)
: CreatureLib::Library::Item(name, category, battleCategory, price, flags), _flingPower(flingPower) {}
inline uint8_t GetFlingPower() const { return _flingPower; }

7
src/Library/Moves/MoveData.cpp
View File

@@ -1,11 +1,12 @@
#include "MoveData.hpp"
#include <utility>
PkmnLib::Library::MoveData::MoveData(const std::string& name, uint8_t type,
PkmnLib::Library::MoveData::MoveData(const Arbutils::CaseInsensitiveConstString& name, uint8_t type,
PkmnLib::Library::MoveCategory category, uint8_t power, uint8_t accuracy,
uint8_t baseUsage, CreatureLib::Library::AttackTarget target, int8_t priority,
std::unordered_set<Arbutils::CaseInsensitiveConstString> flags)
const CreatureLib::Library::SecondaryEffect& effect,
std::unordered_set<uint32_t> flags)
: AttackData(name, type, static_cast<CreatureLib::Library::AttackCategory>(category), power, accuracy, baseUsage,
target, priority, std::move(flags)) {}
target, priority, effect, std::move(flags)) {}
PkmnLib::Library::MoveCategory PkmnLib::Library::MoveData::GetCategory() const {
return static_cast<PkmnLib::Library::MoveCategory>(AttackData::GetCategory());

8
src/Library/Moves/MoveData.hpp
View File

@@ -7,11 +7,11 @@
namespace PkmnLib::Library {
class MoveData : public CreatureLib::Library::AttackData {
private:
public:
MoveData(const std::string& name, uint8_t type, PkmnLib::Library::MoveCategory category, uint8_t power,
uint8_t accuracy, uint8_t baseUsage, CreatureLib::Library::AttackTarget target, int8_t priority,
std::unordered_set<Arbutils::CaseInsensitiveConstString> flags);
MoveData(const Arbutils::CaseInsensitiveConstString& name, uint8_t type,
PkmnLib::Library::MoveCategory category, uint8_t power, uint8_t accuracy, uint8_t baseUsage,
CreatureLib::Library::AttackTarget target, int8_t priority,
const CreatureLib::Library::SecondaryEffect& effect, std::unordered_set<uint32_t> flags);
PkmnLib::Library::MoveCategory GetCategory() const;
};

19
src/Library/Natures/Nature.hpp
View File

@@ -1,21 +1,22 @@
#ifndef PKMNLIB_NATURE_HPP
#define PKMNLIB_NATURE_HPP
#include <CreatureLib/Core/Statistic.hpp>
#include <CreatureLib/Library/Statistic.hpp>
namespace PkmnLib::Library {
class Nature {
private:
CreatureLib::Core::Statistic _increaseStat;
CreatureLib::Core::Statistic _decreaseStat;
CreatureLib::Library::Statistic _increaseStat;
CreatureLib::Library::Statistic _decreaseStat;
float _increaseModifier;
float _decreaseModifier;
public:
Nature()
: _increaseStat(CreatureLib::Core::Statistic::Health), _decreaseStat(CreatureLib::Core::Statistic::Health),
_increaseModifier(1.0f), _decreaseModifier(1.0f) {}
: _increaseStat(CreatureLib::Library::Statistic::Health),
_decreaseStat(CreatureLib::Library::Statistic::Health), _increaseModifier(1.0f), _decreaseModifier(1.0f) {
}
Nature(CreatureLib::Core::Statistic increasedStat, CreatureLib::Core::Statistic decreasedStat,
Nature(CreatureLib::Library::Statistic increasedStat, CreatureLib::Library::Statistic decreasedStat,
float increasedModifier = 1.1f, float decreasedModifier = 0.9f)
: _increaseStat(increasedStat), _decreaseStat(decreasedStat), _increaseModifier(increasedModifier),
_decreaseModifier(decreasedModifier) {}
@@ -23,10 +24,10 @@ namespace PkmnLib::Library {
[[nodiscard]] float GetIncreaseModifier() const { return _increaseModifier; }
[[nodiscard]] float GetDecreaseModifier() const { return _decreaseModifier; }
[[nodiscard]] CreatureLib::Core::Statistic GetIncreasedStat() const { return _increaseStat; }
[[nodiscard]] CreatureLib::Core::Statistic GetDecreasedStat() const { return _decreaseStat; }
[[nodiscard]] CreatureLib::Library::Statistic GetIncreasedStat() const { return _increaseStat; }
[[nodiscard]] CreatureLib::Library::Statistic GetDecreasedStat() const { return _decreaseStat; }
[[nodiscard]] float GetStatModifier(CreatureLib::Core::Statistic stat) const {
[[nodiscard]] float GetStatModifier(CreatureLib::Library::Statistic stat) const {
if (stat == _increaseStat)
return _increaseModifier;
else if (stat == _decreaseStat)

2
src/Library/Natures/NatureLibrary.hpp
View File

@@ -1,7 +1,7 @@
#ifndef PKMNLIB_NATURELIBRARY_HPP
#define PKMNLIB_NATURELIBRARY_HPP
#include <CreatureLib/Core/Exceptions/CreatureException.hpp>
#include <CreatureLib/Library/Exceptions/CreatureException.hpp>
#include <Arbutils/Random.hpp>
#include <unordered_map>
#include <vector>

6
src/Library/Species/PokemonForme.cpp
View File

@@ -1,7 +1,7 @@
#include "PokemonForme.hpp"
PkmnLib::Library::PokemonForme::PokemonForme(ConstString name, float height, float weight, uint32_t baseExperience,
std::vector<uint8_t> types,
CreatureLib::Core::StatisticSet<uint16_t> baseStats,
std::vector<ConstString> talents, std::vector<ConstString> secretTalents,
const List<uint8_t>& types,
CreatureLib::Library::StatisticSet<uint16_t> baseStats,
const List<ConstString>& talents, const List<ConstString>& secretTalents,
const CreatureLib::Library::LearnableAttacks* attacks)
: SpeciesVariant(name, height, weight, baseExperience, types, baseStats, talents, secretTalents, attacks) {}

10
src/Library/Species/PokemonForme.hpp
View File

@@ -6,13 +6,15 @@
namespace PkmnLib::Library {
class PokemonForme : public CreatureLib::Library::SpeciesVariant {
public:
PokemonForme(ConstString name, float height, float weight, uint32_t baseExperience, std::vector<uint8_t> types,
CreatureLib::Core::StatisticSet<uint16_t> baseStats, std::vector<ConstString> talents,
std::vector<ConstString> secretTalents, const CreatureLib::Library::LearnableAttacks* attacks);
PokemonForme(ConstString name, float height, float weight, uint32_t baseExperience, const List<uint8_t>& types,
CreatureLib::Library::StatisticSet<uint16_t> baseStats, const List<ConstString>& talents,
const List<ConstString>& secretTalents, const CreatureLib::Library::LearnableAttacks* attacks);
private:
public:
inline const ConstString& GetAbility(int index) const { return GetTalent(index); }
inline const ConstString& GetAbility(const CreatureLib::Library::TalentIndex& index) const {
return GetTalent(index);
}
};
}

21
src/Library/Statistic.hpp
View File

@@ -1,19 +1,20 @@
#ifndef PKMNLIB_STATISTIC_HPP
#define PKMNLIB_STATISTIC_HPP
#include <CreatureLib/Core/Statistic.hpp>
#include <CreatureLib/Library/Statistic.hpp>
namespace PkmnLib::Library {
class Statistic {
public:
static constexpr const CreatureLib::Core::Statistic HealthPoints = CreatureLib::Core::Statistic::Health;
static constexpr const CreatureLib::Core::Statistic PhysicalAttack =
CreatureLib::Core::Statistic::PhysicalAttack;
static constexpr const CreatureLib::Core::Statistic PhysicalDefense =
CreatureLib::Core::Statistic::PhysicalDefense;
static constexpr const CreatureLib::Core::Statistic SpecialAttack = CreatureLib::Core::Statistic::MagicalAttack;
static constexpr const CreatureLib::Core::Statistic SpecialDefense =
CreatureLib::Core::Statistic::MagicalDefense;
static constexpr const CreatureLib::Core::Statistic Speed = CreatureLib::Core::Statistic::Speed;
static constexpr const CreatureLib::Library::Statistic HealthPoints = CreatureLib::Library::Statistic::Health;
static constexpr const CreatureLib::Library::Statistic PhysicalAttack =
CreatureLib::Library::Statistic::PhysicalAttack;
static constexpr const CreatureLib::Library::Statistic PhysicalDefense =
CreatureLib::Library::Statistic::PhysicalDefense;
static constexpr const CreatureLib::Library::Statistic SpecialAttack =
CreatureLib::Library::Statistic::MagicalAttack;
static constexpr const CreatureLib::Library::Statistic SpecialDefense =
CreatureLib::Library::Statistic::MagicalDefense;
static constexpr const CreatureLib::Library::Statistic Speed = CreatureLib::Library::Statistic::Speed;
};
}

2
src/ScriptResolving/AngelScript/AngelScripResolver.cpp
View File

@@ -11,6 +11,7 @@
#include "TypeRegistry/Battling/RegisterExecutingAttack.hpp"
#include "TypeRegistry/Battling/RegisterPokemonClass.hpp"
#include "TypeRegistry/Battling/RegisterTurnChoices.hpp"
#include "TypeRegistry/ConstString.hpp"
#include "TypeRegistry/Library/RegisterGrowthRateTypes.hpp"
#include "TypeRegistry/Library/RegisterItemTypes.hpp"
#include "TypeRegistry/Library/RegisterMoveTypes.hpp"
@@ -40,6 +41,7 @@ void AngelScripResolver::Initialize(CreatureLib::Battling::BattleLibrary* arg) {
_engine->SetEngineProperty(asEP_COMPILER_WARNINGS, 2);
RegisterStdString(_engine);
ConstStringRegister::Register(_engine);
// Register Script Array type
RegisterScriptArray(_engine, true);

10
src/ScriptResolving/AngelScript/AngelScriptScript.hpp
View File

@@ -2,7 +2,7 @@
#define PKMNLIB_ANGELSCRIPTSCRIPT_HPP
#include <CreatureLib/Battling/ScriptHandling/Script.hpp>
#define ANGELSCRIPT_DLL_LIBRARY_IMPORT
#include <CreatureLib/Core/Exceptions/NotImplementedException.hpp>
#include <CreatureLib/Library/Exceptions/NotImplementedException.hpp>
#include <angelscript.h>
#include "../../Battling/PkmnScript.hpp"
#include "AngelScriptTypeInfo.hpp"
@@ -21,9 +21,9 @@ public:
~AngelScriptScript() override { _obj->Release(); }
[[nodiscard]] const ConstString& GetName() const override { return _type->GetName(); }
[[nodiscard]] const ConstString& GetName() const noexcept override { return _type->GetName(); }
asIScriptFunction* PrepareMethod(const char* name, asIScriptContext* ctx) {
asIScriptFunction* PrepareMethod(const ConstString& name, asIScriptContext* ctx) {
auto func = _type->GetFunction(name);
ctx->Prepare(func);
ctx->SetObject(_obj);
@@ -71,7 +71,7 @@ public:
throw NotImplementedException(); // TODO
}
void ChangeAttack(CreatureLib::Battling::AttackTurnChoice* choice, std::string* outAttack) override {
void ChangeAttack(CreatureLib::Battling::AttackTurnChoice* choice, ConstString* outAttack) override {
throw NotImplementedException(); // TODO
}
@@ -246,7 +246,7 @@ public:
})
}
void OverrideDamage(CreatureLib::Battling::ExecutingAttack* attack, CreatureLib::Battling::Creature* target,
uint8_t hitIndex, int32_t* damage) override {
uint8_t hitIndex, uint32_t* damage) override {
CALL_HOOK(OverrideDamage, {
ctx->SetArgObject(0, (void*)attack);
ctx->SetArgObject(1, (void*)target);

23
src/ScriptResolving/AngelScript/AngelScriptTypeInfo.hpp
View File

@@ -2,8 +2,9 @@
#define PKMNLIB_ANGELSCRIPTTYPEINFO_HPP
#define ANGELSCRIPT_DLL_LIBRARY_IMPORT
#include <Arbutils/Collections/Dictionary.hpp>
#include <Arbutils/ConstString.hpp>
#include <CreatureLib/Core/Exceptions/CreatureException.hpp>
#include <CreatureLib/Library/Exceptions/CreatureException.hpp>
#include <angelscript.h>
#include <cstring>
#include <unordered_map>
@@ -14,7 +15,7 @@ using ConstString = Arbutils::CaseInsensitiveConstString;
class AngelScriptTypeInfo {
private:
asITypeInfo* _type = nullptr;
std::unordered_map<std::string, asIScriptFunction*> _functions;
Arbutils::Collections::Dictionary<ConstString, asIScriptFunction*> _functions;
ConstString _name;
struct FunctionInfo {
@@ -39,23 +40,21 @@ public:
for (const auto& f : _functions) {
f.second->Release();
}
_functions.clear();
_functions.Clear();
}
const ConstString& GetName() const{
return _name;
}
const ConstString& GetName() const noexcept { return _name; }
asIScriptFunction* GetFunction(const std::string& functionName) {
auto find = _functions.find(functionName);
if (find != _functions.end()) {
return find->second;
asIScriptFunction* GetFunction(const ConstString& functionName) {
asIScriptFunction* func;
if (_functions.TryGet(functionName, func)) {
return func;
}
auto func = _type->GetMethodByName(functionName.c_str());
func = _type->GetMethodByName(functionName.c_str());
if (func != nullptr) {
func->AddRef();
}
_functions.insert({functionName, func});
_functions.Insert(functionName, func);
return func;
}

4
src/ScriptResolving/AngelScript/TypeRegistry/BasicScriptClass.cpp
View File

@@ -25,13 +25,13 @@ shared abstract class PkmnScript {
void ModifyEffectChance(ExecutingMove@ attack, Pokemon@ target, float& chance){};
void ModifyIncomingEffectChance(ExecutingMove@ attack, Pokemon@ target, float& chance){};
void OverrideBasePower(ExecutingMove@ attack, Pokemon@ target, uint8 hit, uint8& chance){};
void OverrideBasePower(ExecutingMove@ attack, Pokemon@ target, uint8 hit, uint8& basePower){};
void ChangeDamageStatsUser(ExecutingMove@ attack, Pokemon@ target, uint8 hit, Pokemon@& user){};
void BypassDefensiveStat(ExecutingMove@ attack, Pokemon@ target, uint8 hit, bool& bypass){};
void BypassOffensiveStat(ExecutingMove@ attack, Pokemon@ target, uint8 hit, bool& bypass){};
void ModifyStatModifier(ExecutingMove@ attack, Pokemon@ target, uint8 hit, float& modifier){};
void ModifyDamageModifier(ExecutingMove@ attack, Pokemon@ target, uint8 hit, float& modifier){};
void OverrideDamage(ExecutingMove@ attack, Pokemon@ target, uint8 hit, int& damage){};
void OverrideDamage(ExecutingMove@ attack, Pokemon@ target, uint8 hit, uint& damage){};
// PkmnLib methods
void ModifyCriticalStage(ExecutingMove@ attack, Pokemon@ target, uint8 hit, uint8& critStage){};

10
src/ScriptResolving/AngelScript/TypeRegistry/Battling/RegisterPokemonClass.cpp
View File

@@ -59,8 +59,8 @@ CScriptArray* GetTypes(const PkmnLib::Battling::Pokemon* obj) {
asIScriptEngine* engine = ctx->GetEngine();
asITypeInfo* t = engine->GetTypeInfoByDecl("array<uint8>");
auto a = obj->GetTypes();
CScriptArray* arr = CScriptArray::Create(t, a.size());
for (size_t i = 0; i < a.size(); i++) {
CScriptArray* arr = CScriptArray::Create(t, a.Count());
for (size_t i = 0; i < a.Count(); i++) {
arr->SetValue(i, &a[i]);
}
return arr;
@@ -82,6 +82,10 @@ CScriptArray* GetMoves(const PkmnLib::Battling::Pokemon* obj) {
}
return nullptr;
}
static bool HasHeldItem(const PkmnLib::Battling::Pokemon* obj, const Arbutils::CaseInsensitiveConstString& str) {
return obj->HasHeldItem(str);
}
void RegisterPokemonClass::RegisterPokemonType(asIScriptEngine* engine) {
[[maybe_unused]] int r = engine->RegisterObjectType("Pokemon", 0, asOBJ_REF | asOBJ_NOCOUNT);
@@ -111,7 +115,7 @@ void RegisterPokemonClass::RegisterPokemonType(asIScriptEngine* engine) {
asMETHOD(PkmnLib::Battling::Pokemon, GetHeldItem), asCALL_THISCALL);
assert(r >= 0);
r = engine->RegisterObjectMethod("Pokemon", "bool HasHeldItem(const string &in name) const",
asMETHOD(PkmnLib::Battling::Pokemon, HasHeldItem), asCALL_THISCALL);
asFUNCTION(HasHeldItem), asCALL_CDECL_OBJLAST);
assert(r >= 0);
r = engine->RegisterObjectMethod(
"Pokemon", "void SetHeldItem(const string &in name)",

14
src/ScriptResolving/AngelScript/TypeRegistry/ConstString.cpp Normal file
View File

@@ -0,0 +1,14 @@
#include "ConstString.hpp"
using ConstString = Arbutils::CaseInsensitiveConstString;
static bool ConstStringEquality(const ConstString& a, const ConstString& b) { return a == b; }
void ConstStringRegister::Register(asIScriptEngine* engine) {
auto r = engine->RegisterObjectType("constString", sizeof(Arbutils::CaseInsensitiveConstString),
asOBJ_VALUE | asOBJ_POD);
Assert(r >= 0);
r = engine->RegisterObjectMethod("constString", "bool opEquals(const constString &in) const",
asFUNCTIONPR(ConstStringEquality, (const ConstString&, const ConstString&), bool),
asCALL_CDECL_OBJFIRST);
Assert(r >= 0);
}

11
src/ScriptResolving/AngelScript/TypeRegistry/ConstString.hpp Normal file
View File

@@ -0,0 +1,11 @@
#ifndef PKMNLIB_CONSTSTRING_HPP
#define PKMNLIB_CONSTSTRING_HPP
#include <Arbutils/Assert.hpp>
#include <Arbutils/ConstString.hpp>
#include <angelscript.h>
class ConstStringRegister {
public:
static void Register(asIScriptEngine* engine);
};
#endif // PKMNLIB_CONSTSTRING_HPP

20
src/ScriptResolving/AngelScript/TypeRegistry/Library/RegisterGrowthRateTypes.cpp
View File

@@ -17,13 +17,25 @@ void RegisterGrowthRateTypes::RegisterGrowthRateType(asIScriptEngine* engine) {
asMETHOD(CreatureLib::Library::GrowthRate, CalculateExperience), asCALL_THISCALL);
assert(r >= 0);
}
static uint8_t CalculateLevel(const CreatureLib::Library::GrowthRateLibrary* obj, const ConstString& str,
uint32_t experience) {
return obj->CalculateLevel(str, experience);
}
static uint32_t CalculateExperience(const CreatureLib::Library::GrowthRateLibrary* obj, const ConstString& str,
uint8_t level) {
return obj->CalculateExperience(str, level);
}
void RegisterGrowthRateTypes::RegisterGrowthRateLibrary(asIScriptEngine* engine) {
[[maybe_unused]] int r = engine->RegisterObjectType("GrowthRateLibrary", 0, asOBJ_REF | asOBJ_NOCOUNT);
assert(r >= 0);
r = engine->RegisterObjectMethod("GrowthRateLibrary", "uint8 CalculateLevel(const string &in growthRate, uint experience) const",
asMETHOD(CreatureLib::Library::GrowthRateLibrary, CalculateLevel), asCALL_THISCALL);
r = engine->RegisterObjectMethod("GrowthRateLibrary",
"uint8 CalculateLevel(const string &in growthRate, uint experience) const",
asFUNCTION(CalculateLevel), asCALL_CDECL_OBJLAST);
assert(r >= 0);
r = engine->RegisterObjectMethod("GrowthRateLibrary", "uint CalculateExperience(const string &in growthRate, uint8 experience) const",
asMETHOD(CreatureLib::Library::GrowthRateLibrary, CalculateExperience), asCALL_THISCALL);
r = engine->RegisterObjectMethod("GrowthRateLibrary",
"uint CalculateExperience(const string &in growthRate, uint8 experience) const",
asFUNCTION(CalculateExperience), asCALL_CDECL_OBJLAST);
assert(r >= 0);
}

7
src/ScriptResolving/AngelScript/TypeRegistry/Library/RegisterItemTypes.cpp
View File

@@ -53,6 +53,11 @@ void RegisterItemTypes::RegisterBattleItemCategoryEnum(asIScriptEngine* engine)
ENUM__SIZE_WRAPPER(Move_CategoryWrapper, PkmnLib::Library::Item, GetCategory)
ENUM__SIZE_WRAPPER(Move_BattleCategoryWrapper, PkmnLib::Library::Item, GetBattleCategory)
static bool HasFlag(const PkmnLib::Library::Item* obj, const Arbutils::CaseInsensitiveConstString& str) {
return obj->HasFlag(str);
}
void RegisterItemTypes::RegisterItemType(asIScriptEngine* engine) {
[[maybe_unused]] int r = engine->RegisterObjectType("Item", 0, asOBJ_REF | asOBJ_NOCOUNT);
assert(r >= 0);
@@ -69,7 +74,7 @@ void RegisterItemTypes::RegisterItemType(asIScriptEngine* engine) {
asMETHOD(PkmnLib::Library::Item, GetPrice), asCALL_THISCALL);
assert(r >= 0);
r = engine->RegisterObjectMethod("Item", "bool HasFlag(const string &in flag) const",
asMETHOD(PkmnLib::Library::Item, HasFlag), asCALL_THISCALL);
asFUNCTION(HasFlag), asCALL_CDECL_OBJLAST);
assert(r >= 0);

6
src/ScriptResolving/AngelScript/TypeRegistry/Library/RegisterMoveTypes.cpp
View File

@@ -46,6 +46,10 @@ void RegisterMoveTypes::RegisterMoveTarget(asIScriptEngine* engine) {
ENUM__SIZE_WRAPPER(Move_CategoryWrapper, PkmnLib::Library::MoveData, GetCategory)
ENUM__SIZE_WRAPPER(Move_TargetWrapper, PkmnLib::Library::MoveData, GetTarget)
static bool HasFlag(const PkmnLib::Library::MoveData* obj, const Arbutils::CaseInsensitiveConstString& str) {
return obj->HasFlag(str);
}
void RegisterMoveTypes::RegisterMoveType(asIScriptEngine* engine) {
[[maybe_unused]] int r = engine->RegisterObjectType("MoveData", 0, asOBJ_REF | asOBJ_NOCOUNT);
assert(r >= 0);
@@ -74,7 +78,7 @@ void RegisterMoveTypes::RegisterMoveType(asIScriptEngine* engine) {
asMETHOD(PkmnLib::Library::MoveData, GetPriority), asCALL_THISCALL);
assert(r >= 0);
r = engine->RegisterObjectMethod("MoveData", "bool HasFlag(const string &in flag) const",
asMETHOD(PkmnLib::Library::MoveData, HasFlag), asCALL_THISCALL);
asFUNCTION(HasFlag), asCALL_CDECL_OBJLAST);
assert(r >= 0);
}
void RegisterMoveTypes::RegisterMoveLibrary(asIScriptEngine* engine) {

15
src/ScriptResolving/AngelScript/TypeRegistry/Library/RegisterSpeciesTypes.cpp
View File

@@ -63,13 +63,18 @@ void RegisterSpeciesTypes::RegisterSpeciesType(asIScriptEngine* engine) {
r = engine->RegisterObjectMethod("Species", "Gender GetRandomGender() const",
asMETHOD(PkmnLib::Library::PokemonSpecies, GetRandomGender), asCALL_THISCALL);
assert(r >= 0);
r = engine->RegisterObjectMethod("Species", "const Forme@ GetForme(string key) const",
asFUNCTION(GetFormeWrapper), asCALL_CDECL_OBJLAST);
r = engine->RegisterObjectMethod("Species", "const Forme@ GetForme(string key) const", asFUNCTION(GetFormeWrapper),
asCALL_CDECL_OBJLAST);
assert(r >= 0);
r = engine->RegisterObjectMethod("Species", "const Forme@ GetDefaultForme() const",
asMETHOD(PkmnLib::Library::PokemonSpecies, GetDefaultForme), asCALL_THISCALL);
assert(r >= 0);
}
const ConstString& GetAbility(PkmnLib::Library::PokemonForme* p, bool hidden, uint8_t index) {
return p->GetAbility(CreatureLib::Library::TalentIndex(hidden, index));
}
void RegisterSpeciesTypes::RegisterFormeType(asIScriptEngine* engine) {
[[maybe_unused]] int r = engine->RegisterObjectType("Forme", 0, asOBJ_REF | asOBJ_NOCOUNT);
assert(r >= 0);
@@ -94,8 +99,10 @@ void RegisterSpeciesTypes::RegisterFormeType(asIScriptEngine* engine) {
r = engine->RegisterObjectMethod("Forme", "uint GetStatistic(Statistic stat) const",
asMETHOD(PkmnLib::Library::PokemonForme, GetStatistic), asCALL_THISCALL);
assert(r >= 0);
r = engine->RegisterObjectMethod("Forme", "const string& GetAbility(int index) const",
asMETHOD(PkmnLib::Library::PokemonForme, GetTalent), asCALL_THISCALL);
r = engine->RegisterObjectMethod(
"Forme", "const constString& GetAbility(bool hidden, uint8 index) const",
asFUNCTIONPR(GetAbility, (PkmnLib::Library::PokemonForme * p, bool hidden, uint8_t index), const ConstString&),
asCALL_CDECL_OBJFIRST);
assert(r >= 0);
}
void RegisterSpeciesTypes::RegisterSpeciesLibrary(asIScriptEngine* engine) {

6
src/ScriptResolving/AngelScript/TypeRegistry/Library/RegisterTypeLibrary.cpp
View File

@@ -6,11 +6,15 @@ void RegisterTypeLibrary::Register(asIScriptEngine* engine) {
RegisterTypeLibraryType(engine);
}
static bool GetTypeId(const CreatureLib::Library::TypeLibrary* obj, const Arbutils::CaseInsensitiveConstString& str) {
return obj->GetTypeId(str);
}
void RegisterTypeLibrary::RegisterTypeLibraryType(asIScriptEngine* engine) {
[[maybe_unused]] int r = engine->RegisterObjectType("TypeLibrary", 0, asOBJ_REF | asOBJ_NOCOUNT);
assert(r >= 0);
r = engine->RegisterObjectMethod("TypeLibrary", "uint8 GetTypeId(const string &in name) const",
asMETHOD(CreatureLib::Library::TypeLibrary, GetTypeId), asCALL_THISCALL);
asFUNCTION(GetTypeId), asCALL_CDECL_OBJLAST);
assert(r >= 0);
r = engine->RegisterObjectMethod("TypeLibrary", "float GetSingleEffectiveness(uint8 attacking, uint8 defensive) const",
asMETHOD(CreatureLib::Library::TypeLibrary, GetSingleEffectiveness), asCALL_THISCALL);