E:/Eigene Dateien/Eigene Projekte/c0re/FunctionHandler.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 "FunctionHandler.h"

#include <assert.h>

#include "Level.h"
#include "Window.h"
#include "Player.h"
#include "Button.h"
#include "DAEffect.h"
#include "EventAnimation.h"
#include "EventComputeUnit.h"
#include "EventDeleteEffect.h"
#include "EventDeleteUnit.h"
#include "EventUnblockUnit.h"

FunctionHandler::FunctionHandler()
{
}   
   
FunctionHandler::~FunctionHandler()
{
   
}   
 

std::string FunctionHandler::quit(std::vector<std::string>& p_params, Level* level)
{
        
        return "";
}

std::string FunctionHandler::zoomIn(std::vector<std::string>& p_params, Level* level)
{
        double z = ((level->position.z -3.5) / 1.3 ) + 3.5;
        if (z < 4.0)
                z = 4.0;
        level->position.z = z;
        return "";
}
 
std::string FunctionHandler::zoomOut(std::vector<std::string>& p_params, Level* level)
{
        double z =  ((level->position.z -3.5) * 1.3 ) + 3.5;
        if (z > 40.0)
                z = 40.0;
        level->position.z = z;  
        return "";
}

std::string FunctionHandler::scrollUp(std::vector<std::string>& p_params, Level* level)
{
        level->position.y -= 0.1;
        return "";
}
 
std::string FunctionHandler::scrollDown(std::vector<std::string>& p_params, Level* level)
{
        level->position.y += 0.1;
        return "";
}
 
std::string FunctionHandler::scrollLeft(std::vector<std::string>& p_params, Level* level)
{
        level->position.x -= 0.1;       
        return "";
}
 
std::string FunctionHandler::scrollRight(std::vector<std::string>& p_params, Level* level)
{
        level->position.x += 0.1;
        return "";
}

std::string FunctionHandler::select(std::vector<std::string>& p_params, Level* level)
{
        int id = level->pick();
        if (id > 0)
        {
                Texture* texture = Texture::get(id);
                if (texture == 0)
                        return "";

                Button *btn = texture->getButton();
                if (btn != 0)
                {
                        if (btn->label.find("BUTTONBONUS") != std::string::npos)
                                return FunctionHandler::selectBonus(p_params, level);
                        else
                                level->inputMessages.push_back(btn->label);
                        return "";
                }

                //clean cast
                Field * field = texture->getField();
                if (field == 0)
                        return "";
                //save the origin
                Field::s_selectedFieldID = field->id;

                //select the child object
                if (field->unit != 0)
                {
                        //now bind new functions
                        if (!field->unit->isSettled) //functions for not settled units
                        {
                                level->bindings["+RMOUSE"] = "!STANDARDACTION";
                                level->bindings["+S"] = "!SETTLE"; 
                                level->bindings["BUTTONSETTLE"] = "!SETTLE";
                        }
                        else //functions for settled units
                        {
                                level->bindings.erase("+RMOUSE");
                                level->bindings["+T"] = "!TERMINATE";
                                if (field->unit->generates != "#")
                                        level->bindings["+RMOUSE"] = "!SETSPAWNDESTINATION";
                                
                        }
                        Unit::s_selectedID = field->unit->id;
                }
                else 
                {
                        //no unit selected -> rebind scrolling
                        level->bindings["+RMOUSE"] = "!GRABSCREEN";
                        level->bindings["-RMOUSE"] = "!RELEASESCREEN";
                        level->bindings.erase("+S");
                        level->bindings.erase("BUTTONSETTLE");
                        Unit::s_selectedID = -1;
                }
        }
        
        return "";
}

std::string FunctionHandler::grabScreen(std::vector<std::string>& p_params, Level* level)
{
        //at first save mouse coordinates
        level->mousePos = level->window->mousePos;
        //now we will scroll the window eah time
        level->currentCommands.push_back("SCROLLSCREEN");
        //o left mousbutton actios!
        level->bindings.erase("+LMOUSE");
        return "";
}

std::string FunctionHandler::releaseScreen(std::vector<std::string>& p_params, Level* level)
{
        level->currentCommands.remove("SCROLLSCREEN");
        //add left mouse button actions
        level->bindings["+LMOUSE"] = "!SELECT";
        return "";
}

std::string FunctionHandler::scroll(std::vector<std::string>& p_params, Level* level)
{
        Vector3i d_mouse = level->mousePos - level->window->mousePos;
        Vector3d d_move;
        d_move.x = d_mouse.x / (double) level->window->width;
        d_move.y = (-1) * (d_mouse.y / (double) level->window->height);
        d_move *= (level->position.z);
        level->position += d_move;

        level->mousePos = level->window->mousePos;
        return "";
}

std::string FunctionHandler::standardAction(std::vector<std::string>& p_params, Level* level)
{
        //have we picked soething?
        int id = level->pick();
        if (id <= 0)
                return ""; //no

        //get the destination
        Texture* texture = Texture::get(id);
        if (texture == 0)
                return "";

        //clean cast
        Field * destination = texture->getField();
        if (destination == 0)
                return "";

        //get the origin field
        texture = Texture::get(Field::s_selectedFieldID);
        //clean cast
        Field* origin = texture->getField();
        if(origin->unit == 0)                   //this function may only be called if an unit has been selected
                return "";                                      //but when so unit has lost.... there is nothing to do :D

        if (origin->unit->isBlocked)            //do nothing if we are in any cooldown
                return "";
        
        //now test which standard action
        if (Field::s_selectedFieldID == destination->id) //same field we are on -> settle
                return FunctionHandler::settle(p_params, level);

        //now check if on the destination field a unit is on
        if (destination->unit == 0) //no it is not -> check for moving
        {
                //check if it is in range
                if  (isConnected(origin, destination) == -1)
                        return ""; //not connected

                //check if there is enough energy to pay
                if (origin->unit->player->energy < origin->unit->move_cost)
                        return "";

                //we proceed, move the object
                origin->unit->player->energy -= origin->unit->move_cost; //pay for it
                destination->unit = origin->unit;
                origin->unit = 0;
                Field::s_selectedFieldID = destination->id;
                destination->unit->isBlocked = true;
                level->eventList[destination->unit->move_cooldown].push_back(new EventUnblockUnit(destination->unit));

        }
        else //there is another unit
        {
                //so we check if it is an oponents unit
                if (origin->unit->player == destination->unit->player) //same player?
                        return ""; //then we can do nothing

                if (origin->unit->player->energy < origin->unit->absorb_cost)
                        return ""; //not enough energy for DA

                //check for distance
                int xDif = destination->xCoord - origin->xCoord;
                int yDif = destination->yCoord - origin->yCoord;
                if (! ( ((abs(xDif) == 0) && (abs(yDif) <= 2))
                                ||      ((abs(xDif) <= 2) && (abs(yDif) <= 1))
                                ||      ((abs(xDif) == 1) && (origin->xCoord % 2 == 0) && (yDif == -2))
                                ||      ((abs(xDif) == 1) && (origin->xCoord % 2 == 1) && (yDif == 2)) ))
                {
                        return ""; //out of range
                }


                /************ attack ************/
                //pay for DA
                origin->unit->player->energy -= origin->unit->absorb_cost;

                //compute
                int ori_combatvalue = origin->unit->getCombatValue(rand() / (double)RAND_MAX); //combat value of attacker
                int des_combatvalue = destination->unit->getCombatValue(rand() / (double)RAND_MAX); //combatvalue of attacked
                Field* loosing = 0;

                //now the difference if we fight against a core or not core-combat_value = 99!
                if (des_combatvalue == 99)
                {       
                        //we assume that we cannot be attacked by a core
                        if (ori_combatvalue != 99)
                        {
                                destination->unit->player->energy -= ori_combatvalue;
                                origin->unit->isBlocked = true;
                                level->eventList[origin->unit->absorb_cooldown_core].push_back(new EventUnblockUnit(origin->unit));
                                if (destination->unit->player->energy < 0)
                                        loosing = destination; //delete the core if the player is dead
                        }
                }
                else //not a core
                {
                        if (ori_combatvalue == des_combatvalue) //no patt :)
                                des_combatvalue += ((int)((rand()/(double)RAND_MAX) + 0.5) * 2) - 1;  //50% chance if equal for both
                        if (des_combatvalue < ori_combatvalue)
                        {       //attacker wins
                                loosing = destination;
                                origin->unit->isBlocked = true;
                                level->eventList[origin->unit->absorb_cooldown].push_back(new EventUnblockUnit(origin->unit));
                        }
                        else
                                loosing = origin;
                }

                DAEffect *dae = new DAEffect(Vector3i(origin->xCoord, origin->yCoord, 0), Vector3i(destination->xCoord, destination->yCoord, 0), ori_combatvalue, des_combatvalue, level);
                dae->loadAndBind("textures//dae-seq.png");
                dae->sequenceCount = 4;
                level->effects.push_back(dae);
                //now we will call this event 16 times, but only all 4 rounds
                for (int i = 0; i < 16; i++)
                        level->eventList[4*i + 1].push_back(new EventAnimation(dae, 1));
                //and finally we will delete the effect
                level->eventList[65].push_back(new EventDeleteEffect(dae));
                //and also we will delete the unit
                if (loosing != 0)
                {
                        level->eventList[65].push_back(new EventDeleteUnit(loosing));
                        loosing->unit->isBlocked = true;
                }
                /************ end attack ************/
        }

        return "";
}

std::string FunctionHandler::settle(std::vector<std::string>& p_params, Level* level)
{
        //get the origin field
        Texture *texture = Texture::get(Field::s_selectedFieldID);
        //clean cast
        Field* origin = texture->getField();

        assert(origin->unit != 0);

        if (origin->unit->isBlocked)
                return "";

        if (origin->energy == 0)
                return "";

        if (origin->isSettleRange)
                return "";

        //settle
        if (origin->unit->settle(level) == 0) //sucessful settled
        {
                level->bindings.erase("+S");
                level->bindings.erase("+RMOUSE");
                if (origin->unit->generates != "#")
                        level->bindings["+RMOUSE"] = "!SETSPAWNDESTINATION";
                level->eventList[origin->unit->settle_cooldown].push_back(new EventComputeUnit(origin));
        }

        return "";
}

std::string FunctionHandler::terminate(std::vector<std::string>& p_params, Level* level)
{
        //get the origin field
        Texture *texture = Texture::get(Field::s_selectedFieldID);
        //clean cast
        Field* origin = texture->getField();
                        
        bool doIt = false;
        
        doIt = true;

        if (origin->unit->mutates == "#")
                doIt = false;

        if (doIt)
        {//settle
                origin->unit->mutate(level);
                level->bindings["+RMOUSE"] = "!STANDARDACTION";
                level->bindings["+S"] = "!SETTLE";
        }

        return "";
}

std::string FunctionHandler::setSpawnDestination(std::vector<std::string>& p_params, Level* level)
{
        //get the origin field
        Texture *texture = Texture::get(Field::s_selectedFieldID);
        //clean cast
        Field* origin = texture->getField();
        //and get the settled unit
        Unit* unit = origin->unit;
        
        //now get the field that has been choosen;
        int id = level->pick();
        //nothing picked
        if (id <= 0)
                return "";

        texture = Texture::get(id);
        if (texture == 0)
        { //nothing selected -> delete spwan point
                unit->s_selectedID = -1;
                return "";
        }

        //clean cast
        Field * destination = texture->getField();
        if (destination == 0)
        { //nothing selected -> delete spwan point
                unit->s_selectedID = -1;
                return "";
        }

        //now check if they are connected
        int spawnDirection = isConnected(origin, destination);
        if (spawnDirection == -1) //not connected
        {
                //but maybe we can attack it? if we are a core :D
                if (origin->unit->settledCombatValue == 99)
                        return FunctionHandler::standardAction(p_params, level);
        }

        //check if there is a unit
        if (destination->unit != 0)
        {
                if (destination->unit->isSettled)       //we cannot spawn if there is something settled
                {
                        unit->spawnDestination = -1;
                        return "";

                }
                //is it an enemy unit?
                if (destination->unit->player != unit->player)
                {
                        //so we can attack it, if we are a core :D
                        if (origin->unit->settledCombatValue == 99)
                                return FunctionHandler::standardAction(p_params, level);
                } //if it is a friedly unit we can set the spawnpoint
        }
        
        //so we can set the spawpoint
        unit->spawnDestination = spawnDirection;
        unit->spawnDestinationField = destination; // this must only be used if spawnDirection > -1
        level->eventList[1].push_back(new EventComputeUnit(origin)); //next round we compute the unit

        return "";
}

std::string FunctionHandler::selectBonus(std::vector<std::string>& p_params, Level* level)
{
        //get the origin field
        Texture *texture = Texture::get(Field::s_selectedFieldID);
        // if == 0 nothing slected till now
        if (texture == 0)
                return ""; //nothing to do
        //clean cast
        Field* origin = texture->getField();
        //and get the settled unit
        Unit* unit = origin->unit;
        assert(unit != 0);

        //now get the field that has been choosen;
        int id = level->pick();
        //nothing picked
        if (id <= 0)
                return "";
        texture = Texture::get(id);
        if (texture == 0)
                return ""; //nothing selected
        Button *btn = texture->getButton();
        if (btn == 0)
                return ""; //it's not a button
        if (btn->val == -1)
                return ""; // not a bonus button
        if (unit->player->energy < btn->val)
                return ""; //not enough energy
        if (unit->bonus == btn->val)
                return ""; //no change
        if (((unit->movingCombatBonus == 0) && (!unit->isSettled)) || ((unit->settledCombatBonus == 0) && (unit->isSettled)))
                return ""; //no bonus available
        unit->bonus = btn->val;
        unit->player->energy -= btn->val;
        
        return "";
}

int FunctionHandler::isConnected(Field* origin, Field* destination)
{
        int ret = -1;

        int xDif = destination->xCoord - origin->xCoord;
        int yDif = destination->yCoord - origin->yCoord;
        if ((xDif == 0) && (abs(yDif) == 1))
        {
                if (yDif == 1)
                        ret = 0;
                else
                        ret = 3;
        }
        if((origin->xCoord % 2) == 0) //if x is even
        {
                if ((abs(xDif) == 1) && ((yDif == 0) || (yDif == -1)))
                {
                        if (yDif == 0) //upper field
                        {
                                if (xDif == -1)
                                        ret = 1;
                                else
                                        ret = 5;
                        }
                        else // lower field
                                                        {
                                if (xDif == -1)
                                        ret = 2;
                                else
                                        ret = 4;
                        }
                }
        }
        else    //x is odd
        {
                if ((abs(xDif) == 1) && ((yDif == 0) || (yDif == 1)))
                {
                        if (yDif == 1) //upper field
                        {
                                if (xDif == -1)
                                        ret = 1;
                                else
                                        ret = 5;
                        }
                        else // lower field
                                                        {
                                if (xDif == -1)
                                        ret = 2;
                                else
                                        ret = 4;
                        }
                }
        }
        
        return ret;
}

---