control.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <vector>
#include "game_info.hpp"
#include "io.hpp"
 
class Controller
{
private:
    GameInfo info;                              
    std::vector<Operation> self_operations;     
    std::vector<Operation> opponent_operations; 
 
    /* Updating process after calling read_round_info() */
 
    void update_towers(std::vector<Tower>& new_towers)
    {
        info.towers = std::move(new_towers);
        info.next_tower_id = info.towers.empty() ? 0 : info.towers.back().id + 1;
    }
 
    void update_ants(const std::vector<Ant>& new_ants)
    {
        for (auto& ant : new_ants)
            update_ant(ant);
        info.next_ant_id = info.ants.empty() ? 0 : info.ants.back().id + 1;
    }
 
    void update_ant(const Ant& a)
    {
        auto it = std::find_if(info.ants.begin(), info.ants.end(), [a](const Ant &x)
                          { return x.id == a.id; });
        if (it != info.ants.end()) // not newly generated
        {
            if (!(it->x == a.x && it->y == a.y))
                it->path.push_back(get_direction(it->x, it->y, a.x, a.y));
            it->x = a.x, it->y = a.y, it->hp = a.hp, it->age = a.age, it->state = a.state;
        }
        else // newly generated
        {
            info.ants.emplace(it, a);
        }
    }
 
    void update_coins(int coin0, int coin1)
    {
        info.set_coin(0, coin0);
        info.set_coin(1, coin1);
    }
 
    void update_bases_hp(int hp0, int hp1)
    {
        info.set_base_hp(0, hp0);
        info.set_base_hp(1, hp1);
    }
 
    Controller(InitInfo init_info)
        : info(init_info.second), self_player_id(init_info.first) {}
 
public:
    const int self_player_id; 
 
    Controller(): Controller(read_init_info()) {}
 
    const GameInfo& get_info() const
    {
        return info;
    }
 
    const std::vector<Operation>& get_self_operations() const
    {
        return self_operations;
    }
 
    const std::vector<Operation>& get_opponent_operations() const
    {
        return opponent_operations;
    }
 
    void read_round_info()
    {
        // 1. Read
        auto result = ::read_round_info();
        // 2. Update
        // 1) Towers
        update_towers(result.towers);
        // 2) Ants and Pheromone
        update_ants(result.ants);
        info.global_pheromone_attenuation();
        info.update_pheromone_for_ants();
        info.clear_dead_and_succeeded_ants();
        // 3) Coins and Bases
        update_coins(result.coin0, result.coin1);
        update_bases_hp(result.hp0, result.hp1);
        // 3. Start Next Round
        // 1) update round number
        info.round = result.round;
        // 2) count down super weapons' cd
        info.count_down_super_weapons_cd();
        // 3) clear operations
        self_operations.clear();
        opponent_operations.clear();
    }
 
    void read_opponent_operations()
    {
        opponent_operations = ::read_opponent_operations();
    }
 
    void apply_opponent_operations()
    {
        // 1) count down opponent's super weapons' left-time
        info.count_down_super_weapons_left_time(!self_player_id);
        // 2) apply opponent's operations
        for (auto& op: opponent_operations)
            info.apply_operation(!self_player_id, op);
    }
 
    bool append_self_operation(OperationType type, int arg0 = -1, int arg1 = -1)
    {
        return append_self_operation(Operation(type, arg0, arg1));
    }
 
    bool append_self_operation(Operation op)
    {
        if (info.is_operation_valid(self_player_id, self_operations, op))
        {
            self_operations.push_back(op);
            return true;
        }
        return false;
    }
 
    void apply_self_operations()
    {
        // 1) count down self's long-lasting weapons' left-time
        info.count_down_super_weapons_left_time(self_player_id);
        // 2) apply self operations
        for (auto& op: self_operations)
            info.apply_operation(self_player_id, op);
    }
 
    void send_self_operations() const
    {
        send_operations(self_operations);        
    }
};