delete is now thread safe

[physics.git] / src / game.cpp

/*
 *  Copyright (C) 2008 Patrik Gornicz, Gornicz_P (at) hotmail (dot) com.
 *
 *  This program 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 "game.h"
#include "debug.h"

#include <vector>
using std::vector;

#include "entityCreator.h"
#include "effectManager.h"

#include "GameStates/GameState.h"
#include "GameStates/Running.h"
#include "GameStates/Paused.h"
#include "GameStates/CreatingPolygon.h"


/// ***** Private Variables *****

// The stack of active game states
vector<GameState*> active_States;

// Pointers to each possible game state
// inserted and removed from the active_States
Running* running;
Paused* paused;
CreatingPolygon* creating_Polygon;

// true if the top state requested itself to be poped
bool pop_State;
// pointer to a state wishing to be added
GameState* push_State;


/// ***** Public Methods *****

void game::init()
{
    running = new Running();
    paused = new Paused();
    creating_Polygon = new CreatingPolygon();

    pop_State = false;
    push_State = NULL;

    // create starting entities
    creator::init();

    active_States.push_back(running);

    effect::init();

    DPF(0, "World Created");
}

void game::clean()
{
    effect::clean();

    creator::clean();

    delete creating_Polygon;
    delete paused;
    delete running;
}

void game::handleInput()
{
    creator::handleInput();


    if(running->pushMe())
        push_State = running;

    if(paused->pushMe())
        push_State = paused;

    if(creating_Polygon->pushMe())
        push_State = creating_Polygon;


    int last = active_States.size() -1;
    for( int i = 0;
         i <= last;
         i++ )
    {
        if( i == last )
        {
            if(active_States[i]->popMe())
                pop_State = true;
            else
                active_States[i]->handleInput(true);
        }
        else
            active_States[i]->handleInput(false);
    }
}

void game::update(float time_step)
{
    if(push_State != NULL)
    {
        // don't want to pop and push same state, pop wins arbitrary
        if(!pop_State)
            active_States.push_back(push_State);

        push_State = NULL;
    }

    if(pop_State)
    {
        active_States.pop_back();
        pop_State = false;
    }

    int last = active_States.size() -1;
    for( int i = 0;
         i <= last;
         i++ )
    {
        if( i == last )
            active_States[i]->update(time_step, true);
        else
            active_States[i]->update(time_step, false);
    }
}

void game::draw()
{
    int last = active_States.size() -1;
    for( int i = 0;
         i <= last;
         i++ )
    {
        if( i == last )
            active_States[i]->draw(true);
        else
            active_States[i]->draw(false);
    }
}