CreatureLib/tests/BattleTests/TurnOrderTests.cpp

#ifdef TESTS_BUILD

#include "../TestLibrary/TestLibrary.cpp"
#include "../../src/Battling/TurnChoices/PassTurnChoice.hpp"
#include "../../src/Battling/TurnChoices/AttackTurnChoice.hpp"
#include "../../src/Battling/Flow/TurnOrdering.hpp"

using namespace CreatureLib;
using namespace CreatureLib::Battling;

TEST_CASE( "Turn ordering: Attack before pass", "[Battling]" ) {
    auto choice1 = new PassTurnChoice(nullptr);
    auto choice2 = new AttackTurnChoice(nullptr, nullptr);
    auto vec = std::vector<const BaseTurnChoice*>{choice1, choice2};
    auto rand = Core::Random();
    TurnOrdering::OrderChoices(vec,rand);
    CHECK(vec[0] == choice2);
    CHECK(vec[1] == choice1);
    vec = std::vector<const BaseTurnChoice*>{choice2, choice1};
    TurnOrdering::OrderChoices(vec,rand);
    CHECK(vec[0] == choice2);
    CHECK(vec[1] == choice1);

    delete choice1;
    delete choice2;
}

TEST_CASE( "Turn ordering: High priority goes before no priority", "[Battling]" ) {
    auto l = GetLibrary()->GetAttackLibrary();
    auto a1 = new LearnedAttack(l->GetAttack("standard"), AttackLearnMethod::Unknown);
    auto a2 = new LearnedAttack(l->GetAttack("highPriority"), AttackLearnMethod::Unknown);
    auto choice1 = new AttackTurnChoice(nullptr, a1);
    auto choice2 = new AttackTurnChoice(nullptr, a2);
    auto vec = std::vector<const BaseTurnChoice*>{choice1, choice2};
    auto rand = Core::Random();
    TurnOrdering::OrderChoices(vec,rand);
    CHECK(vec[0] == choice2);
    CHECK(vec[1] == choice1);
    vec = std::vector<const BaseTurnChoice*>{choice2, choice1};
    TurnOrdering::OrderChoices(vec,rand);
    CHECK(vec[0] == choice2);
    CHECK(vec[1] == choice1);

    delete choice1;
    delete choice2;
    delete a1;
    delete a2;
}

TEST_CASE( "Turn ordering: Higher priority goes before high priority", "[Battling]" ) {
    auto l = GetLibrary()->GetAttackLibrary();
    auto a1 = new LearnedAttack(l->GetAttack("highPriority"), AttackLearnMethod::Unknown);
    auto a2 = new LearnedAttack(l->GetAttack("higherPriority"), AttackLearnMethod::Unknown);
    auto choice1 = new AttackTurnChoice(nullptr, a1);
    auto choice2 = new AttackTurnChoice(nullptr, a2);
    auto vec = std::vector<const BaseTurnChoice*>{choice1, choice2};
    auto rand = Core::Random();
    TurnOrdering::OrderChoices(vec,rand);
    CHECK(vec[0] == choice2);
    CHECK(vec[1] == choice1);
    vec = std::vector<const BaseTurnChoice*>{choice2, choice1};
    TurnOrdering::OrderChoices(vec,rand);
    CHECK(vec[0] == choice2);
    CHECK(vec[1] == choice1);

    delete choice1;
    delete choice2;
    delete a1;
    delete a2;
}

TEST_CASE( "Turn ordering: High priority goes before low priority", "[Battling]" ) {
    auto l = GetLibrary()->GetAttackLibrary();
    auto a1 = new LearnedAttack(l->GetAttack("lowPriority"), AttackLearnMethod::Unknown);
    auto a2 = new LearnedAttack(l->GetAttack("higherPriority"), AttackLearnMethod::Unknown);
    auto choice1 = new AttackTurnChoice(nullptr, a1);
    auto choice2 = new AttackTurnChoice(nullptr, a2);
    auto vec = std::vector<const BaseTurnChoice*>{choice1, choice2};
    auto rand = Core::Random();
    TurnOrdering::OrderChoices(vec,rand);
    CHECK(vec[0] == choice2);
    CHECK(vec[1] == choice1);
    vec = std::vector<const BaseTurnChoice*>{choice2, choice1};
    TurnOrdering::OrderChoices(vec,rand);
    CHECK(vec[0] == choice2);
    CHECK(vec[1] == choice1);

    delete choice1;
    delete choice2;
    delete a1;
    delete a2;
}

TEST_CASE( "Turn ordering: No priority goes before low priority", "[Battling]" ) {
    auto l = GetLibrary()->GetAttackLibrary();
    auto a1 = new LearnedAttack(l->GetAttack("lowPriority"), AttackLearnMethod::Unknown);
    auto a2 = new LearnedAttack(l->GetAttack("standard"), AttackLearnMethod::Unknown);
    auto choice1 = new AttackTurnChoice(nullptr, a1);
    auto choice2 = new AttackTurnChoice(nullptr, a2);
    auto vec = std::vector<const BaseTurnChoice*>{choice1, choice2};
    auto rand = Core::Random();
    TurnOrdering::OrderChoices(vec,rand);
    CHECK(vec[0] == choice2);
    CHECK(vec[1] == choice1);
    vec = std::vector<const BaseTurnChoice*>{choice2, choice1};
    TurnOrdering::OrderChoices(vec,rand);
    CHECK(vec[0] == choice2);
    CHECK(vec[1] == choice1);

    delete choice1;
    delete choice2;
    delete a1;
    delete a2;
}



#endif