E:/Eigene Dateien/Eigene Projekte/c0re/Unit.cpp

Go to the documentation of this file.

/*
        This file is part of c0re.

        c0re is a multiplayer RTS on a hexagonal map with an evolving unit concept.
    Copyright (C) 2007 Stephan Hofmann

    c0re is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "Unit.h"

#include "system.h"
#include <GL/gl.h>
#include <GL/glu.h>
#include <fstream>

#include "myTools.h"
#include "Level.h"
#include "Player.h"
#include "EventUnblockUnit.h"
#include "EventComputeUnit.h"

int Unit::s_selectedID = -1;

Unit::Unit(Player *p_player)
{
        player = p_player;
}

Unit::~Unit()
{

}

int Unit::load(std::string p_filename)
{
        int ret = 0;

        std::string texture;

        std::ifstream fin(p_filename.c_str());
        std::string buffer;
        std::vector<std::string> values;

        isBlocked = false;
        isSettled = false;
        size = 0.5;
        bonus = 0;

        while (fin.good()) {
                std::getline(fin,buffer,'\n');
                splitLine(values, buffer, "=");
                if (values.size() == 2)
                {
                        if (values[0].find("name") != std::string::npos)
                        {
                                name = values[1];
                                if (name == "Core")
                                        isSettled = true;
                        }
                        else if (values[0].find("size") != std::string::npos)
                        {
                                size = atof(values[1].c_str()) * 0.5;
                        }
                        else if (values[0].find("move_cost") != std::string::npos)
                        {
                                move_cost = atoi(values[1].c_str());
                        }
                        else if (values[0].find("move_cool") != std::string::npos)
                        {
                                move_cooldown = (int)(atof(values[1].c_str()) / (double)Level::roundTime * 1000.0);
                        }
                        else if (values[0].find("generation_cool") != std::string::npos)
                        {
                                generate_cooldown = (int)(atof(values[1].c_str()) / (double)Level::roundTime * 1000.0);
                        }
                        else if (values[0].find("settle_cost") != std::string::npos)
                        {
                                settle_cost = atoi(values[1].c_str());
                        }
                        else if (values[0] == "absorb")
                        {
                                absorb_cost = atoi(values[1].c_str());
                        }
                        else if (values[0] == "absorb_cool")
                        {
                                absorb_cooldown = (int)(atof(values[1].c_str()) / (double)Level::roundTime * 1000.0);
                        }
                        else if (values[0] == "absorb_cool_core")
                        {
                                absorb_cooldown_core = (int)(atof(values[1].c_str()) / (double)Level::roundTime * 1000.0);
                        }
                        else if (values[0].find("settle_energy") != std::string::npos)
                        {
                                settle_energy = atoi(values[1].c_str());
                        }
                        else if (values[0].find("settle_cool") != std::string::npos)
                        {
                                settle_cooldown = (int)(atof(values[1].c_str()) / (double)Level::roundTime * 1000.0);
                        }
                        else if (values[0].find("generates") != std::string::npos)
                        {
                                generates = values[1];
                        }
                        else if (values[0].find("mutates") != std::string::npos)
                        {
                                mutates = values[1];
                        }
                        else if (values[0].find("sprite") != std::string::npos)
                        {
                                texture = values[1];
                        }
                        else if (values[0].find("settleSprite") != std::string::npos)
                        {
                                settleSprite = values[1];
                        }
                        else if (values[0].find("moving_combatvalue") != std::string::npos)
                        {
                                movingCombatValue = atoi(values[1].c_str());
                        }
                        else if (values[0].find("moving_combatbonus") != std::string::npos)
                        {
                                movingCombatBonus = atoi(values[1].c_str());
                        }
                        else if (values[0].find("moving_combatrandom") != std::string::npos)
                        {
                                movingCombatRandom = atoi(values[1].c_str());
                        }
                        else if (values[0].find("settled_combatvalue") != std::string::npos)
                        {
                                settledCombatValue = atoi(values[1].c_str());
                        }
                        else if (values[0].find("settled_combatbonus") != std::string::npos)
                        {
                                settledCombatBonus = atoi(values[1].c_str());
                        }
                        else if (values[0].find("settled_combatrandom") != std::string::npos)
                        {
                                settledCombatRandom = atoi(values[1].c_str());
                        }
                }
        }
        fin.close();

        spawnDestination = -1;

        loadAndBind("textures//" + player->color + "//" + texture, TM_Masked_Blue_To_Red);

        return ret;
}

int Unit::settle(Level* p_level)
{
        int ret = 0;

        //check if player has enough energy
        if (player->energy >= settle_cost && !isSettled)
        {
                player->energy -= settle_cost; // pay for it
                loadAndBind("textures//" + player->color + "//" + settleSprite, TM_Masked_Blue_To_Red);
                isSettled = true;
                size = 0.5;
                isBlocked = true;
                p_level->eventList[settle_cooldown].push_back(new EventUnblockUnit(this));
        }
        else //no settle
        {
                ret = 1;
        }


        return ret;
}

int Unit::compute(Field* p_field, Level *p_level)
{
        int ret = 0;

        if (generates != "#") //unit only generates no energy is delivered
        {
                //now look if energy is needed for generation
                if (settle_energy > 0)
                {
                        //yes energy is needed
                        if (p_field->energy > 0)
                        {
                                //yes energy is there
                                if (generate(p_field, p_level) == 1) //we generated something
                                {       //now pay for it
                                        leechEnergy(p_field, p_level); //drop the energy
                                }
                        }
                }
                else //no energy needed
                {
                        generate(p_field, p_level);
                }
        }
        else if (isSettled && !isBlocked)//no generation -> energy for the pool
        {
                //first enter cooldown, so no problem with mutating
                isBlocked = true;
                p_level->eventList[settle_cooldown].push_back(new EventUnblockUnit(this));

                player->energy += leechEnergy(p_field, p_level);

                if (isSettled) //still settled?
                        p_level->eventList[settle_cooldown].push_back(new EventComputeUnit(p_field));

        }

        return ret;
}

int Unit::generate(Field* p_field, Level *p_level)
{
        int ret = 0;
        
        if (isSettled && !isBlocked && (spawnDestination > -1))
        {
                if (spawnDestinationField->unit == 0)
                {
                        spawnDestinationField->unit = new Unit(player);
                        spawnDestinationField->unit->load("units//" + generates);
                        isBlocked = true;
                        p_level->eventList[generate_cooldown].push_back(new EventUnblockUnit(this));
                        p_level->eventList[generate_cooldown].push_back(new EventComputeUnit(p_field));
                        ret = 1;
                }
                else //we have to check next round, maybe the unit has been moved away
                        p_level->eventList[1].push_back(new EventComputeUnit(p_field));

        }

        return ret;
}

int Unit::mutate(Level *p_level)
{
        int ret = 0;

        if (isSettled)
        {
                load("units//" + mutates);
                p_level->bindings["+RMOUSE"] = "!STANDARDACTION";
                p_level->bindings["+S"] = "!SETTLE";
                p_level->bindings["BUTTONSETTLE"] = "!SETTLE";
        }

        return ret;
}

int Unit::leechEnergy(Field* p_field, Level *p_level)
{
        int ret = 0;

        if (p_field->energy > 0)
        {
                if (p_field->energy >= settle_energy)
                        p_field->energy -= settle_energy;
                else 
                        p_field->energy = 0;

                ret = settle_energy;

                p_field->select(p_field->textureName);
                if (p_field->energy == 0)
                {
                        mutate(p_level);
                }
        }

        return ret;
}

int Unit::render(Vector3d p_pos, Level* p_level, double p_deltasize)
{
        int ret = 0;
        
        glPushMatrix();

        //this is needed as the tile is only using 0.87 of the y-size of the square
        glTranslated(p_pos.x, p_pos.y + 0.065, p_pos.z);
        
        //is there a spwanDestination?
        if (spawnDestination >= 0)
        {
                glPushMatrix();
                glLineWidth(3.0);
                //so we paint a pointer towards it

                glRotated(60.0 * (double) spawnDestination, 0.0, 0.0, 1.0);
                glScaled(p_deltasize, p_deltasize, p_deltasize);
                double cd = ((1) / generate_cooldown);
                if (cd > 1.0)
                        cd = 1.0;
                glBegin(GL_LINES);
                        glColor3d (1.0, 1.0, 1.0);
                        glVertex3d(0.0, 0.0, 0.0);
                        glVertex3d(0.0, 0.2, 0.0);
                        glVertex3d(0.0, 0.2, 0.0);
                        glColor3d (1.0, cd, cd); 
                        glVertex3d(0.0, 0.4, 0.0);
                        glVertex3d(0.0, 0.4, 0.0);
                        glVertex3d(0.1, 0.3, 0.0);
                        glVertex3d(0.0, 0.4, 0.0);
                        glVertex3d(-0.1, 0.3, 0.0);
                glEnd();
                glLineWidth(1.0);
                glPopMatrix();
        }

        Object::render(Vector3d(0.0, 0.0, 0.0), p_deltasize);

        double x = 0.125;
        double y = 4*x - x;

        //if selected -> paint a box around it
        if (s_selectedID == id)
        {
                glPushMatrix();
                glScaled(p_deltasize, p_deltasize, p_deltasize);
                //if (p_round > lastMove + (long)move_cooldown)
                if (!isBlocked)
                        glColor3d (0.5, 1.0, 0.75);
                else
                        glColor3d (1.0, 0.5, 0.75);
                glLineWidth(2.0);
                glBegin(GL_LINE_LOOP);
                        glVertex3d(x, y, 0.0);
                        glVertex3d(y, x, 0.0);
                        glVertex3d(y, -x, 0.0);
                        glVertex3d(x, -y, 0.0);
                        glVertex3d(-x, -y, 0.0);
                        glVertex3d(-y, -x, 0.0);
                        glVertex3d(-y, x, 0.0);
                        glVertex3d(-x, y, 0.0);
                glEnd();
                glLineWidth(1.0);
                glPopMatrix();
        }
        
        //write the Bonus if available
        if (((movingCombatBonus != 0) && (!isSettled)) || ((settledCombatBonus != 0) && (isSettled)))
        {
                glColor4d(0.8, 0.8, 0.8, 1.0);
                p_level->glPrint2d(0.0, 0.0, "%i", bonus);
        }

        glPopMatrix(); //translation

        return ret;
}

int Unit::getCombatValue(double p_rand)
{
        int ret = 0;

        if (isSettled)
        {
                ret += settledCombatValue;
                ret += settledCombatBonus * bonus; // selected bonus
                if (settledCombatRandom > 0)
                        ret += (int)((double)settledCombatRandom * p_rand + 1.0);
        }
        else
        {
                ret += movingCombatValue;
                ret += movingCombatBonus * bonus; // selected bonus
                if (movingCombatRandom > 0)
                        ret += (int)((double)movingCombatRandom * p_rand + 1.0);
        }

        //afterwards the bonus is cleared
        bonus = 0;

        return ret;
}

---