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

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

#include "Window.h"

Menu::Menu (Window* p_window) : GLInterface (p_window)
{
}

Menu::~Menu()
{
}

std::string Menu::getLevelName(std::string p_directory, std::string p_mask)
{
        std::string ret;

        // get all files in the current directory
        std::vector<std::string> level_files = this->getLevelFiles(p_directory + "//" + p_mask);

        ret = this->getSelectedItem(level_files);
        
        //if not "QUIT" add directory
        if (ret != "QUIT")
                ret.insert(0, p_directory + "//");
        else //ret is empty
                ret = "";

        return ret;
}

eGameMode Menu::getGameMode()
{
        eGameMode ret = GM_None;

        std::vector<std::string> options;

        options.push_back("local");
        options.push_back("host");
        options.push_back("connect");

        //now the copyright notice
        options.push_back("");
        options.push_back("");
        options.push_back("c0re  Copyright (C) 2007  Stephan Hofmann");
        options.push_back("");
        options.push_back("This program comes with ABSOLUTELY NO");
        options.push_back("WARRANTY. This is free software, and ");
        options.push_back("you are welcome to redistribute it under");
        options.push_back("certain conditions; See license.txt");

        std::string result = this->getSelectedItem(options);
        if (result == "local")
                ret = GM_Local;
        else if (result == "host")
                ret = GM_Server;
        else if (result == "connect")
                ret = GM_Client;

        return ret;
}

std::string Menu::getString(std::string p_display, std::string p_default)
{
        std::string ret = p_default;
        initGL();
        
        bool run = true;

        do
        {
                this->renderInputText(p_display, ret);
                if (window->checkMessages() == 1)
                        run = false;
                //get messages
                std::string msg;
                while (inputMessages.size() > 0)
                {
                        msg = inputMessages.front();
                        inputMessages.pop_front();
                        if ((msg == "QUIT") || (msg == "+ESC"))
                        {
                                ret = "";
                                run = false;
                        }
                        else if (msg == "+RETURN")
                                run = false;
                        else if (msg == "+SPACE")
                                ret.append(" ");
                        else if ((msg == "+BACKSPACE") && (ret.length() > 0))
                                ret.erase(ret.length() - 1, 1 );
                        else if ((msg.size() == 2) && (msg[0] == '+'))
                                ret += msg[1];
                }

        } while (run);

        window->clearCurrent();
        return ret;
}

std::string Menu::getSelectedItem(std::vector<std::string> &p_options, int p_maxOption)
{
        if ((p_maxOption == -1) || (p_maxOption > (int)p_options.size()))
                p_maxOption = (int)p_options.size();
                
        std::string ret = "";
        
        initGL();
        
        //highlighting the first Element
        unsigned int currentElement = 0;
        
        //process user queries
        do
        {
                //render the menu
                this->renderSelectionList(p_options, currentElement);
                if (window->checkMessages() == 1)
                        ret = "QUIT";

                std::string msg;
                while (inputMessages.size() > 0)
                {
                        msg = inputMessages.front();
                        inputMessages.pop_front();
                        if ((msg == "QUIT") || (msg == "+ESC"))
                                ret = "QUIT";
                        else if ((msg == "+SPACE") || (msg == "+RETURN"))
                        {
                                if (currentElement != p_maxOption)
                                {
                                        ret = p_options[currentElement];
                                }
                                else //but only if not "Exit" is selected
                                {
                                        ret = "QUIT";
                                }
                        }
                        else if (msg == "+UPARROW")
                        {
                                if (currentElement != 0)
                                {
                                        currentElement--;
                                }
                        }
                        else if (msg == "+DOWNARROW")
                        {
                                if (currentElement != p_maxOption)
                                {
                                        currentElement++;
                                }
                        }
                }
                sleep();
        } while (ret.length() == 0); //Repeat until something has been selected

        window->clearCurrent();

        return ret;
}

int Menu::renderSelectionList(std::vector<std::string> &p_options, unsigned int p_currentElement)
{
        int ret = 0;
        writeText(p_options, p_currentElement + 1);
        return ret;
}

int Menu::renderInputText(std::string p_display, std::string p_input)
{
        int ret = 0;
        std::vector<std::string> vec;
        vec.push_back(p_display);
        vec.push_back(std::string(">") + p_input);
        writeText(vec, 2);
        return ret;
}

std::vector<std::string> Menu::getLevelFiles(std::string p_filemask)
{
        std::vector<std::string> ret;

        HANDLE fHandle; 
        WIN32_FIND_DATA wfd; 

        // fetch first file in the directory
        fHandle=FindFirstFile(p_filemask.c_str(),&wfd); 
        do
        { 
                if (wfd.dwFileAttributes != FILE_ATTRIBUTE_DIRECTORY) 
                {
                        ret.push_back(std::string(wfd.cFileName));
                } 
        } while (FindNextFile(fHandle,&wfd));
        FindClose(fHandle);

        return ret;
}

int Menu::initGL()
{
        GLInterface::initGL();

        return 0;
}

int Menu::writeText(std::vector<std::string> p_text, int p_highlightedLine)
{
        int ret = 0;
        int begin = 0;
        int end = (int)p_text.size();
        if (p_highlightedLine < 1)
                p_highlightedLine = 1;
        else if (p_highlightedLine > end)
                p_highlightedLine = end;
        p_highlightedLine--;

        int count = 3;

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glViewport(0, 0, window->width, window->height);
        
        //perspective view 45deg fov
        gluPerspective(45.0, (GLfloat)window->width/(GLfloat)window->height, 0.125, 1048575.875);

        //now turn to look in thhe other direction
        glRotated(180.0, 0.0, 1.0, 0.0);
        //and set the postion fixed, to see the text
        glTranslated(1.0, 0.0, 2.0);

        double lineHeight = 0.1;

        int i;
        glColor3d(0.5, 0.5, 0.5);
        for (i = begin; i < p_highlightedLine; i++)
                glPrint2d(0.0, (count - i) * (lineHeight), p_text[i].c_str());
        glColor3d(1.0, 1.0, 1.0);
        glPrint2d(0.0, (count - p_highlightedLine) * (lineHeight), p_text[p_highlightedLine].c_str());  
        glColor3d(0.5, 0.5, 0.5);
        for (i = p_highlightedLine + 1; i < end; i++)
                glPrint2d(0.0, (count - i) * (lineHeight), p_text[i].c_str());

        glFlush();
        //swap buffer
        window->swapBuffers();

        return ret;
}

---