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

Update to newer CreatureLib.
continuous-integration/drone/push Build is passing Details

This commit is contained in:
Deukhoofd 2020-07-04 15:50:30 +02:00
parent 698bc62b47
commit 7f1bc252ba
Signed by: Deukhoofd
GPG Key ID: ADF2E9256009EDCE
49 changed files with 207 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CInterface/AngelScript/AngelScriptResolver.cpp
View File

@ -15,7 +15,7 @@ export uint8_t PkmnLib_AngelScriptResolver_CreateScript(AngelScriptResolver* p,
export uint8_t PkmnLib_AngelScriptResolver_FinalizeModule(AngelScriptResolver* p) { Try(p->FinalizeModule();) }
export uint8_t PkmnLib_AngelScriptResolver_LoadScript(CreatureLib::Battling::Script*& out, AngelScriptResolver* p,
ScriptCategory category, const char* scriptName) {
Try(out = p->LoadScript(category, ArbUt::CaseInsensitiveConstString(scriptName));)
Try(out = p->LoadScript(category, ArbUt::StringView(scriptName));)
}
export uint8_t PkmnLib_AngelScriptResolver_WriteByteCodeToFile(AngelScriptResolver* p, const char* file,
bool stripDebugInfo) {

4
CInterface/Battling/Battle.cpp
View File

@ -10,8 +10,6 @@ export uint8_t PkmnLib_Battle_Construct(Battle*& out, const BattleLibrary* libra
}
export void PkmnLib_Battle_Destruct(Battle* p) { delete p; }
export uint8_t PkmnLib_Battle_SetWeather(Battle* p, const char* name) {
Try(p->SetWeather(ArbUt::CaseInsensitiveConstString(name)));
};
export uint8_t PkmnLib_Battle_SetWeather(Battle* p, const char* name) { Try(p->SetWeather(ArbUt::StringView(name))); };
export uint8_t PkmnLib_Battle_ClearWeather(Battle* p) { Try(p->ClearWeather()); };
export const char* PkmnLib_Battle_GetWeatherName(Battle* p) { return p->GetWeatherName().c_str(); }

2
CInterface/Library/EvolutionData.cpp
View File

@ -15,7 +15,7 @@ export const EvolutionData* PkmnLib_EvolutionData_CreateKnownMoveEvolution(const
}
export const EvolutionData* PkmnLib_EvolutionData_CreateLocationEvolution(const char* location,
const PokemonSpecies* into) {
return EvolutionData::CreateLocationEvolution(ArbUt::CaseInsensitiveConstString(location), into);
return EvolutionData::CreateLocationEvolution(ArbUt::StringView(location), into);
}
export const EvolutionData* PkmnLib_Evolution_CreateTimeEvolution(TimeOfDay time, const PokemonSpecies* into) {
return EvolutionData::CreateTimeEvolution(time, into);

7
CInterface/Library/Item.cpp
View File

@ -1,5 +1,5 @@
#include "../../src/Library/Items/Item.hpp"
#include <Arbutils/ConstString.hpp>
#include <Arbutils/StringView.hpp>
#include "../Core.hpp"
using namespace PkmnLib::Library;
@ -8,11 +8,10 @@ export Item* PkmnLib_Item_Construct(const char* name, CreatureLib::Library::Item
const char* flags[], size_t flagsCount, uint8_t flingPower) {
std::unordered_set<uint32_t> conversedFlags(flagsCount);
for (size_t i = 0; i < flagsCount; i++) {
conversedFlags.insert(ArbUt::CaseInsensitiveConstString::GetHash(flags[i]));
conversedFlags.insert(ArbUt::StringView::CalculateHash(flags[i]));
}
return new Item(ArbUt::CaseInsensitiveConstString(name), category, battleCategory, price, conversedFlags,
flingPower);
return new Item(ArbUt::StringView(name), category, battleCategory, price, conversedFlags, flingPower);
};
export void PkmnLib_Item_Destruct(const Item* p) { delete p; }

4
CInterface/Library/NatureLibrary.cpp
View File

@ -8,10 +8,10 @@ export NatureLibrary* PkmnLib_NatureLibrary_Construct(size_t initialCapacity) {
export void PkmnLib_NatureLibrary_Destruct(const NatureLibrary* p) { delete p; }
export uint8_t PkmnLib_NatureLibrary_LoadNature(NatureLibrary* p, const char* name, const Nature* nature) {
Try(p->LoadNature(ArbUt::CaseInsensitiveConstString(name), nature);)
Try(p->LoadNature(ArbUt::StringView(name), nature);)
}
export uint8_t PkmnLib_NatureLibrary_GetNatureByName(NatureLibrary* p, const char* name, const Nature*& out) {
Try(out = p->GetNatureByName(ArbUt::CaseInsensitiveConstString(name)).GetRaw());
Try(out = p->GetNatureByName(ArbUt::StringView(name)).GetRaw());
}
export const char* PkmnLib_NatureLibrary_GetRandomNatureName(NatureLibrary* p, ArbUt::Random* rand) {

3
CInterface/Library/PokemonSpecies.cpp
View File

@ -5,8 +5,7 @@ using namespace PkmnLib::Library;
export uint8_t PkmnLib_PokemonSpecies_Construct(const PokemonSpecies*& out, uint16_t id, const char* name,
const PokemonForme* defaultForme, float genderRatio,
const char* growthRate, uint8_t captureRate, uint8_t baseHappiness) {
Try(auto cName = ArbUt::CaseInsensitiveConstString(name);
auto cGrowthRate = ArbUt::CaseInsensitiveConstString(growthRate);
Try(auto cName = ArbUt::StringView(name); auto cGrowthRate = ArbUt::StringView(growthRate);
out = new PokemonSpecies(id, cName, defaultForme, genderRatio, cGrowthRate, captureRate, baseHappiness);)
}

2
CMakeLists.txt
View File

@ -5,7 +5,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror")
project(pkmnLib)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
if (NOT SCRIPT_PROVIDER)

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

@ -1,5 +1,5 @@
#include "Battle.hpp"
void PkmnLib::Battling::Battle::SetWeather(const ArbUt::CaseInsensitiveConstString& name) {
void PkmnLib::Battling::Battle::SetWeather(const ArbUt::StringView& name) {
if (_weatherScript != nullptr) {
_weatherScript->OnRemove();
}

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

@ -16,9 +16,9 @@ namespace PkmnLib::Battling {
bool canFlee = true, uint8_t numberOfSides = 2, uint8_t creaturesPerSide = 1)
: CreatureLib::Battling::Battle(library, parties, canFlee, numberOfSides, creaturesPerSide) {}
void SetWeather(const ArbUt::CaseInsensitiveConstString& name);
void SetWeather(const ArbUt::StringView& name);
void ClearWeather();
const ArbUt::CaseInsensitiveConstString& GetWeatherName() noexcept { return _weatherScript->GetName(); }
const ArbUt::StringView& GetWeatherName() noexcept { return _weatherScript->GetName(); }
size_t ScriptCount() const override { return CreatureLib::Battling::Battle::ScriptCount() + 1; }
void GetActiveScripts(ArbUt::List<CreatureLib::Battling::ScriptWrapper>& scripts) override {

8
src/Battling/EventHooks/WeatherChangeEvent.hpp
View File

@ -1,21 +1,21 @@
#ifndef PKMNLIB_WEATHERCHANGEEVENT_HPP
#define PKMNLIB_WEATHERCHANGEEVENT_HPP
#include <Arbutils/ConstString.hpp>
#include <Arbutils/StringView.hpp>
#include <CreatureLib/Battling/EventHooks/EventData.hpp>
#include "PkmnEventKind.hpp"
namespace PkmnLib::Battling {
class WeatherChangeEvent : public CreatureLib::Battling::EventData {
ArbUt::CaseInsensitiveConstString _weatherName;
ArbUt::StringView _weatherName;
public:
explicit WeatherChangeEvent(const ArbUt::CaseInsensitiveConstString& name) : _weatherName(name) {}
explicit WeatherChangeEvent(const ArbUt::StringView& name) : _weatherName(name) {}
[[nodiscard]] CreatureLib::Battling::EventDataKind GetKind() const noexcept override {
return static_cast<CreatureLib::Battling::EventDataKind>(PkmnEventDataKind::WeatherChange);
}
const ArbUt::CaseInsensitiveConstString GetWeatherName() const noexcept { return _weatherName; }
const ArbUt::StringView& GetWeatherName() const noexcept { return _weatherName; }
};
}

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

@ -68,7 +68,7 @@ PkmnLib::Battling::Pokemon* PkmnLib::Battling::CreatePokemon::Build() {
ArbUt::BorrowedPtr<const Library::Item> heldItem = nullptr;
if (!this->_heldItem.Empty()) {
if (!_library->GetItemLibrary()->TryGet(this->_heldItem, heldItem)) {
throw CreatureException("Unknown Item: " + this->_heldItem.std_str());
THROW_CREATURE("Unknown Item: " << this->_heldItem.std_str());
}
AssertNotNull(heldItem);
}
@ -103,8 +103,7 @@ PkmnLib::Battling::Pokemon* PkmnLib::Battling::CreatePokemon::Build() {
pkmn->Initialize();
return pkmn;
}
PkmnLib::Battling::CreatePokemon
PkmnLib::Battling::CreatePokemon::WithNature(const ArbUt::CaseInsensitiveConstString& nature) {
PkmnLib::Battling::CreatePokemon PkmnLib::Battling::CreatePokemon::WithNature(const ArbUt::StringView& nature) {
_nature = nature;
return *this;
}
@ -130,8 +129,7 @@ PkmnLib::Battling::CreatePokemon PkmnLib::Battling::CreatePokemon::WithEffortVal
_evSpeed = speed;
return *this;
}
PkmnLib::Battling::CreatePokemon
PkmnLib::Battling::CreatePokemon::WithForme(const ArbUt::CaseInsensitiveConstString& forme) {
PkmnLib::Battling::CreatePokemon PkmnLib::Battling::CreatePokemon::WithForme(const ArbUt::StringView& forme) {
_forme = forme;
return *this;
}
@ -144,17 +142,16 @@ PkmnLib::Battling::CreatePokemon PkmnLib::Battling::CreatePokemon::IsShiny(bool
_isShiny = value;
return *this;
}
PkmnLib::Battling::CreatePokemon
PkmnLib::Battling::CreatePokemon::WithHeldItem(const ArbUt::CaseInsensitiveConstString& item) {
PkmnLib::Battling::CreatePokemon PkmnLib::Battling::CreatePokemon::WithHeldItem(const ArbUt::StringView& item) {
_heldItem = item;
return *this;
}
PkmnLib::Battling::CreatePokemon
PkmnLib::Battling::CreatePokemon::LearnMove(const ArbUt::CaseInsensitiveConstString& moveName,
PkmnLib::Battling::CreatePokemon::LearnMove(const ArbUt::StringView& moveName,
CreatureLib::Battling::AttackLearnMethod method) {
ArbUt::BorrowedPtr<const PkmnLib::Library::MoveData> move = nullptr;
if (!_library->GetMoveLibrary()->TryGet(moveName, move)) {
throw CreatureException("Invalid Move given: " + moveName.std_str());
THROW_CREATURE("Invalid Move given: " << moveName.std_str());
}
if (_currentMove >= _library->GetSettings()->GetMaximalMoves()) {
throw CreatureException("This pokemon already has the maximal allowed moves.");

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

@ -7,15 +7,15 @@ namespace PkmnLib::Battling {
class CreatePokemon {
private:
ArbUt::BorrowedPtr<const BattleLibrary> _library;
ArbUt::CaseInsensitiveConstString _species = ""_cnc;
ArbUt::CaseInsensitiveConstString _forme = "default"_cnc;
ArbUt::StringView _species = ""_cnc;
ArbUt::StringView _forme = "default"_cnc;
uint8_t _level;
std::string _nickname = "";
ArbUt::CaseInsensitiveConstString _ability = ""_cnc;
ArbUt::CaseInsensitiveConstString _nature;
ArbUt::StringView _ability = ""_cnc;
ArbUt::StringView _nature;
CreatureLib::Library::Gender _gender = static_cast<CreatureLib::Library::Gender>(-1);
ArbUt::CaseInsensitiveConstString _heldItem = ""_cnc;
ArbUt::StringView _heldItem = ""_cnc;
uint32_t _identifier = 0;
struct ToLearnMethod {
@ -48,16 +48,15 @@ namespace PkmnLib::Battling {
bool _allowedExperienceGain = true;
public:
CreatePokemon(const BattleLibrary* library, const ArbUt::CaseInsensitiveConstString& species, uint8_t level)
CreatePokemon(const BattleLibrary* library, const ArbUt::StringView& species, uint8_t level)
: _library(library), _species(species), _level(level), _attacks(library->GetSettings()->GetMaximalMoves()) {
}
CreatePokemon WithForme(const ArbUt::CaseInsensitiveConstString& forme);
CreatePokemon WithForme(const ArbUt::StringView& forme);
CreatePokemon WithGender(CreatureLib::Library::Gender gender);
CreatePokemon IsShiny(bool value);
CreatePokemon WithHeldItem(const ArbUt::CaseInsensitiveConstString& item);
CreatePokemon LearnMove(const ArbUt::CaseInsensitiveConstString& move,
CreatureLib::Battling::AttackLearnMethod method);
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);
@ -67,7 +66,7 @@ namespace PkmnLib::Battling {
CreatePokemon WithEffortValues(uint8_t hp, uint8_t att, uint8_t def, uint8_t spAtt, uint8_t spDef,
uint8_t speed);
CreatePokemon WithNature(const ArbUt::CaseInsensitiveConstString& nature);
CreatePokemon WithNature(const ArbUt::StringView& nature);
CreatePokemon IsAllowedExperienceGain(bool value);
Pokemon* Build();

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

@ -22,7 +22,7 @@ namespace PkmnLib::Battling {
const ArbUt::BorrowedPtr<const Library::PokemonSpecies>& species,
const ArbUt::BorrowedPtr<const Library::PokemonForme>& forme, uint8_t level, uint32_t experience,
uint32_t uid, CreatureLib::Library::Gender gender, uint8_t coloring,
ArbUt::BorrowedPtr<const Library::Item> heldItem, const std::string& nickname,
ArbUt::BorrowedPtr<const Library::Item> heldItem, const std::string_view& nickname,
const CreatureLib::Library::TalentIndex& talent,
const std::vector<CreatureLib::Battling::LearnedAttack*>& moves,
CreatureLib::Library::StatisticSet<uint8_t> individualValues,

2
src/Library/Evolutions/EvolutionData.hpp
View File

@ -38,7 +38,7 @@ namespace PkmnLib::Library {
{new CreatureLib::Library::EffectParameter((int64_t)friendship)}, into);
}
static const EvolutionData* CreateKnownMoveEvolution(const MoveData* move, const PokemonSpecies* into);
static inline const EvolutionData* CreateLocationEvolution(const ArbUt::CaseInsensitiveConstString& location,
static inline const EvolutionData* CreateLocationEvolution(const ArbUt::StringView& location,
const PokemonSpecies* into) {
return new EvolutionData(EvolutionMethod::LocationBased,
{new CreatureLib::Library::EffectParameter(location)}, into);

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

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

8
src/Library/Items/ItemLibrary.hpp
View File

@ -6,21 +6,21 @@
namespace PkmnLib::Library {
class ItemLibrary : public CreatureLib::Library::ItemLibrary {
public:
inline bool TryGet(const ArbUt::CaseInsensitiveConstString& name, ArbUt::BorrowedPtr<const Item>& item) const {
inline bool TryGet(const ArbUt::BasicStringView& name, ArbUt::BorrowedPtr<const Item>& item) const {
auto v = item.As<const CreatureLib::Library::Item>();
auto res = CreatureLib::Library::ItemLibrary::TryGet(name.GetHash(), v);
item = v.ForceAs<const Item>();
return res;
}
inline ArbUt::BorrowedPtr<const Item> Get(const ArbUt::CaseInsensitiveConstString& name) const {
inline ArbUt::BorrowedPtr<const Item> Get(const ArbUt::BasicStringView& name) const {
return CreatureLib::Library::ItemLibrary::Get(name).ForceAs<const Item>();
}
inline ArbUt::BorrowedPtr<const Item> operator[](const ArbUt::CaseInsensitiveConstString& name) const {
inline ArbUt::BorrowedPtr<const Item> operator[](const ArbUt::BasicStringView& name) const {
return Get(name);
}
void Insert(const ArbUt::CaseInsensitiveConstString& name, const Item* item) {
void Insert(const ArbUt::StringView& name, const Item* item) {
CreatureLib::Library::ItemLibrary::Insert(name, item);
}
};

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

@ -1,6 +1,6 @@
#include "MoveData.hpp"
#include <utility>
PkmnLib::Library::MoveData::MoveData(const ArbUt::CaseInsensitiveConstString& name, uint8_t type,
PkmnLib::Library::MoveData::MoveData(const ArbUt::StringView& 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,

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

@ -8,7 +8,7 @@ namespace PkmnLib::Library {
class MoveData : public CreatureLib::Library::AttackData {
private:
public:
MoveData(const ArbUt::CaseInsensitiveConstString& name, uint8_t type, PkmnLib::Library::MoveCategory category,
MoveData(const ArbUt::StringView& 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);

6
src/Library/Moves/MoveLibrary.hpp
View File

@ -8,18 +8,18 @@ namespace PkmnLib::Library {
public:
MoveLibrary(size_t initialCapacity = 32) : CreatureLib::Library::AttackLibrary(initialCapacity) {}
virtual ArbUt::BorrowedPtr<const MoveData> operator[](const ArbUt::CaseInsensitiveConstString& name) const {
virtual ArbUt::BorrowedPtr<const MoveData> operator[](const ArbUt::BasicStringView& name) const {
return Get(name);
}
inline bool TryGet(const ArbUt::CaseInsensitiveConstString& name,
inline bool TryGet(const ArbUt::BasicStringView& name,
ArbUt::BorrowedPtr<const MoveData>& move) const {
auto v = move.As<const MoveData::AttackData>();
auto res = CreatureLib::Library::AttackLibrary::TryGet(name, v);
move = v.As<const MoveData>();
return res;
}
inline ArbUt::BorrowedPtr<const MoveData> Get(const ArbUt::CaseInsensitiveConstString& name) const {
inline ArbUt::BorrowedPtr<const MoveData> Get(const ArbUt::BasicStringView& name) const {
return CreatureLib::Library::AttackLibrary::Get(name).As<const MoveData>();
}
};

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

@ -3,9 +3,9 @@
#include <Arbutils/Collections/Dictionary.hpp>
#include <Arbutils/Collections/List.hpp>
#include <Arbutils/ConstString.hpp>
#include <Arbutils/Memory/BorrowedPtr.hpp>
#include <Arbutils/Random.hpp>
#include <Arbutils/StringView.hpp>
#include <CreatureLib/Library/Exceptions/CreatureException.hpp>
#include <unordered_map>
#include <vector>
@ -14,32 +14,31 @@
namespace PkmnLib::Library {
class NatureLibrary {
private:
std::unordered_map<ArbUt::CaseInsensitiveConstString, std::unique_ptr<const Nature>> _items;
std::unordered_map<ArbUt::StringView, std::unique_ptr<const Nature>> _items;
public:
explicit NatureLibrary(size_t size = 32) noexcept : _items(size) {}
~NatureLibrary() = default;
inline void LoadNature(const ArbUt::CaseInsensitiveConstString& name, const Nature* nature) {
inline void LoadNature(const ArbUt::StringView& name, const Nature* nature) {
_items.insert({name, std::unique_ptr<const Nature>(nature)});
}
inline ArbUt::BorrowedPtr<const Nature> GetNatureByName(const ArbUt::CaseInsensitiveConstString& name) const {
inline ArbUt::BorrowedPtr<const Nature> GetNatureByName(const ArbUt::StringView& name) const {
return _items.at(name);
}
inline const ArbUt::CaseInsensitiveConstString&
GetRandomNatureName(ArbUt::Random rand = ArbUt::Random()) const {
inline const ArbUt::StringView& GetRandomNatureName(ArbUt::Random rand = ArbUt::Random()) const {
auto i = rand.Get(_items.size());
return std::next(std::begin(_items), i)->first;
}
inline const ArbUt::CaseInsensitiveConstString& GetRandomNatureName(ArbUt::Random* rand) const {
inline const ArbUt::StringView& GetRandomNatureName(ArbUt::Random* rand) const {
auto i = rand->Get(_items.size());
return std::next(std::begin(_items), i)->first;
}
inline ArbUt::CaseInsensitiveConstString GetNatureName(ArbUt::BorrowedPtr<const Nature> nature) {
inline ArbUt::StringView GetNatureName(ArbUt::BorrowedPtr<const Nature> nature) {
for (const auto& v : _items) {
if (v.second.get() == nature.GetRaw()) {
return v.first;

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

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

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

@ -7,16 +7,14 @@
namespace PkmnLib::Library {
class PokemonForme : public CreatureLib::Library::SpeciesVariant {
public:
PokemonForme(ArbUt::CaseInsensitiveConstString name, float height, float weight, uint32_t baseExperience,
PokemonForme(const ArbUt::StringView& name, float height, float weight, uint32_t baseExperience,
const ArbUt::List<uint8_t>& types, CreatureLib::Library::StatisticSet<uint16_t> baseStats,
const ArbUt::List<ArbUt::CaseInsensitiveConstString>& talents,
const ArbUt::List<ArbUt::CaseInsensitiveConstString>& secretTalents,
const ArbUt::List<ArbUt::StringView>& talents, const ArbUt::List<ArbUt::StringView>& secretTalents,
const CreatureLib::Library::LearnableAttacks* attacks);
private:
public:
inline const ArbUt::CaseInsensitiveConstString&
GetAbility(const CreatureLib::Library::TalentIndex& index) const {
inline const ArbUt::StringView& GetAbility(const CreatureLib::Library::TalentIndex& index) const {
return GetTalent(index);
}
};

11
src/Library/Species/PokemonSpecies.hpp
View File

@ -12,9 +12,8 @@ namespace PkmnLib::Library {
ArbUt::UniquePtrList<const EvolutionData> _evolutions;
public:
PokemonSpecies(uint16_t id, const ArbUt::CaseInsensitiveConstString& name, const PokemonForme* defaultForme,
float genderRatio, const ArbUt::CaseInsensitiveConstString& growthRate, uint8_t captureRate,
uint8_t baseHappiness) noexcept
PokemonSpecies(uint16_t id, const ArbUt::StringView& name, const PokemonForme* defaultForme, float genderRatio,
const ArbUt::StringView& growthRate, uint8_t captureRate, uint8_t baseHappiness) noexcept
: CreatureSpecies(id, name, defaultForme, genderRatio, growthRate, captureRate),
_baseHappiness(baseHappiness) {}
@ -26,9 +25,9 @@ namespace PkmnLib::Library {
return CreatureSpecies::GetVariant("default"_cnc.GetHash()).As<const PokemonForme>();
}
inline bool HasForme(const ArbUt::CaseInsensitiveConstString& key) const { return HasVariant(key); }
inline bool HasForme(const ArbUt::BasicStringView& key) const { return HasVariant(key); }
inline bool TryGetForme(const ArbUt::CaseInsensitiveConstString& key,
inline bool TryGetForme(const ArbUt::BasicStringView& key,
ArbUt::BorrowedPtr<const PokemonForme>& forme) const {
auto v = forme.As<const PokemonForme::SpeciesVariant>();
auto res = TryGetVariant(key, v);
@ -36,7 +35,7 @@ namespace PkmnLib::Library {
return res;
}
inline ArbUt::BorrowedPtr<const PokemonForme> GetForme(const ArbUt::CaseInsensitiveConstString& key) const {
inline ArbUt::BorrowedPtr<const PokemonForme> GetForme(const ArbUt::BasicStringView& key) const {
return CreatureSpecies::GetVariant(key).As<const PokemonForme>();
}

8
src/Library/Species/SpeciesLibrary.hpp
View File

@ -7,7 +7,7 @@
namespace PkmnLib::Library {
class SpeciesLibrary : public CreatureLib::Library::SpeciesLibrary {
public:
inline bool TryGet(const ArbUt::CaseInsensitiveConstString& name,
inline bool TryGet(const ArbUt::BasicStringView& name,
ArbUt::BorrowedPtr<const PokemonSpecies>& outSpecies) const {
auto v = outSpecies.As<const PokemonSpecies::CreatureSpecies>();
auto res = CreatureLib::Library::SpeciesLibrary::TryGet(name, v);
@ -15,15 +15,15 @@ namespace PkmnLib::Library {
return res;
}
inline ArbUt::BorrowedPtr<const PokemonSpecies> Get(const ArbUt::CaseInsensitiveConstString& name) const {
inline ArbUt::BorrowedPtr<const PokemonSpecies> Get(const ArbUt::BasicStringView& name) const {
return CreatureLib::Library::SpeciesLibrary::Get(name).As<const PokemonSpecies>();
}
ArbUt::BorrowedPtr<const PokemonSpecies> operator[](const ArbUt::CaseInsensitiveConstString& name) const {
ArbUt::BorrowedPtr<const PokemonSpecies> operator[](const ArbUt::BasicStringView& name) const {
return Get(name);
}
void Insert(const ArbUt::CaseInsensitiveConstString& name, const PokemonSpecies* species) {
void Insert(const ArbUt::StringView& name, const PokemonSpecies* species) {
CreatureLib::Library::SpeciesLibrary::Insert(name, species);
}
};

23
src/ScriptResolving/AngelScript/AngelScriptResolver.cpp
View File

@ -124,8 +124,9 @@ void AngelScriptResolver::MessageCallback(const asSMessageInfo* msg, void* param
printf("%s (%d, %d) : %s : %s\n", msg->section, msg->row, msg->col, type, msg->message);
}
CreatureLib::Battling::Script* AngelScriptResolver::LoadScript(ScriptCategory category, const ConstString& scriptName) {
ArbUt::Dictionary<ConstString, AngelScriptTypeInfo*> innerDb;
CreatureLib::Battling::Script* AngelScriptResolver::LoadScript(ScriptCategory category,
const ArbUt::StringView& scriptName) {
ArbUt::Dictionary<ArbUt::StringView, AngelScriptTypeInfo*> innerDb;
if (!_typeDatabase.TryGet(category, innerDb)) {
innerDb.Insert(scriptName, nullptr);
_typeDatabase.Insert(category, innerDb);
@ -159,16 +160,17 @@ void AngelScriptResolver::FinalizeModule() {
for (size_t m = 0; m < metadata.size(); m++) {
auto data = metadata[m];
if (std::regex_match(data, base_match, metadataMatcher)) {
auto metadataKind = ArbUt::CaseInsensitiveConstString(base_match[1].str());
auto mt = base_match[1].str();
auto metadataKind = ArbUt::StringView(mt.c_str(), mt.length());
auto metadataVariables = base_match[2].str();
if (!std::regex_match(metadataVariables, base_match, variableMatcher)) {
continue;
}
ConstString effectName;
ArbUt::StringView effectName;
for (size_t variableIndex = 1; variableIndex < base_match.size(); variableIndex += 2) {
if (ArbUt::CaseInsensitiveConstString::GetHash(base_match[variableIndex]) == "effect"_cnc) {
if (ArbUt::StringView::CalculateHash(base_match[variableIndex].str().c_str()) == "effect"_cnc) {
auto val = base_match[variableIndex + 1].str();
effectName = ConstString(val);
effectName = ArbUt::StringView(val.c_str(), val.length());
}
}
if (effectName.Empty()) {
@ -299,17 +301,18 @@ void AngelScriptResolver::LoadByteCodeFromMemory(uint8_t* byte, size_t size) {
delete stream;
}
void AngelScriptResolver::InitializeByteCode(
asIBinaryStream* stream, const ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ConstString, uint32_t>>& types) {
asIBinaryStream* stream,
const ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ArbUt::StringView, uint32_t>>& types) {
auto typeCount = _mainModule->GetObjectTypeCount();
ArbUt::Dictionary<uint32_t, asITypeInfo*> objectTypes;
for (asUINT i = 0; i < typeCount; i++) {
auto t = _mainModule->GetObjectTypeByIndex(i);
objectTypes.Insert(ConstString::GetHash(t->GetName()), t);
objectTypes.Insert(ArbUt::StringView::CalculateHash(t->GetName()), t);
}
ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ConstString, AngelScriptTypeInfo*>> typeDatabase;
ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ArbUt::StringView, AngelScriptTypeInfo*>> typeDatabase;
for (const auto& innerDb : types) {
ArbUt::Dictionary<ConstString, AngelScriptTypeInfo*> newInnerDb;
ArbUt::Dictionary<ArbUt::StringView, AngelScriptTypeInfo*> newInnerDb;
for (const auto& val : innerDb.second) {
auto decl = val.second;
auto type = objectTypes[decl];

17
src/ScriptResolving/AngelScript/AngelScriptResolver.hpp
View File

@ -20,14 +20,13 @@ private:
static void MessageCallback(const asSMessageInfo* msg, void* param);
static void Print(const std::string& str) { std::cout << str << std::endl; }
ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ArbUt::CaseInsensitiveConstString, AngelScriptTypeInfo*>>
_typeDatabase;
ArbUt::Dictionary<ConstString, asITypeInfo*> _baseTypes;
ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ArbUt::StringView, AngelScriptTypeInfo*>> _typeDatabase;
ArbUt::Dictionary<ArbUt::StringView, asITypeInfo*> _baseTypes;
void RegisterTypes();
void InitializeByteCode(
asIBinaryStream* stream,
const ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ArbUt::CaseInsensitiveConstString, uint32_t>>& types);
void
InitializeByteCode(asIBinaryStream* stream,
const ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ArbUt::StringView, uint32_t>>& types);
public:
~AngelScriptResolver() override {
@ -45,14 +44,14 @@ public:
void FinalizeModule();
CreatureLib::Battling::Script* LoadScript(ScriptCategory category, const ConstString& scriptName) override;
CreatureLib::Battling::Script* LoadScript(ScriptCategory category, const ArbUt::StringView& scriptName) override;
void WriteByteCodeToFile(const char* file, bool stripDebugInfo = false);
void LoadByteCodeFromFile(const char* file);
uint8_t* WriteByteCodeToMemory(size_t& size, bool stripDebugInfo = false);
void LoadByteCodeFromMemory(uint8_t*, size_t size);
const ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ArbUt::CaseInsensitiveConstString, AngelScriptTypeInfo*>>&
const ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ArbUt::StringView, AngelScriptTypeInfo*>>&
GetTypeDatabase() const noexcept {
return _typeDatabase;
}
@ -70,7 +69,7 @@ public:
Assert(r >= 0);
}
asITypeInfo* GetBaseType(const ConstString& name) {
asITypeInfo* GetBaseType(const ArbUt::StringView& name) {
asITypeInfo* t = nullptr;
if (!_baseTypes.TryGet(name, t)) {
t = this->_engine->GetTypeInfoByDecl(name.c_str());

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

@ -66,7 +66,7 @@ void AngelScriptScript::OnRemove() { CALL_HOOK(OnRemove, ); }
void AngelScriptScript::OnBeforeTurn(const CreatureLib::Battling::BaseTurnChoice* choice) {
CALL_HOOK(OnBeforeTurn, { ctx->SetArgObject(0, (void*)choice); })
}
void AngelScriptScript::ChangeAttack(CreatureLib::Battling::AttackTurnChoice* choice, ConstString* outAttack) {
void AngelScriptScript::ChangeAttack(CreatureLib::Battling::AttackTurnChoice* choice, ArbUt::StringView* outAttack) {
CALL_HOOK(ChangeAttack, {
ctx->SetArgObject(0, (void*)choice);
ctx->SetArgAddress(0, outAttack);

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

@ -27,11 +27,9 @@ public:
~AngelScriptScript() override { _obj->Release(); }
[[nodiscard]] const ArbUt::CaseInsensitiveConstString& GetName() const noexcept override {
return _type->GetName();
}
[[nodiscard]] const ArbUt::StringView& GetName() const noexcept override { return _type->GetName(); }
asIScriptFunction* PrepareMethod(const ArbUt::CaseInsensitiveConstString& name, asIScriptContext* ctx) {
asIScriptFunction* PrepareMethod(const ArbUt::BasicStringView& name, asIScriptContext* ctx) {
auto func = _type->GetFunction(name);
ctx->Prepare(func);
ctx->SetObject(_obj);
@ -47,8 +45,7 @@ public:
void OnBeforeTurn(const CreatureLib::Battling::BaseTurnChoice* choice) override;
void ChangeAttack(CreatureLib::Battling::AttackTurnChoice* choice,
ArbUt::CaseInsensitiveConstString* outAttack) override;
void ChangeAttack(CreatureLib::Battling::AttackTurnChoice* choice, ArbUt::StringView* outAttack) override;
void PreventAttack(CreatureLib::Battling::ExecutingAttack* attack, bool* outResult) override;

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

@ -3,7 +3,7 @@
#define ANGELSCRIPT_DLL_LIBRARY_IMPORT
#include <Arbutils/Collections/Dictionary.hpp>
#include <Arbutils/ConstString.hpp>
#include <Arbutils/StringView.hpp>
#include <CreatureLib/Library/Exceptions/CreatureException.hpp>
#include <angelscript.h>
#include <cstring>
@ -14,7 +14,7 @@ class AngelScriptTypeInfo {
private:
asITypeInfo* _type = nullptr;
ArbUt::Dictionary<uint32_t, asIScriptFunction*> _functions;
ArbUt::CaseInsensitiveConstString _name;
ArbUt::StringView _name;
struct FunctionInfo {
bool Exists = false;
@ -33,8 +33,8 @@ private:
}
public:
explicit AngelScriptTypeInfo(const ArbUt::CaseInsensitiveConstString& name, asITypeInfo* type)
: _type(type), _name(name) {}
explicit AngelScriptTypeInfo(const ArbUt::StringView& name, asITypeInfo* type) : _type(type), _name(name) {}
~AngelScriptTypeInfo() {
for (const auto& f : _functions) {
f.second->Release();
@ -42,11 +42,11 @@ public:
_functions.Clear();
}
const ArbUt::CaseInsensitiveConstString& GetName() const noexcept { return _name; }
const ArbUt::StringView& GetName() const noexcept { return _name; }
const char* GetDecl() { return _type->GetName(); }
asIScriptFunction* GetFunction(const ArbUt::CaseInsensitiveConstString& functionName) {
asIScriptFunction* GetFunction(const ArbUt::BasicStringView& functionName) {
asIScriptFunction* func;
if (_functions.TryGet(functionName, func)) {
return func;

18
src/ScriptResolving/AngelScript/ByteCodeHandling/IPkmnBinaryStream.hpp
View File

@ -2,7 +2,7 @@
#define PKMNLIB_IPKMNBINARYSTREAM_HPP
#include <Arbutils/Collections/Dictionary.hpp>
#include <Arbutils/ConstString.hpp>
#include <Arbutils/StringView.hpp>
#include <CreatureLib/Battling/ScriptHandling/ScriptCategory.hpp>
#include <angelscript.h>
@ -13,8 +13,8 @@ protected:
IPkmnBinaryStream(size_t angelScriptBound) : _angelScriptBound(angelScriptBound) {}
public:
virtual void
WriteTypes(const ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ConstString, AngelScriptTypeInfo*>>& types) {
virtual void WriteTypes(
const ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ArbUt::StringView, AngelScriptTypeInfo*>>& types) {
// We serialize our types in the format
// "[category(byte)][name(str)]\2[decl(str)]\2[name(str)]\2[decl(str)]\1[category(byte)]...."
@ -38,9 +38,9 @@ public:
Write("\1", sizeof(char));
}
}
virtual ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ConstString, uint32_t>> ReadTypes() {
virtual ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ArbUt::StringView, uint32_t>> ReadTypes() {
_angelScriptBound = SIZE_MAX;
ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ConstString, uint32_t>> types;
ArbUt::Dictionary<ScriptCategory, ArbUt::Dictionary<ArbUt::StringView, uint32_t>> types;
ScriptCategory categoryArr[1];
while (true) {
// Every inner database starts with the category, of known size. Read that.
@ -49,7 +49,7 @@ public:
if (read == 0) {
break;
}
ArbUt::Dictionary<ConstString, uint32_t> innerDb;
ArbUt::Dictionary<ArbUt::StringView, uint32_t> innerDb;
// We don't know the sizes of the name and decl. Allocate 128 characters for them, as that should be enough.
char name[128];
@ -68,8 +68,7 @@ public:
if (isDecl) {
// Insert the name and decl into the dictionary. Close off the decl with eof as well.
decl[pos] = '\0';
innerDb.Insert(ArbUt::CaseInsensitiveConstString(name),
ArbUt::CaseInsensitiveConstString::GetHash(decl));
innerDb.Insert(ArbUt::StringView(name), ArbUt::StringView::CalculateHash(decl));
}
// If we have found \1, we are done with the current category, so break.
break;
@ -80,8 +79,7 @@ public:
if (isDecl) {
// Insert the name and decl into the dictionary. Close off the decl with eof as well.
decl[pos] = '\0';
innerDb.Insert(ArbUt::CaseInsensitiveConstString(name),
ArbUt::CaseInsensitiveConstString::GetHash(decl));
innerDb.Insert(ArbUt::StringView(name), ArbUt::StringView::CalculateHash(decl));
// Reset our position and toggle back to name.
pos = 0;
isDecl = false;

14
src/ScriptResolving/AngelScript/TypeRegistry/Battling/RegisterBattleClass.cpp
View File

@ -65,22 +65,22 @@ void RegisterBattleClass::RegisterBattle(asIScriptEngine* engine) {
Assert(r >= 0);
r = engine->RegisterObjectMethod(
"Battle", "void AddVolatile(const constString &in name) const",
asMETHODPR(PkmnLib::Battling::Battle, AddVolatileScript, (const ConstString&), void), asCALL_THISCALL);
asMETHODPR(PkmnLib::Battling::Battle, AddVolatileScript, (const ArbUt::StringView&), void), asCALL_THISCALL);
Assert(r >= 0);
r = engine->RegisterObjectMethod(
"Battle", "void RemoveVolatile(const constString &in name) const",
asMETHODPR(PkmnLib::Battling::Battle, RemoveVolatileScript, (const ConstString&), void), asCALL_THISCALL);
asMETHODPR(PkmnLib::Battling::Battle, RemoveVolatileScript, (const ArbUt::BasicStringView&), void),
asCALL_THISCALL);
Assert(r >= 0);
r = engine->RegisterObjectMethod("Battle", "void SetWeather(const constString &in name) const",
asMETHODPR(PkmnLib::Battling::Battle, SetWeather, (const ConstString&), void),
asCALL_THISCALL);
r = engine->RegisterObjectMethod(
"Battle", "void SetWeather(const constString &in name) const",
asMETHODPR(PkmnLib::Battling::Battle, SetWeather, (const ArbUt::StringView&), void), asCALL_THISCALL);
Assert(r >= 0);
r = engine->RegisterObjectMethod("Battle", "void ClearWeather(const constString &in name) const",
asMETHODPR(PkmnLib::Battling::Battle, ClearWeather, (), void), asCALL_THISCALL);
Assert(r >= 0);
r = engine->RegisterObjectMethod(
"Battle", "const constString& GetWeatherName() const",
asMETHODPR(PkmnLib::Battling::Battle, GetWeatherName, (), const ArbUt::CaseInsensitiveConstString&),
asCALL_THISCALL);
asMETHODPR(PkmnLib::Battling::Battle, GetWeatherName, (), const ArbUt::StringView&), asCALL_THISCALL);
Assert(r >= 0);
}

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

@ -21,10 +21,11 @@ void RegisterPokemonClass::RegisterDamageSource(asIScriptEngine* engine) {
[[maybe_unused]] int r = engine->RegisterEnum("DamageSource");
Assert(r >= 0);
for (auto v : CreatureLib::Battling::DamageSourceHelper::GetValues()) {
r = engine->RegisterEnumValue("DamageSource", CreatureLib::Battling::DamageSourceHelper::ToString(v), (int)v);
r = engine->RegisterEnumValue("DamageSource", CreatureLib::Battling::DamageSourceHelper::ToString(v).c_str(),
(int)v);
}
for (auto v : PkmnDamageSourceHelper::GetValues()) {
r = engine->RegisterEnumValue("DamageSource", PkmnDamageSourceHelper::ToString(v), (int)v);
r = engine->RegisterEnumValue("DamageSource", PkmnDamageSourceHelper::ToString(v).c_str(), (int)v);
}
Assert(r >= 0);
@ -75,10 +76,12 @@ CScriptArray* GetMoves(const PkmnLib::Battling::Pokemon* obj) {
}
return nullptr;
}
static bool HasHeldItem(const PkmnLib::Battling::Pokemon* obj, const ConstString& str) {
static bool HasHeldItem(const PkmnLib::Battling::Pokemon* obj, const ArbUt::StringView& str) {
return obj->HasHeldItem(str.GetHash());
}
static std::string NicknameWrapper(const PkmnLib::Battling::Pokemon* obj) { return std::string(obj->GetNickname()); }
SMART_PTR_GETTER_FUNC(PkmnLib::Battling::Pokemon, const CreatureLib::Library::CreatureSpecies, GetSpecies);
SMART_PTR_GETTER_FUNC(PkmnLib::Battling::Pokemon, const PkmnLib::Library::PokemonForme, GetForme);
SMART_PTR_GETTER_FUNC(PkmnLib::Battling::Pokemon, const CreatureLib::Library::Item, GetHeldItem);
@ -90,7 +93,7 @@ void RegisterPokemonClass::RegisterPokemonType(asIScriptEngine* engine) {
asFUNCTION(GetSpeciesWrapper), asCALL_CDECL_OBJLAST);
Assert(r >= 0);
r = engine->RegisterObjectMethod("Pokemon", "const Forme@ get_Forme() const property", asFUNCTION(GetFormeWrapper),
asCALL_CDECL_OBJLAST);
asCALL_CDECL_OBJFIRST);
Assert(r >= 0);
r = engine->RegisterObjectMethod("Pokemon", "uint8 get_Level() const property",
asMETHOD(PkmnLib::Battling::Pokemon, GetLevel), asCALL_THISCALL);
@ -99,7 +102,7 @@ void RegisterPokemonClass::RegisterPokemonType(asIScriptEngine* engine) {
asMETHOD(PkmnLib::Battling::Pokemon, GetExperience), asCALL_THISCALL);
Assert(r >= 0);
r = engine->RegisterObjectMethod("Pokemon", "Gender get_Gender() const property", asFUNCTION(Pkmn_GenderWrapper),
asCALL_CDECL_OBJLAST);
asCALL_CDECL_OBJFIRST);
Assert(r >= 0);
r = engine->RegisterObjectMethod("Pokemon", "uint8 get_Coloring() const property",
asMETHOD(PkmnLib::Battling::Pokemon, GetColoring), asCALL_THISCALL);
@ -108,15 +111,14 @@ void RegisterPokemonClass::RegisterPokemonType(asIScriptEngine* engine) {
asMETHOD(PkmnLib::Battling::Pokemon, IsShiny), asCALL_THISCALL);
Assert(r >= 0);
r = engine->RegisterObjectMethod("Pokemon", "const Item@ get_HeldItem() const property",
asFUNCTION(GetHeldItemWrapper), asCALL_CDECL_OBJLAST);
asFUNCTION(GetHeldItemWrapper), asCALL_CDECL_OBJFIRST);
Assert(r >= 0);
r = engine->RegisterObjectMethod("Pokemon", "bool HasHeldItem(const constString &in name) const",
asFUNCTION(HasHeldItem), asCALL_CDECL_OBJFIRST);
Assert(r >= 0);
r = engine->RegisterObjectMethod(
"Pokemon", "void SetHeldItem(const string &in name)",
asMETHODPR(PkmnLib::Battling::Pokemon, SetHeldItem, (const ArbUt::CaseInsensitiveConstString&), void),
asCALL_THISCALL);
asMETHODPR(PkmnLib::Battling::Pokemon, SetHeldItem, (const ArbUt::BasicStringView&), void), asCALL_THISCALL);
Assert(r >= 0);
r = engine->RegisterObjectMethod("Pokemon", "void SetHeldItem(const Item@ item)",
asMETHODPR(PkmnLib::Battling::Pokemon, SetHeldItem,
@ -127,7 +129,7 @@ void RegisterPokemonClass::RegisterPokemonType(asIScriptEngine* engine) {
asMETHOD(PkmnLib::Battling::Pokemon, GetCurrentHealth), asCALL_THISCALL);
Assert(r >= 0);
r = engine->RegisterObjectMethod("Pokemon", "const string& get_Nickname() const property",
asMETHOD(PkmnLib::Battling::Pokemon, GetNickname), asCALL_THISCALL);
asFUNCTION(NicknameWrapper), asCALL_CDECL_OBJFIRST);
Assert(r >= 0);
r = engine->RegisterObjectMethod("Pokemon", "const constString& get_ActiveAbility() const property",
asMETHOD(PkmnLib::Battling::Pokemon, GetActiveTalent), asCALL_THISCALL);
@ -151,7 +153,7 @@ void RegisterPokemonClass::RegisterPokemonType(asIScriptEngine* engine) {
asMETHOD(PkmnLib::Battling::Pokemon, OverrideActiveTalent), asCALL_THISCALL);
Assert(r >= 0);
r = engine->RegisterObjectMethod("Pokemon", "LearnedMove@[]@ GetMoves() const", asFUNCTION(GetMoves),
asCALL_CDECL_OBJLAST);
asCALL_CDECL_OBJFIRST);
Assert(r >= 0);
r = engine->RegisterObjectMethod("Pokemon", "void ChangeStatBoost(Statistic stat, int8 amount)",
asMETHOD(PkmnLib::Battling::Pokemon, ChangeStatBoost), asCALL_THISCALL);
@ -176,10 +178,11 @@ void RegisterPokemonClass::RegisterPokemonType(asIScriptEngine* engine) {
Assert(r >= 0);
r = engine->RegisterObjectMethod(
"Pokemon", "void AddVolatile(const constString &in name) const",
asMETHODPR(PkmnLib::Battling::Pokemon, AddVolatileScript, (const ConstString&), void), asCALL_THISCALL);
asMETHODPR(PkmnLib::Battling::Pokemon, AddVolatileScript, (const ArbUt::StringView&), void), asCALL_THISCALL);
Assert(r >= 0);
r = engine->RegisterObjectMethod(
"Pokemon", "void RemoveVolatile(const constString &in name) const",
asMETHODPR(PkmnLib::Battling::Pokemon, RemoveVolatileScript, (const ConstString&), void), asCALL_THISCALL);
asMETHODPR(PkmnLib::Battling::Pokemon, RemoveVolatileScript, (const ArbUt::BasicStringView&), void),
asCALL_THISCALL);
Assert(r >= 0);
}

49
src/ScriptResolving/AngelScript/TypeRegistry/ConstString.cpp
View File

@ -1,18 +1,18 @@
#include "ConstString.hpp"
using ConstString = ArbUt::CaseInsensitiveConstString;
#include <Arbutils/StringView.hpp>
static void ConstructConstString(void* self) { new (self) ConstString(); }
static void CopyConstructConstString(const ConstString& other, void* self) { new (self) ConstString(other); }
static void DestructConstString(void* self) { ((ConstString*)self)->~ConstString(); }
static bool ConstStringEquality(const ConstString& a, const ConstString& b) { return a == b; }
static bool ConstStringStdStringEquality(const ConstString& a, const std::string& b) { return a == b; }
static ConstString ImplStdStringConstStringConv(const std::string& s) { return ConstString(s); }
static std::string ImplConstStringStdStringConv(const ConstString& s) { return s.std_str(); }
static uint32_t ImplConstStringHashConv(const ConstString& s) { return s.GetHash(); }
static void ConstructConstString(void* self) { new (self) ArbUt::StringView(); }
static void CopyConstructConstString(const ArbUt::StringView& other, void* self) {
new (self) ArbUt::StringView(other);
}
static void DestructConstString(void* self) { ((ArbUt::StringView*)self)->~StringView(); }
static bool ConstStringEquality(const ArbUt::StringView& a, const ArbUt::StringView& b) { return a == b; }
static bool ConstStringStdStringEquality(const ArbUt::StringView& a, const std::string& b) { return a == b; }
static uint32_t ImplConstStringHashConv(const ArbUt::StringView& s) { return s.GetHash(); }
void ConstStringRegister::Register(asIScriptEngine* engine) {
auto r = engine->RegisterObjectType("constString", sizeof(ArbUt::CaseInsensitiveConstString),
asOBJ_VALUE | asOBJ_APP_CLASS_CDAK);
auto r = engine->RegisterObjectType("constString", sizeof(ArbUt::StringView),
asOBJ_VALUE | asGetTypeTraits<ArbUt::StringView>());
Assert(r >= 0);
r = engine->RegisterObjectBehaviour("constString", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructConstString),
@ -27,33 +27,24 @@ void ConstStringRegister::Register(asIScriptEngine* engine) {
asCALL_CDECL_OBJLAST);
Assert(r >= 0);
r = engine->RegisterObjectMethod("constString", "constString &opAssign(const constString &in)",
asMETHODPR(ConstString, operator=,(const ConstString&), ConstString&),
asCALL_THISCALL);
r = engine->RegisterObjectMethod(
"constString", "constString &opAssign(const constString &in)",
asMETHODPR(ArbUt::StringView, operator=, (const ArbUt::StringView&), ArbUt::StringView&), asCALL_THISCALL);
Assert(r >= 0);
r = engine->RegisterObjectMethod("constString", "bool opEquals(const constString &in) const",
asFUNCTIONPR(ConstStringEquality, (const ConstString&, const ConstString&), bool),
asCALL_CDECL_OBJFIRST);
r = engine->RegisterObjectMethod(
"constString", "bool opEquals(const constString &in) const",
asFUNCTIONPR(ConstStringEquality, (const ArbUt::StringView&, const ArbUt::StringView&), bool),
asCALL_CDECL_OBJFIRST);
Assert(r >= 0);
r = engine->RegisterObjectMethod(
"constString", "bool opEquals(const string &in) const",
asFUNCTIONPR(ConstStringStdStringEquality, (const ConstString&, const std::string&), bool),
asFUNCTIONPR(ConstStringStdStringEquality, (const ArbUt::StringView&, const std::string&), bool),
asCALL_CDECL_OBJFIRST);
Assert(r >= 0);
r = engine->RegisterObjectMethod("string", "constString opImplConv()",
asFUNCTIONPR(ImplStdStringConstStringConv, (const std::string&), ConstString),
asCALL_CDECL_OBJFIRST);
Assert(r >= 0);
r = engine->RegisterObjectMethod("constString", "string opImplConv()",
asFUNCTIONPR(ImplConstStringStdStringConv, (const ConstString&), std::string),
asCALL_CDECL_OBJFIRST);
Assert(r >= 0);
r = engine->RegisterObjectMethod("constString", "uint opImplConv()",
asFUNCTIONPR(ImplConstStringHashConv, (const ConstString&), uint32_t),
asFUNCTIONPR(ImplConstStringHashConv, (const ArbUt::StringView&), uint32_t),
asCALL_CDECL_OBJFIRST);
Assert(r >= 0);
}

1
src/ScriptResolving/AngelScript/TypeRegistry/ConstString.hpp
View File

@ -1,7 +1,6 @@
#ifndef PKMNLIB_CONSTSTRING_HPP
#define PKMNLIB_CONSTSTRING_HPP
#include <Arbutils/Assert.hpp>
#include <Arbutils/ConstString.hpp>
#include <angelscript.h>
class ConstStringRegister {
public:

14
src/ScriptResolving/AngelScript/TypeRegistry/Library/RegisterEffectParameter.cpp
View File

@ -4,16 +4,14 @@
static CreatureLib::Library::EffectParameter* Ref_Factory() { return new CreatureLib::Library::EffectParameter(); }
static const ArbUt::CaseInsensitiveConstString& AsString(const CreatureLib::Library::EffectParameter* p) {
return p->AsString();
}
static const ArbUt::StringView& AsString(const CreatureLib::Library::EffectParameter* p) { return p->AsString(); }
void RegisterEffectParameter::Register(asIScriptEngine* engine) {
[[maybe_unused]] int r = engine->RegisterEnum("EffectParameterType");
Assert(r >= 0);
for (auto val : CreatureLib::Library::EffectParameterTypeHelper::GetValues()) {
r = engine->RegisterEnumValue("EffectParameterType",
CreatureLib::Library::EffectParameterTypeHelper::ToString(val), (int)val);
CreatureLib::Library::EffectParameterTypeHelper::ToString(val).c_str(), (int)val);
Assert(r >= 0);
}
@ -36,9 +34,9 @@ void RegisterEffectParameter::Register(asIScriptEngine* engine) {
r = engine->RegisterObjectMethod("EffectParameter", "float AsFloat() const",
asMETHOD(CreatureLib::Library::EffectParameter, AsFloat), asCALL_THISCALL);
Assert(r >= 0);
r = engine->RegisterObjectMethod("EffectParameter", "const constString& AsString() const",
asFUNCTIONPR(AsString, (const CreatureLib::Library::EffectParameter*),
const ArbUt::CaseInsensitiveConstString&),
asCALL_CDECL_OBJFIRST);
r = engine->RegisterObjectMethod(
"EffectParameter", "const constString& AsString() const",
asFUNCTIONPR(AsString, (const CreatureLib::Library::EffectParameter*), const ArbUt::StringView&),
asCALL_CDECL_OBJFIRST);
Assert(r >= 0);
}

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

@ -18,11 +18,11 @@ void RegisterGrowthRateTypes::RegisterGrowthRateType(asIScriptEngine* engine) {
assert(r >= 0);
}
static uint8_t CalculateLevel(const CreatureLib::Library::GrowthRateLibrary* obj, const ConstString& str,
static uint8_t CalculateLevel(const CreatureLib::Library::GrowthRateLibrary* obj, const ArbUt::StringView& str,
uint32_t experience) {
return obj->CalculateLevel(str, experience);
}
static uint32_t CalculateExperience(const CreatureLib::Library::GrowthRateLibrary* obj, const ConstString& str,
static uint32_t CalculateExperience(const CreatureLib::Library::GrowthRateLibrary* obj, const ArbUt::StringView& str,
uint8_t level) {
return obj->CalculateExperience(str, level);
}

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

@ -58,9 +58,7 @@ 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 ArbUt::CaseInsensitiveConstString& str) {
return obj->HasFlag(str);
}
static bool HasFlag(const PkmnLib::Library::Item* obj, const ArbUt::BasicStringView& str) { return obj->HasFlag(str); }
void RegisterItemTypes::RegisterItemType(asIScriptEngine* engine) {
[[maybe_unused]] int r = engine->RegisterObjectType("Item", 0, asOBJ_REF | asOBJ_NOCOUNT);

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

@ -1,5 +1,5 @@
#include "RegisterMoveTypes.hpp"
#include <cassert>
#include <Arbutils/Assert.hpp>
#include "../../../../Library/Moves/MoveData.hpp"
#include "../../../../Library/Moves/MoveLibrary.hpp"
@ -12,11 +12,11 @@ void RegisterMoveTypes::Register(asIScriptEngine* engine) {
#define REGISTER_ENUM_VALUE(asName, cName, valueName) \
r = engine->RegisterEnumValue(#asName, #valueName, (int)cName::valueName); \
assert(r >= 0);
Assert(r >= 0);
void RegisterMoveTypes::RegisterMoveCategory(asIScriptEngine* engine) {
[[maybe_unused]] int r = engine->RegisterEnum("MoveCategory");
assert(r >= 0);
Assert(r >= 0);
REGISTER_ENUM_VALUE(MoveCategory, PkmnLib::Library::MoveCategory, Physical)
REGISTER_ENUM_VALUE(MoveCategory, PkmnLib::Library::MoveCategory, Special)
REGISTER_ENUM_VALUE(MoveCategory, PkmnLib::Library::MoveCategory, Status)
@ -24,7 +24,7 @@ void RegisterMoveTypes::RegisterMoveCategory(asIScriptEngine* engine) {
void RegisterMoveTypes::RegisterMoveTarget(asIScriptEngine* engine) {
[[maybe_unused]] int r = engine->RegisterEnum("MoveTarget");
assert(r >= 0);
Assert(r >= 0);
REGISTER_ENUM_VALUE(MoveTarget, CreatureLib::Library::AttackTarget, Adjacent)
REGISTER_ENUM_VALUE(MoveTarget, CreatureLib::Library::AttackTarget, AdjacentAlly)
REGISTER_ENUM_VALUE(MoveTarget, CreatureLib::Library::AttackTarget, AdjacentAllySelf)
@ -46,47 +46,47 @@ 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 ArbUt::CaseInsensitiveConstString& str) {
static bool HasFlag(const PkmnLib::Library::MoveData* obj, const ArbUt::BasicStringView& 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);
Assert(r >= 0);
r = engine->RegisterObjectMethod("MoveData", "const constString& get_Name() const property",
asMETHOD(PkmnLib::Library::MoveData, GetName), asCALL_THISCALL);
assert(r >= 0);
Assert(r >= 0);
r = engine->RegisterObjectMethod("MoveData", "uint8 get_Type() const property",
asMETHOD(PkmnLib::Library::MoveData, GetType), asCALL_THISCALL);
assert(r >= 0);
Assert(r >= 0);
r = engine->RegisterObjectMethod("MoveData", "MoveCategory get_Category() const property",
asFUNCTION(Move_CategoryWrapper), asCALL_CDECL_OBJLAST);
assert(r >= 0);
Assert(r >= 0);
r = engine->RegisterObjectMethod("MoveData", "uint8 get_BasePower() const property",
asMETHOD(PkmnLib::Library::MoveData, GetBasePower), asCALL_THISCALL);
assert(r >= 0);
Assert(r >= 0);
r = engine->RegisterObjectMethod("MoveData", "uint8 get_Accuracy() const property",
asMETHOD(PkmnLib::Library::MoveData, GetAccuracy), asCALL_THISCALL);
assert(r >= 0);
Assert(r >= 0);
r = engine->RegisterObjectMethod("MoveData", "uint8 get_BaseUsages() const property",
asMETHOD(PkmnLib::Library::MoveData, GetBaseUsages), asCALL_THISCALL);
assert(r >= 0);
Assert(r >= 0);
r = engine->RegisterObjectMethod("MoveData", "MoveTarget get_Target() const property",
asFUNCTION(Move_TargetWrapper), asCALL_CDECL_OBJLAST);
assert(r >= 0);
Assert(r >= 0);
r = engine->RegisterObjectMethod("MoveData", "int8 get_Priority() const property",
asMETHOD(PkmnLib::Library::MoveData, GetPriority), asCALL_THISCALL);
assert(r >= 0);
Assert(r >= 0);
r = engine->RegisterObjectMethod("MoveData", "bool HasFlag(const constString &in flag) const", asFUNCTION(HasFlag),
asCALL_CDECL_OBJLAST);
assert(r >= 0);
Assert(r >= 0);
}
void RegisterMoveTypes::RegisterMoveLibrary(asIScriptEngine* engine) {
[[maybe_unused]] int r = engine->RegisterObjectType("MoveLibrary", 0, asOBJ_REF | asOBJ_NOCOUNT);
assert(r >= 0);
Assert(r >= 0);
r = engine->RegisterObjectMethod("MoveLibrary", "const MoveData@ Get(const constString &in name) const",
asMETHOD(PkmnLib::Library::MoveLibrary, Get), asCALL_THISCALL);
assert(r >= 0);
Assert(r >= 0);
}
#undef REGISTER_ENUM_VALUE

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

@ -43,7 +43,7 @@ void RegisterSpeciesTypes::RegisterStatisticEnum(asIScriptEngine* engine) {
static const PkmnLib::Library::PokemonForme* GetFormeWrapper(const std::string& s,
const PkmnLib::Library::PokemonSpecies* species) {
return species->GetForme(ArbUt::CaseInsensitiveConstString(s.c_str(), s.length()))
return species->GetForme(ArbUt::StringView(s.c_str(), s.length()))
.As<const PkmnLib::Library::PokemonForme>()
.GetRaw();
}
@ -75,7 +75,7 @@ void RegisterSpeciesTypes::RegisterSpeciesType(asIScriptEngine* engine) {
assert(r >= 0);
}
const ArbUt::CaseInsensitiveConstString& GetAbility(PkmnLib::Library::PokemonForme* p, bool hidden, uint8_t index) {
const ArbUt::StringView& GetAbility(PkmnLib::Library::PokemonForme* p, bool hidden, uint8_t index) {
return p->GetAbility(CreatureLib::Library::TalentIndex(hidden, index));
}
@ -106,7 +106,7 @@ void RegisterSpeciesTypes::RegisterFormeType(asIScriptEngine* engine) {
r = engine->RegisterObjectMethod("Forme", "const constString& GetAbility(bool hidden, uint8 index) const",
asFUNCTIONPR(GetAbility,
(PkmnLib::Library::PokemonForme * p, bool hidden, uint8_t index),
const ArbUt::CaseInsensitiveConstString&),
const ArbUt::StringView&),
asCALL_CDECL_OBJFIRST);
assert(r >= 0);
}

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

@ -4,7 +4,7 @@
void RegisterTypeLibrary::Register(asIScriptEngine* engine) { RegisterTypeLibraryType(engine); }
static bool GetTypeId(const CreatureLib::Library::TypeLibrary* obj, const ArbUt::CaseInsensitiveConstString& str) {
static bool GetTypeId(const CreatureLib::Library::TypeLibrary* obj, const ArbUt::BasicStringView& str) {
return obj->GetTypeId(str);
}

9
tests/PokemonTests/BasicPokemonTests.cpp
View File

@ -20,11 +20,10 @@ TEST_CASE("Get Nature from Pokemon") {
TEST_CASE("Get Attack name from Pokemon") {
auto lib = TestLibrary::GetLibrary();
auto mon =
PkmnLib::Battling::CreatePokemon(lib, "testSpecies"_cnc, 1)
.LearnMove(ArbUt::CaseInsensitiveConstString("testMove"), CreatureLib::Battling::AttackLearnMethod::Level)
.LearnMove(ArbUt::CaseInsensitiveConstString("testMove2"), CreatureLib::Battling::AttackLearnMethod::Level)
.Build();
auto mon = PkmnLib::Battling::CreatePokemon(lib, "testSpecies"_cnc, 1)
.LearnMove("testMove"_cnc, CreatureLib::Battling::AttackLearnMethod::Level)
.LearnMove("testMove2"_cnc, CreatureLib::Battling::AttackLearnMethod::Level)
.Build();
auto move = mon->GetMoves()[0];
REQUIRE(move->GetMoveData()->GetName() == "testMove"_cnc);
auto move2 = mon->GetMoves()[1];

7
tests/ScriptTests/BaseScriptClassTests.cpp
View File

@ -88,7 +88,7 @@ static AngelScriptResolver* GetScriptResolver(PkmnLib::Battling::BattleLibrary*
return _resolverCache;
}
static AngelScriptScript* GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ConstString& scriptName) {
static AngelScriptScript* GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ArbUt::StringView& scriptName) {
auto lib = GetScriptResolver(mainLib);
auto s = lib->LoadScript(ScriptCategory::Creature, scriptName);
auto script = dynamic_cast<AngelScriptScript*>(s);
@ -113,7 +113,7 @@ TEST_CASE("Invoke OnInitialize script function") {
auto parameters = {new CreatureLib::Library::EffectParameter(true),
new CreatureLib::Library::EffectParameter((int64_t)684),
new CreatureLib::Library::EffectParameter(ArbUt::CaseInsensitiveConstString("foobar"))};
new CreatureLib::Library::EffectParameter(ArbUt::StringView("foobar"))};
script->OnInitialize(parameters);
@ -134,9 +134,6 @@ TEST_CASE("Invoke OnInitialize script function") {
ctx = ctxPool->RequestContext();
script->PrepareMethod("GetStringValue"_cnc, ctx);
REQUIRE(ctx->Execute() == asEXECUTION_FINISHED);
// Arbutils::CaseInsensitiveConstString s;
// s = *(Arbutils::CaseInsensitiveConstString*)ctx->GetReturnAddress();
// REQUIRE(s == "foobar"_cnc);
ctxPool->ReturnContextToPool(ctx);
for (auto p : parameters) {

34
tests/ScriptTests/ScriptTypeTests/Battle/PokemonTests.cpp
View File

@ -24,7 +24,7 @@ class testScript1 {
void testDamage(Pokemon@ p, uint32 damage, DamageSource source){ p.Damage(damage, source); }
void testHeal(Pokemon@ p, uint32 amount){ p.Heal(amount); }
bool testMove(Pokemon@ p, uint index, LearnedMove@ move){ return p.GetMoves()[index] is move; }
bool testHasHeldItem(Pokemon@ p, const string &in item){ return p.HasHeldItem(item); }
bool testHasHeldItem(Pokemon@ p, const constString &in item){ return p.HasHeldItem(item); }
}}
)"}};
@ -52,7 +52,7 @@ static AngelScriptResolver* GetScriptResolver(PkmnLib::Battling::BattleLibrary*
return _resolverCache;
}
static ScriptData GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ConstString& funcName) {
static ScriptData GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ArbUt::StringView& funcName) {
auto lib = GetScriptResolver(mainLib);
auto s = lib->LoadScript(ScriptCategory::Creature, "testScript1"_cnc);
auto script = dynamic_cast<AngelScriptScript*>(s);
@ -185,20 +185,20 @@ TEST_CASE("Validate Pokemon CurrentHealth in Script") {
}
TEST_CASE("Validate Pokemon Nickname in Script") {
auto mainLib = TestLibrary::GetLibrary();
auto data = GetScript(mainLib, "testNickname"_cnc);
auto mon = PkmnLib::Battling::CreatePokemon(mainLib, "testSpecies"_cnc, 30)
.WithForme("default"_cnc)
.WithGender(CreatureLib::Library::Gender::Male)
.Build();
data.Context->SetArgObject(0, const_cast<PkmnLib::Battling::Pokemon*>(mon));
auto name = mon->GetNickname();
data.Context->SetArgAddress(1, &name);
REQUIRE(data.Context->Execute() == asEXECUTION_FINISHED);
REQUIRE((bool)data.Context->GetReturnWord());
delete mon;
// auto mainLib = TestLibrary::GetLibrary();
// auto data = GetScript(mainLib, "testNickname"_cnc);
//
// auto mon = PkmnLib::Battling::CreatePokemon(mainLib, "testSpecies"_cnc, 30)
// .WithForme("default"_cnc)
// .WithGender(CreatureLib::Library::Gender::Male)
// .Build();
// data.Context->SetArgObject(0, (void*)mon);
// auto name = std::string(mon->GetNickname());
// data.Context->SetArgAddress(1, &name);
//
// REQUIRE(data.Context->Execute() == asEXECUTION_FINISHED);
// REQUIRE((bool)data.Context->GetReturnWord());
// delete mon;
}
TEST_CASE("Validate Pokemon Active Ability in Script") {
@ -324,7 +324,7 @@ TEST_CASE("Validate Pokemon HasHeldItem in Script") {
auto data = GetScript(mainLib, "testHasHeldItem"_cnc);
data.Context->SetArgObject(0, const_cast<PkmnLib::Battling::Pokemon*>(mon));
std::string item = "testItem";
ArbUt::StringView item = "testItem"_cnc;
data.Context->SetArgAddress(1, &item);
REQUIRE(data.Context->Execute() == asEXECUTION_FINISHED);

2
tests/ScriptTests/ScriptTypeTests/Library/FormesTests.cpp
View File

@ -42,7 +42,7 @@ static AngelScriptResolver* GetScriptResolver(PkmnLib::Battling::BattleLibrary*
return _resolverCache;
}
static ScriptData GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ConstString& funcName) {
static ScriptData GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ArbUt::StringView& funcName) {
auto lib = GetScriptResolver(mainLib);
auto s = lib->LoadScript(ScriptCategory::Creature, "testScript1"_cnc);
auto script = dynamic_cast<AngelScriptScript*>(s);

2
tests/ScriptTests/ScriptTypeTests/Library/ItemDataTests.cpp
View File

@ -38,7 +38,7 @@ static AngelScriptResolver* GetScriptResolver(PkmnLib::Battling::BattleLibrary*
return _resolverCache;
}
static ScriptData GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ConstString& funcName) {
static ScriptData GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ArbUt::StringView& funcName) {
auto lib = GetScriptResolver(mainLib);
auto s = lib->LoadScript(ScriptCategory::Creature, "testScript1"_cnc);
auto script = dynamic_cast<AngelScriptScript*>(s);

2
tests/ScriptTests/ScriptTypeTests/Library/MoveTests.cpp
View File

@ -42,7 +42,7 @@ static AngelScriptResolver* GetScriptResolver(PkmnLib::Battling::BattleLibrary*
return _resolverCache;
}
static ScriptData GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ConstString& funcName) {
static ScriptData GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ArbUt::StringView& funcName) {
auto lib = GetScriptResolver(mainLib);
auto s = lib->LoadScript(ScriptCategory::Creature, "testScript1"_cnc);
auto script = dynamic_cast<AngelScriptScript*>(s);

2
tests/ScriptTests/ScriptTypeTests/Library/SpeciesTests.cpp
View File

@ -40,7 +40,7 @@ static AngelScriptResolver* GetScriptResolver(PkmnLib::Battling::BattleLibrary*
return _resolverCache;
}
static ScriptData GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ConstString& funcName) {
static ScriptData GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ArbUt::StringView& funcName) {
auto lib = GetScriptResolver(mainLib);
auto s = lib->LoadScript(ScriptCategory::Creature, "testScript1"_cnc);
auto script = dynamic_cast<AngelScriptScript*>(s);

2
tests/ScriptTests/ScriptTypeTests/Library/StaticLibraryTests.cpp
View File

@ -41,7 +41,7 @@ static AngelScriptResolver* GetScriptResolver(PkmnLib::Battling::BattleLibrary*
return _resolverCache;
}
static ScriptData GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ConstString& funcName) {
static ScriptData GetScript(PkmnLib::Battling::BattleLibrary* mainLib, const ArbUt::StringView& funcName) {
auto lib = GetScriptResolver(mainLib);
auto s = lib->LoadScript(ScriptCategory::Creature, "testScript1"_cnc);
auto script = dynamic_cast<AngelScriptScript*>(s);

2
tests/TestLibrary/TestLibrary.cpp
View File

@ -1,5 +1,5 @@
#include "TestLibrary.hpp"
#include <Arbutils/ConstString.hpp>
#include <Arbutils/StringView.hpp>
PkmnLib::Battling::BattleLibrary* TestLibrary::_library = nullptr;
PkmnLib::Library::SpeciesLibrary* TestLibrary::BuildSpeciesLibrary() {