reworked ups/fps/paused logic
[physics.git] / src / game.cpp
1 /*
2  *  Copyright (C) 2008 Patrik Gornicz, Gornicz_P (at) hotmail (dot) com.
3  *
4  *  This program is free software: you can redistribute it and/or modify
5  *  it under the terms of the GNU General Public License as published by
6  *  the Free Software Foundation, either version 3 of the License, or
7  *  (at your option) any later version.
8  *
9  *  This program is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  *  GNU General Public License for more details.
13  *
14  *  You should have received a copy of the GNU General Public License
15  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
17
18 #include "game.h"
19 #include "debug.h"
20
21 #include <vector>
22 using std::vector;
23
24 #include "entityCreator.h"
25 #include "effectManager.h"
26
27 #include "GameStates/GameState.h"
28 #include "GameStates/Running.h"
29 #include "GameStates/Paused.h"
30 #include "GameStates/CreatingPolygon.h"
31
32
33 /// ***** Private Variables *****
34
35 // The stack of active game states
36 vector<GameState*> active_States;
37
38 // Pointers to each possible game state
39 // inserted and removed from the active_States
40 Running* running;
41 Paused* paused;
42 CreatingPolygon* creating_Polygon;
43
44 // true if the top state requested itself to be poped
45 bool pop_State;
46 // pointer to a state wishing to be added
47 GameState* push_State;
48
49
50 /// ***** Public Methods *****
51
52 void game::init()
53 {
54     running = new Running();
55     paused = new Paused();
56     creating_Polygon = new CreatingPolygon();
57
58     pop_State = false;
59     push_State = NULL;
60
61     // create starting entities
62     creator::init();
63
64     active_States.push_back(running);
65
66     effect::init();
67
68     DPF(0, "World Created");
69 }
70
71 void game::clean()
72 {
73     effect::clean();
74
75     creator::clean();
76
77     delete creating_Polygon;
78     delete paused;
79     delete running;
80 }
81
82 void game::handleInput()
83 {
84     creator::handleInput();
85
86     int last = active_States.size() -1;
87
88     if(active_States[last] != running && running->pushMe())
89     {
90         push_State = running;
91     }
92
93     if(active_States[last] != paused && paused->pushMe())
94     {
95         push_State = paused;
96     }
97
98     if(active_States[last] != creating_Polygon && creating_Polygon->pushMe())
99     {
100         push_State = creating_Polygon;
101     }
102
103
104     for( int i = 0;
105          i <= last;
106          i++ )
107     {
108         if( i == last )
109         {
110             if(active_States[i]->popMe())
111                 pop_State = true;
112             else
113                 active_States[i]->handleInput(true);
114         }
115         else
116             active_States[i]->handleInput(false);
117     }
118 }
119
120 void game::update(float time_step)
121 {
122     if(pop_State)
123     {
124         active_States.pop_back();
125         pop_State = false;
126     }
127
128     if(push_State != NULL)
129     {
130         active_States.push_back(push_State);
131         push_State = NULL;
132     }
133
134     int last = active_States.size() -1;
135     for( int i = 0;
136          i <= last;
137          i++ )
138     {
139         if( i == last )
140             active_States[i]->update(time_step, true);
141         else
142             active_States[i]->update(time_step, false);
143     }
144 }
145
146 void game::draw()
147 {
148     int last = active_States.size() -1;
149     for( int i = 0;
150          i <= last;
151          i++ )
152     {
153         if( i == last )
154             active_States[i]->draw(true);
155         else
156             active_States[i]->draw(false);
157     }
158 }