src/game/level.c

   1 #include <SDL.h>
   2 #include "system/stacktrace.h"
   3
   4 #include "color.h"
   5 #include "game/camera.h"
   6 #include "game/level.h"
   7 #include "game/level/background.h"
   8 #include "game/level/boxes.h"
   9 #include "game/level/goals.h"
  10 #include "game/level/labels.h"
  11 #include "game/level/lava.h"
  12 #include "game/level/platforms.h"
  13 #include "game/level/player.h"
  14 #include "game/level/regions.h"
  15 #include "game/level/rigid_bodies.h"
  16 #include "game/level/level_editor/rect_layer.h"
  17 #include "game/level/level_editor/point_layer.h"
  18 #include "game/level/level_editor/player_layer.h"
  19 #include "game/level/level_editor/label_layer.h"
  20 #include "game/level/level_editor/background_layer.h"
  21 #include "system/log.h"
  22 #include "system/lt.h"
  23 #include "system/nth_alloc.h"
  24 #include "system/str.h"
  25 #include "game/level/level_editor.h"
  26 #include "ui/console.h"
  27
  28 #define LEVEL_GRAVITY 1500.0f
  29 #define JOYSTICK_THRESHOLD 1000
  30
  31 typedef enum {
  32     LEVEL_STATE_IDLE = 0,
  33     LEVEL_STATE_PAUSE
  34 } LevelState;
  35
  36 struct Level
  37 {
  38     Lt *lt;
  39
  40     LevelState state;
  41     Background background;
  42     RigidBodies *rigid_bodies;
  43     Player *player;
  44     Platforms platforms;
  45     Goals *goals;
  46     Lava *lava;
  47     Platforms back_platforms;
  48     Boxes *boxes;
  49     Labels *labels;
  50     Regions *regions;
  51 };
  52
  53 Level *create_level_from_level_editor(const LevelEditor *level_editor)
  54 {
  55     trace_assert(level_editor);
  56
  57     Lt *lt = create_lt();
  58
  59     Level *level = PUSH_LT(
  60         lt,
  61         nth_calloc(1, sizeof(Level)),
  62         free);
  63     if (level == NULL) {
  64         RETURN_LT(lt, NULL);
  65     }
  66     level->lt = lt;
  67
  68     level->background = create_background(
  69         color_picker_rgba(
  70             &level_editor->background_layer.color_picker));
  71
  72     level->rigid_bodies = PUSH_LT(lt, create_rigid_bodies(1024), destroy_rigid_bodies);
  73     if (level->rigid_bodies == NULL) {
  74         RETURN_LT(lt, NULL);
  75     }
  76
  77     level->player = PUSH_LT(
  78         lt,
  79         create_player_from_player_layer(
  80             &level_editor->player_layer,
  81             level->rigid_bodies),
  82         destroy_player);
  83     if (level->player == NULL) {
  84         RETURN_LT(lt, NULL);
  85     }
  86
  87     level->platforms = create_platforms_from_rect_layer(level_editor->platforms_layer);
  88
  89     level->goals = PUSH_LT(
  90         lt,
  91         create_goals_from_point_layer(level_editor->goals_layer),
  92         destroy_goals);
  93     if (level->goals == NULL) {
  94         RETURN_LT(lt, NULL);
  95     }
  96
  97     level->lava = PUSH_LT(
  98         lt,
  99         create_lava_from_rect_layer(level_editor->lava_layer),
 100         destroy_lava);
 101     if (level->lava == NULL) {
 102         RETURN_LT(lt, NULL);
 103     }
 104
 105     level->back_platforms =
 106         create_platforms_from_rect_layer(level_editor->back_platforms_layer);
 107
 108     level->boxes = PUSH_LT(
 109         lt,
 110         create_boxes_from_rect_layer(level_editor->boxes_layer, level->rigid_bodies),
 111         destroy_boxes);
 112     if (level->boxes == NULL) {
 113         RETURN_LT(lt, NULL);
 114     }
 115
 116     level->labels = PUSH_LT(
 117         lt,
 118         create_labels_from_label_layer(level_editor->label_layer),
 119         destroy_labels);
 120     if (level->labels == NULL) {
 121         RETURN_LT(lt, NULL);
 122     }
 123
 124     level->regions = PUSH_LT(
 125         lt,
 126         create_regions_from_rect_layer(
 127             level_editor->regions_layer,
 128             level->labels,
 129             level->goals),
 130         destroy_regions);
 131     if (level->regions == NULL) {
 132         RETURN_LT(lt, NULL);
 133     }
 134
 135     return level;
 136 }
 137
 138 void destroy_level(Level *level)
 139 {
 140     trace_assert(level);
 141     RETURN_LT0(level->lt);
 142 }
 143
 144 int level_render(const Level *level, const Camera *camera)
 145 {
 146     trace_assert(level);
 147
 148     if (background_render(&level->background, camera) < 0) {
 149         return -1;
 150     }
 151
 152     if (platforms_render(&level->back_platforms, camera) < 0) {
 153         return -1;
 154     }
 155
 156     if (player_render(level->player, camera) < 0) {
 157         return -1;
 158     }
 159
 160     if (boxes_render(level->boxes, camera) < 0) {
 161         return -1;
 162     }
 163
 164     if (lava_render(level->lava, camera) < 0) {
 165         return -1;
 166     }
 167
 168     if (platforms_render(&level->platforms, camera) < 0) {
 169         return -1;
 170     }
 171
 172     if (goals_render(level->goals, camera) < 0) {
 173         return -1;
 174     }
 175
 176     if (labels_render(level->labels, camera) < 0) {
 177         return -1;
 178     }
 179
 180     if (regions_render(level->regions, camera) < 0) {
 181         return -1;
 182     }
 183
 184     return 0;
 185 }
 186
 187 int level_update(Level *level, float delta_time)
 188 {
 189     trace_assert(level);
 190     trace_assert(delta_time > 0);
 191
 192     if (level->state == LEVEL_STATE_PAUSE) {
 193         return 0;
 194     }
 195
 196     boxes_float_in_lava(level->boxes, level->lava);
 197     rigid_bodies_apply_omniforce(level->rigid_bodies, vec(0.0f, LEVEL_GRAVITY));
 198
 199     boxes_update(level->boxes, delta_time);
 200     player_update(level->player, delta_time);
 201
 202     rigid_bodies_collide(level->rigid_bodies, &level->platforms);
 203
 204     player_die_from_lava(level->player, level->lava);
 205     regions_player_enter(level->regions, level->player);
 206     regions_player_leave(level->regions, level->player);
 207
 208     goals_update(level->goals, delta_time);
 209     lava_update(level->lava, delta_time);
 210     labels_update(level->labels, delta_time);
 211
 212     return 0;
 213 }
 214
 215 static
 216 int level_event_idle(Level *level, const SDL_Event *event,
 217                      Camera *camera, Sound_samples *sound_samples)
 218 {
 219     trace_assert(level);
 220
 221     switch (event->type) {
 222     case SDL_KEYDOWN:
 223         switch (event->key.keysym.sym) {
 224         case SDLK_w:
 225         case SDLK_UP:
 226         case SDLK_SPACE: {
 227             player_jump(level->player);
 228         } break;
 229
 230         case SDLK_p: {
 231             level->state = LEVEL_STATE_PAUSE;
 232             camera->blackwhite_mode = true;
 233             sound_samples_toggle_pause(sound_samples);
 234         } break;
 235
 236         case SDLK_l: {
 237             camera_toggle_debug_mode(camera);
 238         } break;
 239         }
 240         break;
 241
 242     case SDL_JOYBUTTONDOWN:
 243         if (event->jbutton.button == 1) {
 244             player_jump(level->player);
 245         }
 246         break;
 247     }
 248
 249     return 0;
 250 }
 251
 252 static
 253 int level_event_pause(Level *level, const SDL_Event *event,
 254                       Camera *camera, Sound_samples *sound_samples)
 255 {
 256     trace_assert(level);
 257
 258     switch (event->type) {
 259     case SDL_KEYDOWN: {
 260         switch (event->key.keysym.sym) {
 261         case SDLK_p: {
 262             level->state = LEVEL_STATE_IDLE;
 263             camera->blackwhite_mode = false;
 264             sound_samples_toggle_pause(sound_samples);
 265         } break;
 266         }
 267     } break;
 268     }
 269
 270     return 0;
 271 }
 272
 273 int level_event(Level *level, const SDL_Event *event,
 274                 Camera *camera, Sound_samples *sound_samples)
 275 {
 276     trace_assert(level);
 277     trace_assert(event);
 278
 279     switch (level->state) {
 280     case LEVEL_STATE_IDLE: {
 281         return level_event_idle(level, event, camera, sound_samples);
 282     } break;
 283
 284     case LEVEL_STATE_PAUSE: {
 285         return level_event_pause(level, event, camera, sound_samples);
 286     } break;
 287     }
 288
 289     return 0;
 290 }
 291
 292 int level_input(Level *level,
 293                 const Uint8 *const keyboard_state,
 294                 SDL_Joystick *the_stick_of_joy)
 295 {
 296     trace_assert(level);
 297     trace_assert(keyboard_state);
 298
 299     if (level->state == LEVEL_STATE_PAUSE) {
 300         return 0;
 301     }
 302
 303     if (keyboard_state[SDL_SCANCODE_A] || keyboard_state[SDL_SCANCODE_LEFT]) {
 304         player_move_left(level->player);
 305     } else if (keyboard_state[SDL_SCANCODE_D] || keyboard_state[SDL_SCANCODE_RIGHT]) {
 306         player_move_right(level->player);
 307     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) < -JOYSTICK_THRESHOLD) {
 308         player_move_left(level->player);
 309     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) > JOYSTICK_THRESHOLD) {
 310         player_move_right(level->player);
 311     } else {
 312         player_stop(level->player);
 313     }
 314
 315     return 0;
 316 }
 317
 318 int level_sound(Level *level, Sound_samples *sound_samples)
 319 {
 320     if (level->state == LEVEL_STATE_PAUSE) {
 321         return 0;
 322     }
 323
 324     if (goals_sound(level->goals, sound_samples) < 0) {
 325         return -1;
 326     }
 327
 328     if (player_sound(level->player, sound_samples) < 0) {
 329         return -1;
 330     }
 331
 332     return 0;
 333 }
 334
 335 int level_enter_camera_event(Level *level, Camera *camera)
 336 {
 337     if (level->state == LEVEL_STATE_PAUSE) {
 338         return 0;
 339     }
 340
 341     player_focus_camera(level->player, camera);
 342     camera_scale(camera, 1.0f);
 343
 344     goals_cue(level->goals, camera);
 345     goals_checkpoint(level->goals, level->player);
 346     labels_enter_camera_event(level->labels, camera);
 347     return 0;
 348 }
 349
 350 void level_disable_pause_mode(Level *level, Camera *camera,
 351                               Sound_samples *sound_samples)
 352 {
 353     trace_assert(level);
 354     trace_assert(camera);
 355     trace_assert(sound_samples);
 356     level->state = LEVEL_STATE_IDLE;
 357     camera->blackwhite_mode = false;
 358     sound_samples_toggle_pause(sound_samples);
 359 }