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