CreatureLib/tests/TestLibrary/TestLibrary.cpp

#ifdef TESTS_BUILD

#include "TestLibrary.hpp"
#include "../../src/Library/GrowthRates/LookupGrowthRate.hpp"

using namespace CreatureLib::Core;
using namespace CreatureLib::Library;
using namespace CreatureLib::Battling;
BattleLibrary* TestLibrary::_library = nullptr;

BattleLibrary* TestLibrary::Get() {
    if (TestLibrary::_library == nullptr) {
        auto l = new DataLibrary(LibrarySettings(100, 4), BuildSpeciesLibrary(), BuildAttackLibrary(),
                                 BuildItemLibrary(), BuildGrowthRateLibrary(), BuildTypeLibrary());
        auto statCalc = new BattleStatCalculator();
        auto battleLib = new BattleLibrary(l, statCalc, new DamageLibrary(), new CriticalLibrary(),
                                           new ExperienceLibrary(), new ScriptResolver());
        TestLibrary::_library = battleLib;
    }
    return TestLibrary::_library;
}

SpeciesLibrary* TestLibrary::BuildSpeciesLibrary() {
    auto l = new SpeciesLibrary();
    l->LoadSpecies("testSpecies1",
                   new CreatureSpecies(
                       0, "testSpecies1",
                       new SpeciesVariant("default", 1, 1, 10, {0, 1}, StatisticSet<uint16_t>(10, 10, 10, 10, 10, 10),
                                          {"testTalent"}, {"testSecretTalent"}, new LearnableAttacks(100)),
                       0.5f, "testGrowthRate", 5, 100));
    return l;
}

AttackLibrary* TestLibrary::BuildAttackLibrary() {
    auto l = new AttackLibrary();
    l->LoadAttack("standard", new AttackData("standard", "normal", AttackCategory::Physical, 20, 100, 30,
                                             AttackTarget::AdjacentOpponent, 0, {}));
    l->LoadAttack("highPriority", new AttackData("highPriority", "normal", AttackCategory::Physical, 20, 100, 30,
                                                 AttackTarget::AdjacentOpponent, 1, {}));
    l->LoadAttack("higherPriority", new AttackData("higherPriority", "normal", AttackCategory::Physical, 20, 100, 30,
                                                   AttackTarget::AdjacentOpponent, 2, {}));
    l->LoadAttack("lowPriority", new AttackData("lowPriority", "normal", AttackCategory::Physical, 20, 100, 30,
                                                AttackTarget::AdjacentOpponent, -1, {}));
    return l;
}

ItemLibrary* TestLibrary::BuildItemLibrary() {
    auto l = new ItemLibrary();
    return l;
}

GrowthRateLibrary* TestLibrary::BuildGrowthRateLibrary() {
    auto l = new GrowthRateLibrary();
    l->AddGrowthRate("testGrowthRate", new LookupGrowthRate());
    return l;
}

TypeLibrary* TestLibrary::BuildTypeLibrary() {
    auto l = new TypeLibrary();
    l->RegisterType("testType1");
    l->RegisterType("testType2");
    l->RegisterType("testType3");
    return l;
}

#endif