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

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

#include "Level.h"
#include "Field.h"
#include "Player.h"
#include "myTools.h"
#include "Button.h"

Interface::Interface(Level *p_level)
{
        level = p_level;
        id += 200;
}

Interface::~Interface()
{
}

int Interface::render()
{
        int ret = 0;

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glDisable(GL_DEPTH_TEST);

        Texture::render();

        std::vector<Button*>::iterator it;
        for (it = buttons.begin(); it != buttons.end(); it++)
        {
                (*it)->render();
        }

        
        //now the selected field with unit on it
        if (Unit::s_selectedID != -1)
        {
                //get the origin field
                Texture *texture = Texture::get(Field::s_selectedFieldID);
                //clean cast
                Field* field = texture->getField();
                if (field != 0)
                {
                        glPushMatrix();
                        field->render(unitWindowPos, unitWindow->size);
                        //I don't know why i have to add this offset, in normal render it is not needed :(
                        field->renderChild(unitWindowPos - Vector3d(0.0, 0.055, 0.0), level, unitWindow->size);
                        glPopMatrix();

                }
        }
        else // the empty window
        {
                unitWindow->render(unitWindowPos);
        }

        //now the energy counter and text
        glPushMatrix();

        energyCounter->render(energyCounterPos);
        glTranslated(energyCounterFontPos.x, energyCounterFontPos.y, energyCounterFontPos.z);
        glColor4d(0.5, 0.5, 0.5, 1.0);
        level->glPrint2d(0.0, 0.0, "%i", level->players[playerName]->energy);
        glPopMatrix();

        glEnable(GL_DEPTH_TEST);


        return ret;
}

int Interface::load(std::string p_style, std::string p_playerName)
{
        int ret = 0;
        playerName = p_playerName;
        std::string filename = "textures//interface//" + p_style + "//interface.ini";
        std::ifstream fin(filename.c_str());
        std::string buffer;
        std::vector<std::string> values, more_values;
        Button* btn;
        while (fin.good()) {
                std::getline(fin,buffer,'\n');
                splitLine(values, buffer, "=");
                if (true)
                {
                        if (values[0].find("background") != std::string::npos)
                        {
                                loadAndBind("textures//interface//" + p_style + "//" + values[1]);
                        } 
                        else if (values[0].find("button") != std::string::npos)
                        {
                                splitLine(more_values, values[1], ",");
                                btn = new Button(this);
                                btn->loadAndBind("textures//interface//" + p_style + "//" + more_values[0]);
                                btn->size = atof(more_values[1].c_str());
                                btn->pos = Vector3d(atof(more_values[2].c_str()), atof(more_values[3].c_str()), 0.0);
                                btn->label = more_values[4];
                                if (more_values.size() > 5)
                                        btn->val = atoi(more_values[5].c_str());
                                buttons.push_back(btn);
                        }
                        else if (values[0].find("energy_display") != std::string::npos)
                        {
                                splitLine(more_values, values[1], ",");
                                energyCounter = new Object();
                                energyCounter->loadAndBind("textures//interface//" + p_style + "//" + more_values[0]);
                                energyCounter->size = atof(more_values[1].c_str());
                                energyCounterPos = Vector3d(atof(more_values[2].c_str()), atof(more_values[3].c_str()), 0.0);
                                energyCounterFontPos = Vector3d(atof(more_values[4].c_str()), atof(more_values[5].c_str()), 0.0);
                                //as the font-pos is regarded aas offset to energycounter, we simply add it
                                energyCounterFontPos += energyCounterPos;
                        }
                        else if (values[0].find("unit_placeholder") != std::string::npos)
                        {
                                splitLine(more_values, values[1], ",");
                                unitWindow = new Object();
                                unitWindow->loadAndBind("textures//interface//" + p_style + "//" + more_values[0]);
                                unitWindow->size = atof(more_values[1].c_str());
                                unitWindowPos = Vector3d(atof(more_values[2].c_str()), atof(more_values[3].c_str()), 0.0);
                        }
                }
        }
        fin.close();
        return ret;
}

---