src/game.c

   1 #include <SDL.h>
   2 #include "system/stacktrace.h"
   3 #include <stdio.h>
   4
   5 #include "game.h"
   6 #include "game/level.h"
   7 #include "game/sound_samples.h"
   8 #include "game/level_picker.h"
   9 #include "system/log.h"
  10 #include "system/lt.h"
  11 #include "system/nth_alloc.h"
  12 #include "ui/console.h"
  13 #include "ui/edit_field.h"
  14 #include "system/str.h"
  15 #include "sdl/texture.h"
  16 #include "game/level/level_editor/background_layer.h"
  17 #include "game/level/level_editor.h"
  18
  19 static int game_render_cursor(const Game *game);
  20
  21 typedef enum Game_state {
  22     GAME_STATE_LEVEL = 0,
  23     GAME_STATE_LEVEL_PICKER,
  24     GAME_STATE_LEVEL_EDITOR,
  25     GAME_STATE_QUIT
  26 } Game_state;
  27
  28 typedef struct Game {
  29     Lt *lt;
  30
  31     Game_state state;
  32     Sprite_font *font;
  33     LevelPicker *level_picker;
  34     LevelEditor *level_editor;
  35     Level *level;
  36     Sound_samples *sound_samples;
  37     Camera camera;
  38     SDL_Renderer *renderer;
  39     SDL_Texture *texture_cursor;
  40     int cursor_x;
  41     int cursor_y;
  42 } Game;
  43
  44 static
  45 void game_switch_state(Game *game, Game_state state)
  46 {
  47     game->camera = create_camera(game->renderer, game->font);
  48     game->state = state;
  49 }
  50
  51 Game *create_game(const char *level_folder,
  52                   const char *sound_sample_files[],
  53                   size_t sound_sample_files_count,
  54                   SDL_Renderer *renderer)
  55 {
  56     trace_assert(level_folder);
  57
  58     Lt *lt = create_lt();
  59
  60     Game *game = PUSH_LT(lt, nth_calloc(1, sizeof(Game)), free);
  61     if (game == NULL) {
  62         RETURN_LT(lt, NULL);
  63     }
  64     game->lt = lt;
  65
  66     game->font = PUSH_LT(
  67         lt,
  68         create_sprite_font_from_file(
  69             "images/charmap-oldschool.bmp",
  70             renderer),
  71         destroy_sprite_font);
  72     if (game->font == NULL) {
  73         RETURN_LT(lt, NULL);
  74     }
  75
  76     game->level_picker = PUSH_LT(
  77         lt,
  78         create_level_picker(
  79             game->font,
  80             level_folder),
  81         destroy_level_picker);
  82     if (game->level_picker == NULL) {
  83         RETURN_LT(lt, NULL);
  84     }
  85
  86     game->sound_samples = PUSH_LT(
  87         lt,
  88         create_sound_samples(
  89             sound_sample_files,
  90             sound_sample_files_count),
  91         destroy_sound_samples);
  92     if (game->sound_samples == NULL) {
  93         RETURN_LT(lt, NULL);
  94     }
  95
  96     game->renderer = renderer;
  97     game->texture_cursor = PUSH_LT(
  98         lt,
  99         texture_from_bmp("images/cursor.bmp", renderer),
 100         SDL_DestroyTexture);
 101     if (SDL_SetTextureBlendMode(
 102             game->texture_cursor,
 103             SDL_ComposeCustomBlendMode(
 104                 SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR,
 105                 SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR,
 106                 SDL_BLENDOPERATION_ADD,
 107                 SDL_BLENDFACTOR_ONE,
 108                 SDL_BLENDFACTOR_ZERO,
 109                 SDL_BLENDOPERATION_ADD)) < 0) {
 110         log_warn("SDL error: %s\n", SDL_GetError());
 111     }
 112     game->cursor_x = 0;
 113     game->cursor_y = 0;
 114
 115     game_switch_state(game, GAME_STATE_LEVEL_PICKER);
 116
 117     return game;
 118 }
 119
 120 void destroy_game(Game *game)
 121 {
 122     trace_assert(game);
 123     RETURN_LT0(game->lt);
 124 }
 125
 126 int game_render(const Game *game)
 127 {
 128     trace_assert(game);
 129
 130     switch(game->state) {
 131     case GAME_STATE_LEVEL: {
 132         if (level_render(game->level, &game->camera) < 0) {
 133             return -1;
 134         }
 135
 136         if (game_render_cursor(game) < 0) {
 137             return -1;
 138         }
 139
 140     } break;
 141
 142     case GAME_STATE_LEVEL_PICKER: {
 143         if (level_picker_render(game->level_picker, &game->camera) < 0) {
 144             return -1;
 145         }
 146
 147         if (game_render_cursor(game) < 0) {
 148             return -1;
 149         }
 150     } break;
 151
 152     case GAME_STATE_LEVEL_EDITOR: {
 153         if (level_editor_render(game->level_editor, &game->camera) < 0) {
 154             return -1;
 155         }
 156
 157         if (game_render_cursor(game) < 0) {
 158             return -1;
 159         }
 160     } break;
 161
 162     case GAME_STATE_QUIT: break;
 163     }
 164
 165     return 0;
 166 }
 167
 168 int game_sound(Game *game)
 169 {
 170     switch (game->state) {
 171     case GAME_STATE_LEVEL:
 172         return level_sound(game->level, game->sound_samples);
 173     case GAME_STATE_LEVEL_PICKER:
 174         return 0;
 175     case GAME_STATE_LEVEL_EDITOR:
 176         level_editor_sound(game->level_editor, game->sound_samples);
 177         return 0;
 178     case GAME_STATE_QUIT:
 179         return 0;
 180     }
 181
 182     return 0;
 183 }
 184
 185 int game_update(Game *game, float delta_time)
 186 {
 187     trace_assert(game);
 188     trace_assert(delta_time > 0.0f);
 189
 190     switch (game->state) {
 191     case GAME_STATE_LEVEL: {
 192         if (level_update(game->level, delta_time) < 0) {
 193             return -1;
 194         }
 195
 196         if (level_enter_camera_event(game->level, &game->camera) < 0) {
 197             return -1;
 198         }
 199
 200     } break;
 201
 202     case GAME_STATE_LEVEL_PICKER: {
 203         if (level_picker_update(game->level_picker, delta_time) < 0) {
 204             return -1;
 205         }
 206
 207         if (level_picker_enter_camera_event(game->level_picker, &game->camera) < 0) {
 208             return -1;
 209         }
 210
 211         const char *level_filename = level_picker_selected_level(game->level_picker);
 212
 213         if (level_filename != NULL) {
 214             if (game->level_editor == NULL) {
 215                 game->level_editor = PUSH_LT(
 216                     game->lt,
 217                     create_level_editor_from_file(level_filename),
 218                     destroy_level_editor);
 219             } else {
 220                 game->level_editor = RESET_LT(
 221                     game->lt,
 222                     game->level_editor,
 223                     create_level_editor_from_file(level_filename));
 224             }
 225
 226             if (game->level_editor == NULL) {
 227                 return -1;
 228             }
 229
 230             if (game->level == NULL) {
 231                 game->level = PUSH_LT(
 232                     game->lt,
 233                     create_level_from_level_editor(
 234                         game->level_editor),
 235                     destroy_level);
 236             } else {
 237                 game->level = RESET_LT(
 238                     game->lt,
 239                     game->level,
 240                     create_level_from_level_editor(
 241                         game->level_editor));
 242             }
 243
 244             if (game->level == NULL) {
 245                 return -1;
 246             }
 247
 248             //TODO(#1071): Move level picker volume update to a more appropriate place
 249             sound_samples_update_volume(game->sound_samples, level_picker_get_volume(game->level_picker));
 250             game_switch_state(game, GAME_STATE_LEVEL);
 251         }
 252
 253     } break;
 254
 255     case GAME_STATE_LEVEL_EDITOR: {
 256         if (level_editor_focus_camera(
 257                 game->level_editor,
 258                 &game->camera) < 0) {
 259             return -1;
 260         }
 261
 262         level_editor_update(game->level_editor, delta_time);
 263     } break;
 264
 265     case GAME_STATE_QUIT:
 266         break;
 267     }
 268
 269     return 0;
 270 }
 271
 272 static int game_event_running(Game *game, const SDL_Event *event)
 273 {
 274     trace_assert(game);
 275     trace_assert(event);
 276
 277     if (!SDL_IsTextInputActive()) {
 278         switch (event->type) {
 279         case SDL_KEYDOWN: {
 280             switch (event->key.keysym.sym) {
 281             case SDLK_r: {
 282                 game->level = RESET_LT(
 283                     game->lt,
 284                     game->level,
 285                     create_level_from_level_editor(
 286                         game->level_editor));
 287                 if (game->level == NULL) {
 288                     game_switch_state(game, GAME_STATE_QUIT);
 289                     return -1;
 290                 }
 291
 292                 camera_disable_debug_mode(&game->camera);
 293             } break;
 294
 295             case SDLK_TAB: {
 296                 game_switch_state(game, GAME_STATE_LEVEL_EDITOR);
 297             } break;
 298             }
 299         } break;
 300         }
 301     }
 302
 303     return level_event(game->level, event, &game->camera, game->sound_samples);
 304 }
 305
 306 static int game_event_level_picker(Game *game, const SDL_Event *event)
 307 {
 308     trace_assert(game);
 309     trace_assert(event);
 310
 311     switch (event->type) {
 312     case SDL_KEYDOWN: {
 313         switch(event->key.keysym.sym) {
 314         case SDLK_n: {
 315             if (game->level_editor == NULL) {
 316                 game->level_editor = PUSH_LT(
 317                     game->lt,
 318                     create_level_editor(),
 319                     destroy_level_editor);
 320             } else {
 321                 game->level_editor = RESET_LT(
 322                     game->lt,
 323                     game->level_editor,
 324                     create_level_editor());
 325             }
 326
 327             if (game->level_editor == NULL) {
 328                 return -1;
 329             }
 330
 331             if (game->level == NULL) {
 332                 game->level = PUSH_LT(
 333                     game->lt,
 334                     create_level_from_level_editor(
 335                         game->level_editor),
 336                     destroy_level);
 337             } else {
 338                 game->level = RESET_LT(
 339                     game->lt,
 340                     game->level,
 341                     create_level_from_level_editor(
 342                         game->level_editor));
 343             }
 344
 345             if (game->level == NULL) {
 346                 return -1;
 347             }
 348
 349             game_switch_state(game, GAME_STATE_LEVEL);
 350         } break;
 351         }
 352     } break;
 353     }
 354
 355     return level_picker_event(game->level_picker, event, &game->camera);
 356 }
 357
 358 static int game_event_level_editor(Game *game, const SDL_Event *event)
 359 {
 360     trace_assert(game);
 361     trace_assert(event);
 362
 363     switch (event->type) {
 364     case SDL_KEYDOWN: {
 365         switch (event->key.keysym.sym) {
 366         case SDLK_TAB: {
 367             game->level = RESET_LT(
 368                 game->lt,
 369                 game->level,
 370                 create_level_from_level_editor(
 371                     game->level_editor));
 372             if (game->level == NULL) {
 373                 return -1;
 374             }
 375             game_switch_state(game, GAME_STATE_LEVEL);
 376         } break;
 377         }
 378     } break;
 379     }
 380
 381     return level_editor_event(game->level_editor, event, &game->camera);
 382 }
 383
 384 int game_event(Game *game, const SDL_Event *event)
 385 {
 386     trace_assert(game);
 387     trace_assert(event);
 388
 389     switch (event->type) {
 390     case SDL_QUIT: {
 391         game_switch_state(game, GAME_STATE_QUIT);
 392         return 0;
 393     } break;
 394
 395     case SDL_MOUSEMOTION: {
 396         game->cursor_x = event->motion.x;
 397         game->cursor_y = event->motion.y;
 398     } break;
 399
 400     case SDL_KEYDOWN: {
 401         if (event->key.keysym.sym == SDLK_q && event->key.keysym.mod & KMOD_CTRL) {
 402             game_switch_state(game, GAME_STATE_QUIT);
 403             return 0;
 404         }
 405     } break;
 406     }
 407
 408     switch (game->state) {
 409     case GAME_STATE_LEVEL:
 410         return game_event_running(game, event);
 411
 412     case GAME_STATE_LEVEL_PICKER:
 413         return game_event_level_picker(game, event);
 414
 415     case GAME_STATE_LEVEL_EDITOR:
 416         return game_event_level_editor(game, event);
 417
 418     case GAME_STATE_QUIT:
 419         return 0;
 420     }
 421
 422     return -1;
 423 }
 424
 425
 426 int game_input(Game *game,
 427                const Uint8 *const keyboard_state,
 428                SDL_Joystick *the_stick_of_joy)
 429 {
 430     trace_assert(game);
 431     trace_assert(keyboard_state);
 432
 433     switch (game->state) {
 434     case GAME_STATE_QUIT:
 435     case GAME_STATE_LEVEL_EDITOR:
 436         return 0;
 437
 438     case GAME_STATE_LEVEL:
 439         return level_input(game->level, keyboard_state, the_stick_of_joy);
 440
 441     case GAME_STATE_LEVEL_PICKER:
 442         return level_picker_input(game->level_picker, keyboard_state, the_stick_of_joy);
 443     }
 444
 445     return 0;
 446 }
 447
 448 int game_over_check(const Game *game)
 449 {
 450     return game->state == GAME_STATE_QUIT;
 451 }
 452
 453 // Private Functions
 454
 455 static int game_render_cursor(const Game *game)
 456 {
 457     trace_assert(game);
 458
 459     SDL_Rect src = {0, 0, 32, 32};
 460     SDL_Rect dest = {game->cursor_x, game->cursor_y, 32, 32};
 461     if (SDL_RenderCopy(game->renderer, game->texture_cursor, &src, &dest) < 0) {
 462         return -1;
 463     }
 464
 465     return 0;
 466 }