treewars/gamedata.cpp

#include "gamedata.h"
#include "mathutils.h"
#include "debug.h"
#include <list>
#include <algorithm>
#include <cassert>

using std::list;

int GameData::PLAYER1_COLOUR = 0x4a483f;
int GameData::PLAYER2_COLOUR = 0x090c7a;

int GameData::BASE_BUILD_RADIUS = 75;
int GameData::NODE_RADIUS = 10;

GameData::GameData()
    : Graph(true)
{
    current = NULL;
    mode = MODE_BUILD;
    player1 = Player(PLAYER1_COLOUR);
    player2 = Player(PLAYER2_COLOUR);
    turn = &player1;
}

GameData::~GameData() { }


Vertex* GameData::get_current_vertex(bool only_mine) const
{
    if (only_mine)
    {
	if (current != NULL && 
	    current->colour == turn->get_colour()) return current;
	
	return NULL;
    }
    
    return current;
}


void GameData::toggle_turn()
{
    if (!turn->has_played())
    {
	set_mode(MODE_BUILD);
	turn->set_played();
    }
    else set_mode(MODE_SELECT);

    if (!endgame())
    {
	if (turn == &player1) turn = &player2;
	else if (turn == &player2) turn = &player1;

    }
}


void GameData::handle_click(int x, int y)
{
    int r = 10;

    int colour;
    colour = turn->get_colour();

    if (mode == MODE_SELECT)
    {
	if (point_in_vertex(x, y, 0)) select_vertex(x, y);
    }
    else if (mode == MODE_BUILD)
    {
	if (point_in_vertex(x, y, 0)) select_vertex(x, y, true);
	else add_vertex(x, y, 0, r, colour);
    }
    else if (mode == MODE_ATTACK)
    {
	if (select_vertex(x, y, true)) return;
	Vertex* v = vertex_at(x, y, 0);
	if (v == NULL) return;
	if (v->colour != colour) attack_vertex(v);
    }
}


bool GameData::select_vertex(int x, int y, bool only_mine)
{
    Vertex * v = vertex_at(x, y, 0);
    if (v == NULL) return false;

    if (only_mine && v->colour == turn->get_colour())
    {
	current = v;
	return true;
    }
    
    current = v;
    return true;
}


bool GameData::add_vertex(int x, int y, int z, int r, int colour)
{
    if (current == NULL)
    {
	// this is the special case for adding the first vertex for each player
	if (!turn->has_played())
	{
	    Graph::add_vertex(x, y, z, r, colour, 10);
#ifdef DEBUG
	    fprintf(stderr, "debug: GameData::add_vertex(): strength=%2.f\n",
		    calculate_strength(*(vertices.rbegin())));
#endif
	    toggle_turn();
	    return true;
	}
	return false;
    }

    if (current->colour != turn->get_colour()) return false;

    if (Graph::add_vertex(x, y, z, r, colour, 10, current))
    {
#ifdef DEBUG
	fprintf(stderr, "debug: GameData::add_vertex(): strength=%.2f\n",
		calculate_strength(*(vertices.rbegin())));
#endif

	toggle_turn();
	return true;
    }
    return false;
}


float GameData::calculate_strength(Vertex* node)
{
    list<Vertex*> visited;

    // Special case - a one-node tree just returns its own score!
    if (node->neighbors.empty()) return (float)node->score;

    return calculate_strength_r(node, 0, visited);
}


// Oh the recursive recursion!
float GameData::calculate_strength_r(Vertex* node, unsigned int depth, list<Vertex*>& visited)
{
    // Find which vertices we need to visit from here
    list<Vertex*> neighbors = node->neighbors;
    list<Vertex*> to_visit;

    visited.push_back(node);

    for (list<Vertex*>::iterator cursor = neighbors.begin();
	 cursor != neighbors.end(); cursor++)
    {
	Vertex* v = *cursor;
	// if this is true, we haven't visited the vertex on the other end of
	// this edge yet
	if (find(visited.begin(), visited.end(), v) == visited.end())
	{
	    to_visit.push_back(v);
	}
    }

    // This is the base case - this node has no unvisited neighbors
    if (to_visit.empty())
    {
	assert(depth > 0);
	return (float)(node->score) / depth;
    }

    // Else, iterate through to_visit and visit them all, summing their
    // effective strengths adjusted for depth.
    // Since our trees are acyclic, this can't loop.
    float modscore = (float)node->score;
    if (depth > 0) modscore /= depth;

    for (list<Vertex*>::iterator cursor = to_visit.begin();
	 cursor != to_visit.end(); cursor++)
    {
	Vertex* v = *cursor;
	modscore += calculate_strength_r(v, depth+1, visited);
    }

    return modscore;
}


Mode GameData::set_mode(Mode m)
{
    mode = m;
}


int GameData::get_range(Vertex* node)
{
    if (node == NULL) node = current;

    if (node == NULL) return 0;
    else if (mode == MODE_MOVE) return turn->get_energy();
    else if (mode == MODE_BUILD) return BASE_BUILD_RADIUS;
    else if (mode == MODE_ATTACK)
    {
	int range = BASE_BUILD_RADIUS;
	list<Vertex*> neighbors = node->neighbors;

	for(list<Vertex*>::iterator cursor = neighbors.begin();
	    cursor != neighbors.end(); cursor++)
	{
	    Vertex* v = *cursor;
	    range -= (100 - MathUtils::distance(v->x, v->y, v->z,
						node->x, node->y, node->z))
		/ 2;
	}
	if (range < 0) range = 0;
	return range;
    }
}


void GameData::attack_vertex(Vertex* target)
{
    float atk_str = calculate_strength(current);
    float def_str = calculate_strength(target);
    float armor = def_str / 10; // how much energy it takes to deal 1 damage

    int damage = (int)(atk_str / armor);

    target->score -= damage;

    if (target->score <= 0) remove_vertex(target);

#ifdef DEBUG
    fprintf(stderr, "debug: GameData::attack_vertex(): atk_str=%.2f, def_str=%.2f, armor=%.2f, damage=%d\n", atk_str, def_str, armor, damage);
#endif

    toggle_turn();
}


bool GameData::endgame()
{
    if (!(player1.has_played() && player2.has_played())) return false;

    if (get_colour(player1.get_colour()).empty())
    {
	debug("Gamedata::endgame(): player 2 wins\n");
	return true;
    }
    if (get_colour(player2.get_colour()).empty())
    {
	debug("Gamedata::endgame(): player 1 wins\n");
	return true;
    }

    return false;
}