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 = PUSH_LT(
  88         lt,
  89         create_platforms_from_rect_layer(&level_editor->platforms_layer),
  90         destroy_platforms);
  91     if (level->platforms == NULL) {
  92         RETURN_LT(lt, NULL);
  93     }
  94
  95     level->goals = PUSH_LT(
  96         lt,
  97         create_goals_from_point_layer(&level_editor->goals_layer),
  98         destroy_goals);
  99     if (level->goals == NULL) {
 100         RETURN_LT(lt, NULL);
 101     }
 102
 103     level->lava = PUSH_LT(
 104         lt,
 105         create_lava_from_rect_layer(&level_editor->lava_layer),
 106         destroy_lava);
 107     if (level->lava == NULL) {
 108         RETURN_LT(lt, NULL);
 109     }
 110
 111     level->back_platforms = PUSH_LT(
 112         lt,
 113         create_platforms_from_rect_layer(&level_editor->back_platforms_layer),
 114         destroy_platforms);
 115     if (level->back_platforms == NULL) {
 116         RETURN_LT(lt, NULL);
 117     }
 118
 119     level->boxes = PUSH_LT(
 120         lt,
 121         create_boxes_from_rect_layer(&level_editor->boxes_layer, level->rigid_bodies),
 122         destroy_boxes);
 123     if (level->boxes == NULL) {
 124         RETURN_LT(lt, NULL);
 125     }
 126
 127     level->labels = PUSH_LT(
 128         lt,
 129         create_labels_from_label_layer(level_editor->label_layer),
 130         destroy_labels);
 131     if (level->labels == NULL) {
 132         RETURN_LT(lt, NULL);
 133     }
 134
 135     level->regions = PUSH_LT(
 136         lt,
 137         create_regions_from_rect_layer(
 138             &level_editor->regions_layer,
 139             level->labels,
 140             level->goals),
 141         destroy_regions);
 142     if (level->regions == NULL) {
 143         RETURN_LT(lt, NULL);
 144     }
 145
 146     return level;
 147 }
 148
 149 void destroy_level(Level *level)
 150 {
 151     trace_assert(level);
 152     RETURN_LT0(level->lt);
 153 }
 154
 155 int level_render(const Level *level, const Camera *camera)
 156 {
 157     trace_assert(level);
 158
 159     if (background_render(&level->background, camera) < 0) {
 160         return -1;
 161     }
 162
 163     if (platforms_render(level->back_platforms, camera) < 0) {
 164         return -1;
 165     }
 166
 167     if (player_render(level->player, camera) < 0) {
 168         return -1;
 169     }
 170
 171     if (boxes_render(level->boxes, camera) < 0) {
 172         return -1;
 173     }
 174
 175     if (lava_render(level->lava, camera) < 0) {
 176         return -1;
 177     }
 178
 179     if (platforms_render(level->platforms, camera) < 0) {
 180         return -1;
 181     }
 182
 183     if (goals_render(level->goals, camera) < 0) {
 184         return -1;
 185     }
 186
 187     if (labels_render(level->labels, camera) < 0) {
 188         return -1;
 189     }
 190
 191     if (regions_render(level->regions, camera) < 0) {
 192         return -1;
 193     }
 194
 195     return 0;
 196 }
 197
 198 int level_update(Level *level, float delta_time)
 199 {
 200     trace_assert(level);
 201     trace_assert(delta_time > 0);
 202
 203     if (level->state == LEVEL_STATE_PAUSE) {
 204         return 0;
 205     }
 206
 207     boxes_float_in_lava(level->boxes, level->lava);
 208     rigid_bodies_apply_omniforce(level->rigid_bodies, vec(0.0f, LEVEL_GRAVITY));
 209
 210     boxes_update(level->boxes, delta_time);
 211     player_update(level->player, delta_time);
 212
 213     rigid_bodies_collide(level->rigid_bodies, level->platforms);
 214
 215     player_die_from_lava(level->player, level->lava);
 216     regions_player_enter(level->regions, level->player);
 217     regions_player_leave(level->regions, level->player);
 218
 219     goals_update(level->goals, delta_time);
 220     lava_update(level->lava, delta_time);
 221     labels_update(level->labels, delta_time);
 222
 223     return 0;
 224 }
 225
 226 static
 227 int level_event_idle(Level *level, const SDL_Event *event,
 228                      Camera *camera, Sound_samples *sound_samples)
 229 {
 230     trace_assert(level);
 231
 232     switch (event->type) {
 233     case SDL_KEYDOWN:
 234         switch (event->key.keysym.sym) {
 235         case SDLK_w:
 236         case SDLK_UP:
 237         case SDLK_SPACE: {
 238             player_jump(level->player);
 239         } break;
 240
 241         case SDLK_p: {
 242             level->state = LEVEL_STATE_PAUSE;
 243             camera->blackwhite_mode = true;
 244             sound_samples_toggle_pause(sound_samples);
 245         } break;
 246
 247         case SDLK_l: {
 248             camera_toggle_debug_mode(camera);
 249         } break;
 250         }
 251         break;
 252
 253     case SDL_JOYBUTTONDOWN:
 254         if (event->jbutton.button == 1) {
 255             player_jump(level->player);
 256         }
 257         break;
 258     }
 259
 260     return 0;
 261 }
 262
 263 static
 264 int level_event_pause(Level *level, const SDL_Event *event,
 265                       Camera *camera, Sound_samples *sound_samples)
 266 {
 267     trace_assert(level);
 268
 269     switch (event->type) {
 270     case SDL_KEYDOWN: {
 271         switch (event->key.keysym.sym) {
 272         case SDLK_p: {
 273             level->state = LEVEL_STATE_IDLE;
 274             camera->blackwhite_mode = false;
 275             sound_samples_toggle_pause(sound_samples);
 276         } break;
 277         }
 278     } break;
 279     }
 280
 281     return 0;
 282 }
 283
 284 int level_event(Level *level, const SDL_Event *event,
 285                 Camera *camera, Sound_samples *sound_samples)
 286 {
 287     trace_assert(level);
 288     trace_assert(event);
 289
 290     switch (level->state) {
 291     case LEVEL_STATE_IDLE: {
 292         return level_event_idle(level, event, camera, sound_samples);
 293     } break;
 294
 295     case LEVEL_STATE_PAUSE: {
 296         return level_event_pause(level, event, camera, sound_samples);
 297     } break;
 298     }
 299
 300     return 0;
 301 }
 302
 303 int level_input(Level *level,
 304                 const Uint8 *const keyboard_state,
 305                 SDL_Joystick *the_stick_of_joy)
 306 {
 307     trace_assert(level);
 308     trace_assert(keyboard_state);
 309
 310     if (level->state == LEVEL_STATE_PAUSE) {
 311         return 0;
 312     }
 313
 314     if (keyboard_state[SDL_SCANCODE_A] || keyboard_state[SDL_SCANCODE_LEFT]) {
 315         player_move_left(level->player);
 316     } else if (keyboard_state[SDL_SCANCODE_D] || keyboard_state[SDL_SCANCODE_RIGHT]) {
 317         player_move_right(level->player);
 318     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) < -JOYSTICK_THRESHOLD) {
 319         player_move_left(level->player);
 320     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) > JOYSTICK_THRESHOLD) {
 321         player_move_right(level->player);
 322     } else {
 323         player_stop(level->player);
 324     }
 325
 326     return 0;
 327 }
 328
 329 int level_sound(Level *level, Sound_samples *sound_samples)
 330 {
 331     if (level->state == LEVEL_STATE_PAUSE) {
 332         return 0;
 333     }
 334
 335     if (goals_sound(level->goals, sound_samples) < 0) {
 336         return -1;
 337     }
 338
 339     if (player_sound(level->player, sound_samples) < 0) {
 340         return -1;
 341     }
 342
 343     return 0;
 344 }
 345
 346 int level_enter_camera_event(Level *level, Camera *camera)
 347 {
 348     if (level->state == LEVEL_STATE_PAUSE) {
 349         return 0;
 350     }
 351
 352     player_focus_camera(level->player, camera);
 353     camera_scale(camera, 1.0f);
 354
 355     goals_cue(level->goals, camera);
 356     goals_checkpoint(level->goals, level->player);
 357     labels_enter_camera_event(level->labels, camera);
 358     return 0;
 359 }
 360
 361 void level_disable_pause_mode(Level *level, Camera *camera,
 362                               Sound_samples *sound_samples)
 363 {
 364     trace_assert(level);
 365     trace_assert(camera);
 366     trace_assert(sound_samples);
 367     level->state = LEVEL_STATE_IDLE;
 368     camera->blackwhite_mode = false;
 369     sound_samples_toggle_pause(sound_samples);
 370 }