source: code/branches/wagnis_HS18/src/modules/wagnis/WagnisPlayer.cc @ 12114

#include "WagnisPlayer.h"
#include <vector>
#include <string>

namespace orxonox
{
    RegisterClass(WagnisPlayer);

    //Constructor
    WagnisPlayer::WagnisPlayer(Context* context) : HumanPlayer(context){
        RegisterObject(WagnisPlayer);
        this->gameBoard = nullptr;
        this->is_active = false;
        this->origin_province = nullptr;
        this->target_province = nullptr;
        this->province_selection_changed = false;
    }
    //Destructor
    WagnisPlayer::~WagnisPlayer(){

    }
    //Tick
    void WagnisPlayer::tick(float dt){
        SUPER(WagnisPlayer, tick, dt);

        if(this->is_active){
            for(WagnisProvince* prov:this->gameBoard->provs){
                if(prov->getHealth() < prov->getMaxHealth()){
                    if(prov->getHealth() <= prov->getMaxHealth()-1000.0f){
                        this->target_province = prov;
                        this->province_selection_changed = true;
                    }else{
                        this->origin_province = prov;
                        this->province_selection_changed = true;
                    }
                }
            }

            if(this->province_selection_changed && this->origin_province != nullptr && this->target_province != nullptr){
                this->province_selection_changed = false;
                switch(gamestage){
                    case CHOOSE_PROVINCE_STAGE: 
                    {   
                        break;
                    }
                    case REINFORCEMENT_STAGE:
                    {
                        break;
                    }
                    case ATTACK_STAGE:{
                        break;
                    }
                    case MOVE_STAGE:{
                        break;
                    }
                }
            }
        }
    }



    //Manages a Players turn
    void WagnisPlayer::playerTurn(){
        
    }
    //checks if a move is valid, possible MoveTypes: ATTACK, MOVE, SET_TROOPS, SET_TROOPS_INITIAL
    bool WagnisPlayer::checkMove(WagnisProvince*,WagnisProvince*,MoveType move_type)
    {
        if (move_type == ATTACK)
        {
            if (isNeighbour(this->origin_province, this->target_province))//TODO: provinces neighbours
            {
                if (this->origin_province->getOwner_ID() == this->Player_ID) //origin belongs to player
                {
                    if (this->target_province->getOwner_ID() != this->Player_ID)//target belongs to enemy
                        return true;
                }
            }
        }

        if (move_type == MOVE)
        {
            if (existPath(this->origin_province, this->target_province))//TODO: path exists, all belong to same player
            {
                if (this->origin_province->getOwner_ID() == this->Player_ID)//origin belongs to player
                    return true;
            }

        }

        if (move_type == SET_TROOPS)
        {
            if (this->target_province->getOwner_ID() == this->Player_ID)//target belongs to player
                return true;
        }

        if (move_type == SET_TROOPS_INITIAL)
        {
            if (this->target_province->getOwner_ID() == 0)//target belongs to nobody
                return true;
        }
        
        return false;
    }
    
    //
    void WagnisPlayer::setTroops(WagnisProvince*){

    }
    void WagnisPlayer::attack(WagnisProvince*,WagnisProvince*){

    }
    void WagnisPlayer::moveTroops(WagnisProvince*,WagnisProvince*){

    }
    //Return a "Player x" String
    std::string WagnisPlayer::toString(){
        std::string str = "Player ";
        str.append(std::to_string(Player_ID));
        return str;
    }

    //private function for CheckMove
    //checks if provinces are neighbours for move
    bool WagnisPlayer::isNeighbour(WagnisProvince*,WagnisProvince*)
    {
        for (unsigned int i = 0; i < this->origin_province->neighbors.size(); ++i)
        {
            if (this->target_province == this->origin_province->neighbors[i])
                return true;
        }

        return false;
    }

    //private function for CheckMove
    //checks if path is complete with provinces owned by player
    bool WagnisPlayer::existPath(WagnisProvince*,WagnisProvince*)
    {
        if (this->origin_province->getOwner_ID() == this->target_province->getOwner_ID() && isNeighbour(this->origin_province, this->target_province))
            return true;
        
        for (unsigned int i = 0; i < this->origin_province->neighbors.size(); ++i)
        {
            if (this->origin_province->getOwner_ID() == this->origin_province->neighbors[i]->getOwner_ID())
                return existPath(this->origin_province->neighbors[i], this->target_province);
        }
            
        return false;
    }
}