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