CreatureLib/src/Battling/Flow/ResolveTarget.cpp

#include "ResolveTarget.hpp"
using namespace ArbUt;
using namespace CreatureLib::Library;
using namespace CreatureLib::Battling;

static inline constexpr uint8_t GetOppositeSide(uint8_t v) {
    if (v == 1) {
        return 0;
    }
    return 1;
}

static inline List<OptionalBorrowedPtr<Creature>> GetAll(const BorrowedPtr<Battle>& battle) {
    List<OptionalBorrowedPtr<Creature>> arr(battle->GetCreaturesPerSide() * battle->GetSides().Count());
    for (auto* side : battle->GetSides()) {
        for (const auto& mon : side->GetCreatures()) {
            arr.Append(mon);
        }
    }
    return arr;
}

static inline List<OptionalBorrowedPtr<Creature>> GetAllAdjacent(const CreatureIndex& index,
                                                                 const BorrowedPtr<Battle>& battle) {
    auto left = index.GetCreatureIndex() - 1;
    auto right = index.GetCreatureIndex() + 1;
    if (left < 0 && right >= battle->GetCreaturesPerSide()) {
        return {battle->GetCreature(index),
                battle->GetCreature(GetOppositeSide(index.GetSideIndex()), index.GetCreatureIndex())};
    }
    if (left >= 0) {
        if (right < battle->GetCreaturesPerSide()) {
            return {battle->GetCreature(index), battle->GetCreature(index.GetSideIndex(), left),
                    battle->GetCreature(index.GetSideIndex(), right),
                    battle->GetCreature(GetOppositeSide(index.GetSideIndex()), index.GetCreatureIndex())};
        }
        return {battle->GetCreature(index), battle->GetCreature(index.GetSideIndex(), left),
                battle->GetCreature(GetOppositeSide(index.GetSideIndex()), index.GetCreatureIndex())};
    }
    return {battle->GetCreature(index), battle->GetCreature(index.GetSideIndex(), right),
            battle->GetCreature(GetOppositeSide(index.GetSideIndex()), index.GetCreatureIndex())};
}

static inline List<OptionalBorrowedPtr<Creature>> GetAllAdjacentOpponent(const CreatureIndex& index,
                                                                         const BorrowedPtr<Battle>& battle) {
    auto left = index.GetCreatureIndex() - 1;
    auto right = index.GetCreatureIndex() + 1;
    if (left < 0 && right >= battle->GetCreaturesPerSide()) {
        return {battle->GetCreature(index)};
    }
    if (left >= 0) {
        if (right < battle->GetCreaturesPerSide()) {
            return {battle->GetCreature(index), battle->GetCreature(index.GetSideIndex(), left),
                    battle->GetCreature(index.GetSideIndex(), right)};
        }
        return {battle->GetCreature(index), battle->GetCreature(index.GetSideIndex(), left)};
    }
    return {battle->GetCreature(index), battle->GetCreature(index.GetSideIndex(), right)};
}

List<OptionalBorrowedPtr<Creature>> TargetResolver::ResolveTargets(const CreatureIndex& index, AttackTarget target,
                                                                   const BorrowedPtr<Battle>& battle) {
    switch (target) {
        // Single targets should just return the mon at the index.
        case AttackTarget::Adjacent:
        case AttackTarget::AdjacentAlly:
        case AttackTarget::AdjacentAllySelf:
        case AttackTarget::AdjacentOpponent:
        case AttackTarget::Any:
        case AttackTarget::RandomOpponent:
        case AttackTarget::Self: {
            return {battle->GetCreature(index)};
        }
        case AttackTarget::All: {
            return GetAll(battle);
        }
        case AttackTarget::AllAdjacent: {
            return GetAllAdjacent(index, battle);
        }
        case AttackTarget::AllAdjacentOpponent: {
            return GetAllAdjacentOpponent(index, battle);
        }
        case AttackTarget::AllAlly: {
            List<OptionalBorrowedPtr<Creature>> arr(battle->GetCreaturesPerSide());
            for (const auto& mon : battle->GetSides()[index.GetSideIndex()]->GetCreatures()) {
                arr.Append(mon);
            }
            return arr;
        }
        case AttackTarget::AllOpponent: {
            List<OptionalBorrowedPtr<Creature>> arr(battle->GetCreaturesPerSide());
            for (const auto& mon : battle->GetSides()[index.GetSideIndex()]->GetCreatures()) {
                arr.Append(mon);
            }
            return List<OptionalBorrowedPtr<Creature>>(arr);
        }
    }
    THROW("Unknown attack target kind: '" << AttackTargetHelper::ToString(target) << "'.")
}