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

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

#include "myTools.h"
#include "Window.h"
#include "Player.h"
#include "Interface.h"
#include "DAEffect.h"
#include "EventInterface.h"

const unsigned int Level::roundTime = 20;
const int Level::interfaceSizeWidth = 500;
const int Level::interfaceSizeHeight = 150;

Level::Level(Window *p_window) : GLInterface(p_window), eventList(10000)
{

        bindings["+ESC"] = "QUIT";
        bindings["+PGUP"] = "ZOOMIN";
        bindings["+PGDOWN"] = "ZOOMOUT";
        bindings["+LEFTARROW"] = "SCROLLLEFT";
        bindings["+UPARROW"] = "SCROLLUP";
        bindings["+RIGHTARROW"] = "SCROLLRIGHT";
        bindings["+DOWNARROW"] = "SCROLLDOWN";
        bindings["+SPACE"] = "";
        bindings["+LMOUSE"] = "!SELECT"; //only called once
        bindings["+RMOUSE"] = "!GRABSCREEN";
        bindings["-RMOUSE"] = "!RELEASESCREEN";
        bindings["+WMouse"] = "!ZOOMIN";
        bindings["-WMouse"] = "!ZOOMOUT";
        
        functions["QUIT"] = &FunctionHandler::quit;
        functions["ZOOMIN"] = &FunctionHandler::zoomIn;
        functions["ZOOMOUT"] = &FunctionHandler::zoomOut;
        functions["SCROLLLEFT"] = &FunctionHandler::scrollLeft;
        functions["SCROLLUP"] = &FunctionHandler::scrollUp;
        functions["SCROLLRIGHT"] = &FunctionHandler::scrollRight;
        functions["SCROLLDOWN"] = &FunctionHandler::scrollDown;
        functions["SELECT"] = &FunctionHandler::select;
        functions["GRABSCREEN"] = &FunctionHandler::grabScreen;
        functions["RELEASESCREEN"] = &FunctionHandler::releaseScreen;
        functions["SCROLLSCREEN"] = &FunctionHandler::scroll;
        functions["STANDARDACTION"] = &FunctionHandler::standardAction;
        functions["SETTLE"] = &FunctionHandler::settle;
        functions["SETSPAWNDESTINATION"] = &FunctionHandler::setSpawnDestination;
        functions["SELECTBONUS"] = &FunctionHandler::selectBonus;
        
        playerInterface = 0;
        network = 0;
}

Level::~Level()
{
        if (playerInterface != 0)
                delete playerInterface;
}

int Level::run()
{

        int ret = 0;

        // if we multiply this with clock() than we have a better GetTickCount
        double clock_per_ms = 1000.0 / (double)CLOCKS_PER_SEC;
        // the time a GE Tick is over
        double endTime = clock() * clock_per_ms;
        // the time we jumped in
        double globStartTime = clock() * clock_per_ms;

        //Variable for the current time;
        double curTime;

        //init rounds
        round = 0;

        bool run = true;

        do
        {
                //increase roundcounter
                round++;

                // endTime will incresed with our round delta
                endTime += roundTime;
                
                //check for input-messages
                run = checkInput();

                //compute everything on the grid
                //compute();

                //process events
                std::list< EventInterface* >::iterator it;
                for (it = eventList[0].begin(); it != eventList[0].end(); it++)
                {
                        (*it)->compute(this);
                        delete (*it);
                }
                eventList[0].clear();
                eventList.moveOn();


                //compute visibility
                computeVisibility();

                //render szene
                setViewportCamera();
                initViewCamera();
                renderScene();
                //render interface
                setViewportInterface();
                initViewInterface();
                renderInterface();
                //finished rendering
                glFlush();
                window->swapBuffers();

                // sleep, until we reached endtime
                do
                {
                        // sleep
                        sleep(0);
                        // compute curTime
                        curTime = clock() * clock_per_ms;
                } 
                while (curTime < endTime);

        }
        while (run);

        return ret;
}

int Level::compute()
{
        int ret = 0;
        unsigned int i,j;
        for (i = 0; i < grid.size(); i++)
        {       
                for (j = 0; j < grid[i].size(); j++)
                {
                        if (grid[i][j] != 0)
                        {
                                if (grid[i][j]->unit != 0) //compute only units
                                {
                                        grid[i][j]->unit->compute(grid[i][j], this);
                                }
                        }
                }
        }
        return ret;
}

int Level::initViewCamera(bool resetMatrix)
{
        int ret = 0;
        
        //we are working on the porjection matrix oly.
        glMatrixMode(GL_PROJECTION);

        if (resetMatrix)
        {
                //reset camera
                glLoadIdentity();
        }

        //perspective view (45deg fov)
        gluPerspective(45.0, (GLfloat)window->width/(GLfloat)window->height, 0.125, 1048575.875);
        
        //rotate so we look to -Z
        glRotated(180.0, 0.0, 1.0, 0.0);
        //translate to camera position
        glTranslated(position.x, position.y, position.z);

        return ret;
}

int Level::initViewInterface(bool resetMatrix)
{
        int ret = 0;

        //we are working on the porjection matrix oly.
        glMatrixMode(GL_PROJECTION);

        if (resetMatrix)
        {
                //reset camera
                glLoadIdentity();
        }

        //perspectivew view with 45deg fov
        gluPerspective(45.0, interfaceSizeWidth/interfaceSizeHeight, 0.125, 1048575.875);

        //rotate so we look to -Z
        glRotated(180.0, 0.0, 1.0, 0.0);

        //trasnlate fixed so we have the same position for the interface
        glTranslated(0.0, 0.0, 0.4);

        return ret;
}

int Level::renderScene(bool p_normal)
{
        int ret = 0;

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        glDisable(GL_DEPTH_TEST);
        //render fields
        Vector3d pos;
        unsigned int i,j;
        for (i = 0; i < grid.size(); i++)
        {       
                for (j = 0; j < grid[i].size(); j++)
                {
                        if (grid[i][j] != 0)
                        {
                                grid[i][j]->render(pos);
                                if (p_normal)
                                        grid[i][j]->renderChild(pos, this);
                        }
                        pos.y += 0.87;
                }
                pos.x += 0.75;
                if ((i%2) == 0)
                {
                        pos.y = 0.44;
                }
                else
                {
                        pos.y = 0.0;
                }
        }
        //now all effects
        std::list<Texture*>::iterator it;

        if (p_normal)
                for (it = effects.begin(); it != effects.end(); it++)
                {
                        (*it)->render();
                }

        glEnable(GL_DEPTH_TEST);
        
        return ret;
}

int Level::renderInterface()
{
        int ret = 0;

        playerInterface->render();

        return ret;
}

bool Level::checkInput()
{
        bool ret = true;
        singleCommands.clear();

        //check messages
        if (window->checkMessages() == 1)
                ret = false;

        std::string msg;
        std::map<std::string, std::string>::iterator bind_it;
        while (inputMessages.size() > 0)
        {
                msg = inputMessages.front();
                inputMessages.pop_front();

                ret &= (msg != "QUIT");
                if (msg == "-RMOUSE")
                        std::string t = msg;
                if (msg == "BUTTONSETTLE")
                        int t = 3;
                bind_it = bindings.find(msg);
                if (bind_it != bindings.end())
                {
                        //single command?
                        if (bind_it->second.find("!") == 0)
                        {
                                singleCommands.push_back(bind_it->second.substr(1));
                        }
                        else
                        {
                                currentCommands.remove(bind_it->second);
                                currentCommands.push_back(bind_it->second);
                        }
                }
                else
                {
                        //check if an old command has to be removed
                        
                        bind_it = bindings.find(msg.replace(0, 1, "+"));
                        if (bind_it != bindings.end())
                        {
                                currentCommands.remove(bind_it->second);
                        }
                }
        }
        //afterwards run commands
        std::list<std::string>::iterator it;
        for (it = currentCommands.begin(); it != currentCommands.end(); it++)
        {
                std::vector<std::string> param; 
                if (functions.find(*it) != functions.end())
                        (*functions[*it])(param, this);
        }
        for (it = singleCommands.begin(); it != singleCommands.end(); it++)
        {
                std::vector<std::string> param; 
                if (functions.find(*it) != functions.end())
                        (*functions[*it])(param, this);
        }
        return ret;
}

bool Level::setVisible(unsigned int p_x, unsigned int p_y)
{
        bool ret = false;
        if ((0 <= p_x) && (p_x < grid.size()) && (0 <= p_y) && (p_y < grid[p_x].size()))
                if (grid[p_x][p_y] != 0)
                        ret = grid[p_x][p_y]->isVisible = true;
        return ret;
}

int Level::computeVisibility()
{
        int ret = 0;

        unsigned int i,j;
        for (i = 0; i < grid.size(); i++)
                for (j = 0; j < grid[i].size(); j++)
                        if (grid[i][j] != 0)
                                grid[i][j]->isVisible = grid[i][j]->isSettleRange; //make ivisible

        for (i = 0; i < grid.size(); i++)
                for (j = 0; j < grid[i].size(); j++)
                        if (grid[i][j] != 0)
                                if (grid[i][j]->unit != 0)
                                {
                                        setVisible(i - 2, j - 1);
                                        setVisible(i - 2, j + 0);
                                        setVisible(i - 2, j + 1);
                                        
                                        if (i % 2 == 0)
                                                setVisible(i - 1, j - 2);
                                        setVisible(i - 1, j - 1);
                                        setVisible(i - 1, j + 0);
                                        setVisible(i - 1, j + 1);
                                        if (i % 2 == 1)
                                                setVisible(i - 1, j + 2);

                                        setVisible(i + 0, j - 2);
                                        setVisible(i + 0, j - 1);
                                        setVisible(i + 0, j + 0);
                                        setVisible(i + 0, j + 1);
                                        setVisible(i + 0, j + 2);

                                        if (i % 2 == 0)
                                                setVisible(i + 1, j - 2);
                                        setVisible(i + 1, j - 1);
                                        setVisible(i + 1, j + 0);
                                        setVisible(i + 1, j + 1);
                                        if (i % 2 == 1)
                                                setVisible(i + 1, j + 2);


                                        setVisible(i + 2, j - 1);
                                        setVisible(i + 2, j + 0);
                                        setVisible(i + 2, j + 1);

                                }
        return ret;
}

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

        this->initGL();

        playerInterface = new Interface(this);
        playerInterface->load("green", "blue");

        //initialize
        int sizeX = 50;
        int sizeY = 50;
        
        std::vector<Field*> line(sizeY);
        std::vector< std::vector<Field*> > _grid(sizeX, line);

        grid.assign(_grid.begin(), _grid.end());

        for (unsigned int i = 0; i < grid.size(); i++)
        {
                for (unsigned int j = 0; j < grid[i].size(); j++)
                {
                        grid[i][j] = 0;
                }
        }
        
        std::ifstream fin(p_filename.c_str());
        std::string buffer;
        std::vector<std::string> values;
        //initialize random generator
        srand(GetTickCount());
        while (fin.good()) {
                std::getline(fin,buffer,'\n');
                splitLine(values, buffer, ";");
                if (values.size() >= 6)
                {
                        unsigned int i = atoi(values[0].c_str()) - 1;
                        unsigned int j = atoi(values[1].c_str()) - 1;
                        grid[i][j] = new Field();
                        grid[i][j]->xCoord = i;
                        grid[i][j]->yCoord = j;
                        double green = atof(values[2].c_str());
                        double yellow = atof(values[3].c_str());
                        double red = atof(values[4].c_str());
                        double grey = atof(values[5].c_str());
                        double randEnergy = rand() / (double)RAND_MAX;
                        if (green > randEnergy)
                                grid[i][j]->energy = 15;
                        else if (green + yellow > randEnergy)
                                grid[i][j]->energy = 10;
                        else if (green + yellow + red > randEnergy)
                                grid[i][j]->energy = 5;
                        else
                                grid[i][j]->energy = 0;
                        if (values.size() >= 7) // maybe settlerange
                                if (values[6] == "SR")
                                        grid[i][j]->isSettleRange = true;
                        if (values.size() == 9) //an unit is placed here
                        {
                                std::string unitName = values[7];
                                std::string playerName = values[8];
                                //check if player exists
                                if (players.find(playerName) == players.end())
                                {
                                        players[playerName] = new Player(playerName);
                                }
                                grid[i][j]->unit = new Unit(players[playerName]);
                                grid[i][j]->unit->load("units//" + unitName);
                        }
                }
        }
        fin.close();

        Field::shadowTexture = new Object();
        Field::shadowTexture->loadAndBind("textures//shadow.png");

        return ret;
}

int Level::init()
{
        int ret = 0;

        int maxI = -1;
        int maxJ = -1;

        //Load all Textures
        for (int i = 0; i < (int) grid.size(); i++)
        {
                for (int j = 0; j < (int) grid[i].size(); j++)
                {
                        if (grid[i][j] != 0)
                        {
                                grid[i][j]->select("textures//plant.png");
                                if (i > maxI)
                                        maxI = i;
                                if (j > maxJ)
                                        maxJ = j;
                        }
                }
        }

        position = Vector3d(-(maxI / 2.0) * 0.75, -(maxJ /2.0) * 0.87 - 0.44, 25.0);

        return ret;
}

int Level::initGL()
{
        int ret = 0;

        ret = GLInterface::initGL();

        return ret;
}

int Level::pick()
{
        int x = window->mousePos.x;
        int y = window->mousePos.y;
        int halfWidth = (int)(window->width / 2.0);
        int ret = 0;
        //check if the interface or the playingfield has been clicked
        bool checkInterface =   ((x >= halfWidth - (interfaceSizeWidth / 2))
                                                        && (x <= halfWidth + (interfaceSizeWidth / 2)) 
                                                        && (y <= interfaceSizeHeight));

        GLuint buff[256] = {0};
        GLint hits, view[4];

        //set everything
        if (checkInterface)
        {
                setViewportInterface();
                initViewInterface();
        }
        else
        {
                setViewportCamera();
                initViewCamera();
        }

        //This choose the buffer where store the values for the selection data
        glSelectBuffer(256, buff);
 
        //This retrieve info about the viewport
        glGetIntegerv(GL_VIEWPORT, view);

        // Switching in selecton mode
        glRenderMode(GL_SELECT);

        // Clearing the name's stack - This stack contains all the info about the objects
        glInitNames();
 
        // Now fill the stack with one element (or glLoadName will generate an error)
        glPushName(0);
 
        // Now modify the vieving volume, restricting selection area around the cursor*/
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
                glLoadIdentity();
 
                // restrict the draw to an area around the cursor
                gluPickMatrix(x, y, 1.0, 1.0, view);

                if (checkInterface)
                {
                        initViewInterface(false);
                        
                        // draw only the names in the stack, and fill the array
                        renderInterface();
                }
                else
                {
                        initViewCamera(false);
                        
                        // draw only the names in the stack, and fill the array
                        renderScene(false);
                }
 
                // Do you remeber? We do pushMatrix in PROJECTION mode
                glMatrixMode(GL_PROJECTION);
        glPopMatrix();
 
        // get number of objects drawed in that area - and return to render mode
        hits = glRenderMode(GL_RENDER);
 

        glMatrixMode(GL_MODELVIEW);


        //ow select the lowest id, as it marks the field:
        if (hits > 0)
        {
                ret = 1000000;
                for (int i = 0; i < hits; i++)
                {
                        if (ret > (GLubyte)buff[i * 4 + 3])
                                ret = (GLubyte)buff[i * 4 + 3];
                }
        }
        return ret;
}

int Level::setViewportCamera ()
{
        int ret = 0;
        
        glViewport(0, 0, window->width, window->height);
        
        return ret;
}

int Level::setViewportInterface ()
{
        int ret = 0;

        int halfWidth = (int)(window->width / 2.0);

        glViewport(halfWidth - (interfaceSizeWidth / 2), 0, interfaceSizeWidth, interfaceSizeHeight);

        return ret;
}

---