]> git.localhorst.tv Git - blobs.git/blob - src/app/app.cpp
eating and drinking
[blobs.git] / src / app / app.cpp
1 #include "Application.hpp"
2 #include "Assets.hpp"
3 #include "State.hpp"
4
5 #include "init.hpp"
6 #include "../graphics/Viewport.hpp"
7 #include "../io/Token.hpp"
8 #include "../io/TokenStreamReader.hpp"
9
10 #include <fstream>
11 #include <SDL.h>
12 #include <SDL_image.h>
13
14 using std::string;
15
16
17 namespace blobs {
18 namespace app {
19
20 Application::Application(Window &win, graphics::Viewport &vp)
21 : window(win)
22 , viewport(vp)
23 , states() {
24 }
25
26 Application::~Application() {
27 }
28
29
30 void Application::PushState(State *s) {
31         s->app = this;
32         if (!states.empty()) {
33                 states.top()->OnPause();
34         }
35         states.emplace(s);
36         ++s->ref_count;
37         if (s->ref_count == 1) {
38                 s->OnEnter();
39         }
40         s->OnResume();
41 }
42
43 State *Application::PopState() {
44         State *s = states.top();
45         states.pop();
46         s->OnPause();
47         s->OnExit();
48         if (!states.empty()) {
49                 states.top()->OnResume();
50         }
51         return s;
52 }
53
54 State *Application::SwitchState(State *s_new) {
55         s_new->app = this;
56         State *s_old = states.top();
57         states.top() = s_new;
58         --s_old->ref_count;
59         ++s_new->ref_count;
60         s_old->OnPause();
61         if (s_old->ref_count == 0) {
62                 s_old->OnExit();
63         }
64         if (s_new->ref_count == 1) {
65                 s_new->OnEnter();
66         }
67         s_new->OnResume();
68         return s_old;
69 }
70
71 State &Application::GetState() {
72         return *states.top();
73 }
74
75 bool Application::HasState() const noexcept {
76         return !states.empty();
77 }
78
79
80 void Application::Run() {
81         Uint32 last = SDL_GetTicks();
82         while (HasState()) {
83                 Uint32 now = SDL_GetTicks();
84                 int delta = now - last;
85                 Loop(delta);
86                 last = now;
87         }
88 }
89
90 void Application::Loop(int dt) {
91         HandleEvents();
92         if (!HasState()) return;
93         GetState().Update(dt);
94         if (!HasState()) return;
95         viewport.Clear();
96         GetState().Render(viewport);
97         window.Flip();
98 }
99
100 void Application::HandleEvents() {
101         SDL_Event event;
102         while (HasState() && SDL_PollEvent(&event)) {
103                 if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_RESIZED) {
104                         viewport.Resize(event.window.data1, event.window.data2);
105                 }
106                 GetState().Handle(event);
107         }
108 }
109
110 void State::Handle(const SDL_Event &event) {
111         switch (event.type) {
112                 case SDL_KEYDOWN:
113                         OnKeyDown(event.key);
114                         break;
115                 case SDL_KEYUP:
116                         OnKeyUp(event.key);
117                         break;
118                 case SDL_MOUSEBUTTONDOWN:
119                         OnMouseDown(event.button);
120                         break;
121                 case SDL_MOUSEBUTTONUP:
122                         OnMouseUp(event.button);
123                         break;
124                 case SDL_MOUSEMOTION:
125                         OnMouseMotion(event.motion);
126                         break;
127                 case SDL_MOUSEWHEEL:
128                         OnMouseWheel(event.wheel);
129                         break;
130                 case SDL_QUIT:
131                         OnQuit();
132                         break;
133                 case SDL_WINDOWEVENT:
134                         Handle(event.window);
135                         break;
136                 default:
137                         // ignore
138                         break;
139         }
140 }
141
142 void State::Handle(const SDL_WindowEvent &event) {
143         switch (event.event) {
144                 case SDL_WINDOWEVENT_FOCUS_GAINED:
145                         OnFocus();
146                         break;
147                 case SDL_WINDOWEVENT_FOCUS_LOST:
148                         OnBlur();
149                         break;
150                 case SDL_WINDOWEVENT_RESIZED:
151                         OnResize(event.data1, event.data2);
152                         break;
153                 default:
154                         break;
155         }
156 }
157
158 void State::Update(int dt) {
159         OnUpdate(dt);
160 }
161
162 void State::Render(graphics::Viewport &viewport) {
163         OnRender(viewport);
164 }
165
166 void State::OnQuit() {
167         while (App().HasState()) {
168                 App().PopState();
169         }
170 }
171
172
173 Assets::Assets()
174 : path("assets/")
175 , data_path(path + "data/")
176 , font_path(path + "fonts/")
177 , skin_path(path + "skins/")
178 , tile_path(path + "tiles/")
179 , fonts{
180         graphics::Font(font_path + "DejaVuSans.ttf", 32),
181         graphics::Font(font_path + "DejaVuSans.ttf", 24),
182         graphics::Font(font_path + "DejaVuSans.ttf", 16)
183 } {
184         {
185                 std::ifstream resource_file(data_path + "resources");
186                 io::TokenStreamReader resource_reader(resource_file);
187                 ReadResources(resource_reader);
188         }
189
190         {
191                 std::ifstream tile_file(data_path + "tile_types");
192                 io::TokenStreamReader tile_reader(tile_file);
193                 ReadTileTypes(tile_reader);
194         }
195
196
197         graphics::Format format;
198         textures.tiles.Bind();
199         textures.tiles.Reserve(256, 256, 14, format);
200         LoadTileTexture("algae",    textures.tiles,  0);
201         LoadTileTexture("desert",   textures.tiles,  1);
202         LoadTileTexture("forest",   textures.tiles,  2);
203         LoadTileTexture("grass",    textures.tiles,  3);
204         LoadTileTexture("ice",      textures.tiles,  4);
205         LoadTileTexture("jungle",   textures.tiles,  5);
206         LoadTileTexture("mountain", textures.tiles,  6);
207         LoadTileTexture("ocean",    textures.tiles,  7);
208         LoadTileTexture("rock",     textures.tiles,  8);
209         LoadTileTexture("sand",     textures.tiles,  9);
210         LoadTileTexture("taiga",    textures.tiles, 10);
211         LoadTileTexture("tundra",   textures.tiles, 11);
212         LoadTileTexture("water",    textures.tiles, 12);
213         LoadTileTexture("wheat",    textures.tiles, 13);
214
215         textures.skins.Bind();
216         textures.skins.Reserve(256, 256, 9, format);
217         LoadSkinTexture("1", textures.skins, 0);
218         LoadSkinTexture("2", textures.skins, 1);
219         LoadSkinTexture("3", textures.skins, 2);
220         LoadSkinTexture("4", textures.skins, 3);
221         LoadSkinTexture("5", textures.skins, 4);
222         LoadSkinTexture("6", textures.skins, 5);
223         LoadSkinTexture("7", textures.skins, 6);
224         LoadSkinTexture("8", textures.skins, 7);
225         LoadSkinTexture("9", textures.skins, 8);
226 }
227
228 Assets::~Assets() {
229 }
230
231 void Assets::ReadResources(io::TokenStreamReader &in) {
232         while (in.HasMore()) {
233                 string name;
234                 in.ReadIdentifier(name);
235                 in.Skip(io::Token::EQUALS);
236
237                 int id = 0;
238                 if (data.resources.Has(name)) {
239                         id = data.resources[name].id;
240                 } else {
241                         world::Resource res;
242                         res.name = name;
243                         id = data.resources.Add(res);
244                 }
245
246                 in.Skip(io::Token::ANGLE_BRACKET_OPEN);
247                 while (in.Peek().type != io::Token::ANGLE_BRACKET_CLOSE) {
248                         in.ReadIdentifier(name);
249                         in.Skip(io::Token::EQUALS);
250                         if (name == "label") {
251                                 in.ReadString(data.resources[id].label);
252                         } else if (name == "state") {
253                                 in.ReadIdentifier(name);
254                                 if (name == "solid") {
255                                         data.resources[id].state = world::Resource::SOLID;
256                                 } else if (name == "liquid") {
257                                         data.resources[id].state = world::Resource::LIQUID;
258                                 } else if (name == "gas") {
259                                         data.resources[id].state = world::Resource::GAS;
260                                 } else if (name == "plasma") {
261                                         data.resources[id].state = world::Resource::PLASMA;
262                                 } else {
263                                         throw std::runtime_error("unknown resource state '" + name + "'");
264                                 }
265                         } else {
266                                 throw std::runtime_error("unknown resource property '" + name + "'");
267                         }
268                         in.Skip(io::Token::SEMICOLON);
269                 }
270                 in.Skip(io::Token::ANGLE_BRACKET_CLOSE);
271                 in.Skip(io::Token::SEMICOLON);
272         }
273 }
274
275 void Assets::ReadTileTypes(io::TokenStreamReader &in) {
276         while (in.HasMore()) {
277                 string name;
278                 in.ReadIdentifier(name);
279                 in.Skip(io::Token::EQUALS);
280
281                 int id = 0;
282                 if (data.tile_types.Has(name)) {
283                         id = data.tile_types[name].id;
284                 } else {
285                         world::TileType type;
286                         type.name = name;
287                         id = data.tile_types.Add(type);
288                 }
289
290                 in.Skip(io::Token::ANGLE_BRACKET_OPEN);
291                 while (in.Peek().type != io::Token::ANGLE_BRACKET_CLOSE) {
292                         in.ReadIdentifier(name);
293                         in.Skip(io::Token::EQUALS);
294                         if (name == "label") {
295                                 in.ReadString(data.tile_types[id].label);
296                         } else if (name == "texture") {
297                                 data.tile_types[id].texture = in.GetInt();
298                         } else if (name == "yield") {
299                                 in.Skip(io::Token::BRACKET_OPEN);
300                                 while (in.Peek().type != io::Token::BRACKET_CLOSE) {
301                                         world::TileType::Yield yield;
302                                         in.Skip(io::Token::ANGLE_BRACKET_OPEN);
303                                         while (in.Peek().type != io::Token::ANGLE_BRACKET_CLOSE) {
304                                                 in.ReadIdentifier(name);
305                                                 in.Skip(io::Token::EQUALS);
306                                                 if (name == "resource") {
307                                                         in.ReadIdentifier(name);
308                                                         yield.resource = data.resources[name].id;
309                                                 } else if (name == "ubiquity") {
310                                                         yield.ubiquity = in.GetDouble();
311                                                 } else {
312                                                         throw std::runtime_error("unknown tile type yield property '" + name + "'");
313                                                 }
314                                                 in.Skip(io::Token::SEMICOLON);
315                                         }
316                                         in.Skip(io::Token::ANGLE_BRACKET_CLOSE);
317                                         data.tile_types[id].resources.push_back(yield);
318                                         if (in.Peek().type == io::Token::COMMA) {
319                                                 in.Skip(io::Token::COMMA);
320                                         }
321                                 }
322                                 in.Skip(io::Token::BRACKET_CLOSE);
323                         } else {
324                                 throw std::runtime_error("unknown tile type property '" + name + "'");
325                         }
326                         in.Skip(io::Token::SEMICOLON);
327                 }
328                 in.Skip(io::Token::ANGLE_BRACKET_CLOSE);
329                 in.Skip(io::Token::SEMICOLON);
330         }
331 }
332
333 void Assets::LoadTileTexture(const string &name, graphics::ArrayTexture &tex, int layer) const {
334         string path = tile_path + name + ".png";
335         SDL_Surface *srf = IMG_Load(path.c_str());
336         if (!srf) {
337                 throw SDLError("IMG_Load");
338         }
339         try {
340                 tex.Data(layer, *srf);
341         } catch (...) {
342                 SDL_FreeSurface(srf);
343                 throw;
344         }
345         SDL_FreeSurface(srf);
346 }
347
348 void Assets::LoadSkinTexture(const string &name, graphics::ArrayTexture &tex, int layer) const {
349         string path = skin_path + name + ".png";
350         SDL_Surface *srf = IMG_Load(path.c_str());
351         if (!srf) {
352                 throw SDLError("IMG_Load");
353         }
354         try {
355                 tex.Data(layer, *srf);
356         } catch (...) {
357                 SDL_FreeSurface(srf);
358                 throw;
359         }
360         SDL_FreeSurface(srf);
361 }
362
363 }
364 }