simulate.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "game_info.hpp"
#include "control.hpp"
 
enum GameState
{
    Player0Win, 
    Player1Win, 
    Running,    
    Undecided   
};
 
class Simulator
{
private:
    GameInfo info;                          
    std::vector<Operation> operations[2];   
 
    /* Round settlement process */
 
    void attack_ants()
    {
        /* Lightning Storm Attack */
 
        for (SuperWeapon& sw: info.super_weapons)
        {
            if(sw.type != SuperWeaponType::LightningStorm)
                continue;
            for (Ant &ant : info.ants)
            {
                if (sw.is_in_range(ant.x, ant.y) 
                    && ant.player != sw.player)
                {
                    ant.hp = 0;
                    ant.state = AntState::Fail;
                    info.update_coin(sw.player, ant.reward());
                }
            }
        }
        
        /* Tower Attack */
        
        // Set deflector property
        for (Ant& ant: info.ants)
            ant.deflector = info.is_shielded_by_deflector(ant);
        // Attack
        for (Tower& tower: info.towers)
        {
            // Skip if shielded by EMP
            if (info.is_shielded_by_emp(tower))
                continue;
            // Try to attack
            auto targets = tower.attack(info.ants);
            // Get coins if tower killed the target
            for (int idx: targets)
            {
                if (info.ants[idx].state == AntState::Fail)
                    info.update_coin(tower.player, info.ants[idx].reward());
            }
            // Reset tower's damage (clear buff effect)
            tower.damage = TOWER_INFO[tower.type].attack;
        }
        // Reset deflector property
        for (Ant& ant: info.ants)
            ant.deflector = false;
    }
 
    GameState move_ants()
    {
        for (Ant& ant: info.ants)
        {
            // Update age regardless of the state
            ant.age++;
            // 1) No other action for dead ants
            if (ant.state == AntState::Fail)
                continue;
            // 2) Check if too old
            if (ant.age > Ant::AGE_LIMIT)
                ant.state = AntState::TooOld;
            // 3) Move if possible (alive)
            if (ant.state == AntState::Alive)
                ant.move(info.next_move(ant));
            // 4) Check if success (Mark success even if it reaches the age limit)
            if (ant.x == Base::POSITION[!ant.player][0] && ant.y == Base::POSITION[!ant.player][1])
            {
                ant.state = AntState::Success;
                info.update_base_hp(!ant.player, -1);
                info.update_coin(ant.player, 5);
                // If hp of one side's base reaches 0, game over 
                if (info.bases[!ant.player].hp <= 0)
                    return (ant.player == 0) ? GameState::Player0Win : GameState::Player1Win;
            }
            // 5) Unfreeze if frozen
            if (ant.state == AntState::Frozen)
                ant.state = AntState::Alive;
        }
        return GameState::Running;
    }
 
    void generate_ants()
    {
        for (auto& base: info.bases)
        {
            auto ant = base.generate_ant(info.next_ant_id, info.round);
            if (ant)
            {
                info.ants.push_back(std::move(ant.value()));
                info.next_ant_id++;
            }
        }
    }
 
    void get_basic_income(int player_id)
    {
        info.update_coin(player_id, BASIC_INCOME);
    }
 
    /* Game judger */
 
    GameState judge_winner() const
    {
        if (info.bases[0].hp < info.bases[1].hp)
            return GameState::Player1Win;
        else if (info.bases[0].hp > info.bases[1].hp)
            return GameState::Player0Win;
        else
            return GameState::Undecided;
    }
 
public:
    Simulator(const GameInfo& info) : info(info) {}
 
    const GameInfo& get_info()
    {
        return info;
    }
 
    const std::vector<Operation>& get_operations_of_player(int player_id) const
    {
        return operations[player_id];
    }
 
    bool add_operation_of_player(int player_id, Operation op)
    {
        if (info.is_operation_valid(player_id, operations[player_id], op))
        {
            operations[player_id].push_back(op);
            return true;
        }
        return false;
    }
 
    void apply_operations_of_player(int player_id)
    {
        // 1) count down long-lasting weapons' left-time
        info.count_down_super_weapons_left_time(player_id);
        // 2) apply opponent's operations
        for (auto& op: operations[player_id])
            info.apply_operation(player_id, op);
    }
 
    GameState next_round()
    {
        // 1) Judge winner at MAX_ROUND
        if (info.round == MAX_ROUND)
            return judge_winner();
        // 2) Towers attack ants
        attack_ants();
        // 3) Ants move
        GameState state = move_ants();
        if (state != GameState::Running)
            return state;
        // 4) Update pheromone
        info.global_pheromone_attenuation();
        info.update_pheromone_for_ants();
        // 5) Clear dead and succeeded ants
        info.clear_dead_and_succeeded_ants();
        // 6) Barracks generate new ants
        generate_ants();
        // 7) Get basic income
        get_basic_income(0);
        get_basic_income(1);
        // 8) Start next round
        info.round++;
        // 9) Count down super weapons' cd
        info.count_down_super_weapons_cd();
        // 10) Clear operations
        operations[0].clear();
        operations[1].clear();
 
        return GameState::Running;
    }
};