src/game/level.c

   1 #include <SDL2/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/physical_world.h"
  13 #include "game/level/platforms.h"
  14 #include "game/level/player.h"
  15 #include "game/level/regions.h"
  16 #include "system/line_stream.h"
  17 #include "system/lt.h"
  18 #include "system/lt/lt_adapters.h"
  19 #include "system/nth_alloc.h"
  20
  21 #define LEVEL_LINE_MAX_LENGTH 512
  22
  23 struct Level
  24 {
  25     Lt *lt;
  26
  27     Physical_world *physical_world;
  28     Player *player;
  29     Platforms *platforms;
  30     Goals *goals;
  31     Lava *lava;
  32     Platforms *back_platforms;
  33     Background *background;
  34     Boxes *boxes;
  35     Labels *labels;
  36     Regions *regions;
  37 };
  38
  39 Level *create_level_from_file(const char *file_name)
  40 {
  41     trace_assert(file_name);
  42
  43     Lt *const lt = create_lt();
  44     if (lt == NULL) {
  45         return NULL;
  46     }
  47
  48     Level *const level = PUSH_LT(lt, nth_alloc(sizeof(Level)), free);
  49     if (level == NULL) {
  50         RETURN_LT(lt, NULL);
  51     }
  52
  53     LineStream *level_stream = PUSH_LT(
  54         lt,
  55         create_line_stream(
  56             file_name,
  57             "r",
  58             LEVEL_LINE_MAX_LENGTH),
  59         destroy_line_stream);
  60     if (level_stream == NULL) {
  61         RETURN_LT(lt, NULL);
  62     }
  63     level->background = PUSH_LT(
  64         lt,
  65         create_background_from_line_stream(level_stream),
  66         destroy_background);
  67     if (level->background == NULL) {
  68         RETURN_LT(lt, NULL);
  69     }
  70
  71     level->player = PUSH_LT(
  72         lt,
  73         create_player_from_line_stream(level_stream, level),
  74         destroy_player);
  75     if (level->player == NULL) {
  76         RETURN_LT(lt, NULL);
  77     }
  78
  79     level->platforms = PUSH_LT(
  80         lt,
  81         create_platforms_from_line_stream(level_stream),
  82         destroy_platforms);
  83     if (level->platforms == NULL) {
  84         RETURN_LT(lt, NULL);
  85     }
  86
  87     level->goals = PUSH_LT(
  88         lt,
  89         create_goals_from_line_stream(level_stream),
  90         destroy_goals);
  91     if (level->goals == NULL) {
  92         RETURN_LT(lt, NULL);
  93     }
  94
  95     level->lava = PUSH_LT(
  96         lt,
  97         create_lava_from_line_stream(level_stream),
  98         destroy_lava);
  99     if (level->lava == NULL) {
 100         RETURN_LT(lt, NULL);
 101     }
 102
 103     level->back_platforms = PUSH_LT(
 104         lt,
 105         create_platforms_from_line_stream(level_stream),
 106         destroy_platforms);
 107     if (level->back_platforms == NULL) {
 108         RETURN_LT(lt, NULL);
 109     }
 110
 111     level->boxes = PUSH_LT(
 112         lt,
 113         create_boxes_from_line_stream(level_stream),
 114         destroy_boxes);
 115     if (level->boxes == NULL) {
 116         RETURN_LT(lt, NULL);
 117     }
 118
 119     level->labels = PUSH_LT(
 120         lt,
 121         create_labels_from_line_stream(level_stream),
 122         destroy_labels);
 123     if (level->labels == NULL) {
 124         RETURN_LT(lt, NULL);
 125     }
 126
 127     level->regions = PUSH_LT(
 128         lt,
 129         create_regions_from_line_stream(level_stream, level),
 130         destroy_regions);
 131     if (level->regions == NULL) {
 132         RETURN_LT(lt, NULL);
 133     }
 134
 135     level->physical_world = PUSH_LT(lt, create_physical_world(), destroy_physical_world);
 136     if (level->physical_world == NULL) {
 137         RETURN_LT(lt, NULL);
 138     }
 139     if (physical_world_add_solid(
 140             level->physical_world,
 141             player_as_solid(level->player)) < 0) { RETURN_LT(lt, NULL); }
 142     if (boxes_add_to_physical_world(
 143             level->boxes,
 144             level->physical_world) < 0) { RETURN_LT(lt, NULL); }
 145
 146     level->lt = lt;
 147
 148     destroy_line_stream(RELEASE_LT(lt, level_stream));
 149
 150     return level;
 151 }
 152
 153 void destroy_level(Level *level)
 154 {
 155     trace_assert(level);
 156     RETURN_LT0(level->lt);
 157 }
 158
 159 int level_render(const Level *level, Camera *camera)
 160 {
 161     trace_assert(level);
 162
 163     if (background_render(level->background, camera) < 0) {
 164         return -1;
 165     }
 166
 167     if (platforms_render(level->back_platforms, camera) < 0) {
 168         return -1;
 169     }
 170
 171     if (player_render(level->player, camera) < 0) {
 172         return -1;
 173     }
 174
 175     if (boxes_render(level->boxes, camera) < 0) {
 176         return -1;
 177     }
 178
 179     if (lava_render(level->lava, camera) < 0) {
 180         return -1;
 181     }
 182
 183     if (platforms_render(level->platforms, camera) < 0) {
 184         return -1;
 185     }
 186
 187     if (goals_render(level->goals, camera) < 0) {
 188         return -1;
 189     }
 190
 191     if (labels_render(level->labels, camera) < 0) {
 192         return -1;
 193     }
 194
 195     if (regions_render(level->regions, camera) < 0) {
 196         return -1;
 197     }
 198
 199     return 0;
 200 }
 201
 202 int level_update(Level *level, float delta_time)
 203 {
 204     trace_assert(level);
 205     trace_assert(delta_time > 0);
 206
 207     physical_world_apply_gravity(level->physical_world);
 208     boxes_float_in_lava(level->boxes, level->lava);
 209
 210     boxes_update(level->boxes, delta_time);
 211     player_update(level->player, delta_time);
 212
 213     physical_world_collide_solids(level->physical_world, level->platforms);
 214
 215     player_hide_goals(level->player, level->goals);
 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 int level_event(Level *level, const SDL_Event *event)
 228 {
 229     trace_assert(level);
 230     trace_assert(event);
 231
 232     switch (event->type) {
 233     case SDL_KEYDOWN:
 234         switch (event->key.keysym.sym) {
 235         case SDLK_SPACE:
 236             player_jump(level->player);
 237             break;
 238         }
 239         break;
 240
 241     case SDL_JOYBUTTONDOWN:
 242         if (event->jbutton.button == 1) {
 243             player_jump(level->player);
 244         }
 245         break;
 246     }
 247
 248     return 0;
 249 }
 250
 251 int level_input(Level *level,
 252                 const Uint8 *const keyboard_state,
 253                 SDL_Joystick *the_stick_of_joy)
 254 {
 255     trace_assert(level);
 256     trace_assert(keyboard_state);
 257     (void) the_stick_of_joy;
 258
 259     if (keyboard_state[SDL_SCANCODE_A]) {
 260         player_move_left(level->player);
 261     } else if (keyboard_state[SDL_SCANCODE_D]) {
 262         player_move_right(level->player);
 263     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) < 0) {
 264         player_move_left(level->player);
 265     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) > 0) {
 266         player_move_right(level->player);
 267     } else {
 268         player_stop(level->player);
 269     }
 270
 271     return 0;
 272 }
 273
 274 int level_reload_preserve_player(Level *level, const char *file_name)
 275 {
 276     Lt * const lt = create_lt();
 277     if (lt == NULL) {
 278         return -1;
 279     }
 280
 281     /* TODO(#104): duplicate code in create_level_from_file and level_reload_preserve_player */
 282
 283     LineStream * const level_stream = PUSH_LT(
 284         lt,
 285         create_line_stream(
 286             file_name,
 287             "r",
 288             LEVEL_LINE_MAX_LENGTH),
 289         destroy_line_stream);
 290     if (level_stream == NULL) {
 291         RETURN_LT(lt, -1);
 292     }
 293
 294     Background * const background = create_background_from_line_stream(level_stream);
 295     if (background == NULL) {
 296         RETURN_LT(lt, -1);
 297     }
 298     level->background = RESET_LT(level->lt, level->background, background);
 299
 300     Player * const skipped_player = create_player_from_line_stream(level_stream, level);
 301     if (skipped_player == NULL) {
 302         RETURN_LT(lt, -1);
 303     }
 304     destroy_player(skipped_player);
 305
 306     Platforms * const platforms = create_platforms_from_line_stream(level_stream);
 307     if (platforms == NULL) {
 308         RETURN_LT(lt, -1);
 309     }
 310     level->platforms = RESET_LT(level->lt, level->platforms, platforms);
 311
 312     Goals * const goals = create_goals_from_line_stream(level_stream);
 313     if (goals == NULL) {
 314         RETURN_LT(lt, -1);
 315     }
 316     level->goals = RESET_LT(level->lt, level->goals, goals);
 317
 318     Lava * const lava = create_lava_from_line_stream(level_stream);
 319     if (lava == NULL) {
 320         RETURN_LT(lt, -1);
 321     }
 322     level->lava = RESET_LT(level->lt, level->lava, lava);
 323
 324     Platforms * const back_platforms = create_platforms_from_line_stream(level_stream);
 325     if (back_platforms == NULL) {
 326         RETURN_LT(lt, -1);
 327     }
 328     level->back_platforms = RESET_LT(level->lt, level->back_platforms, back_platforms);
 329
 330     Boxes * const boxes = create_boxes_from_line_stream(level_stream);
 331     if (boxes == NULL) {
 332         RETURN_LT(lt, -1);
 333     }
 334     level->boxes = RESET_LT(level->lt, level->boxes, boxes);
 335
 336     Labels * const labels = create_labels_from_line_stream(level_stream);
 337     if (labels == NULL) {
 338         RETURN_LT(lt, -1);
 339     }
 340     level->labels = RESET_LT(level->lt, level->labels, labels);
 341
 342     Regions * const regions = create_regions_from_line_stream(level_stream, level);
 343     if (regions == NULL) {
 344         RETURN_LT(lt, -1);
 345     }
 346     level->regions = RESET_LT(level->lt, level->regions, regions);
 347
 348     physical_world_clean(level->physical_world);
 349     if (physical_world_add_solid(
 350             level->physical_world,
 351             player_as_solid(level->player)) < 0) { RETURN_LT(lt, -1); }
 352     if (boxes_add_to_physical_world(
 353             level->boxes,
 354             level->physical_world) < 0) { RETURN_LT(lt, -1); }
 355
 356     RETURN_LT(lt, 0);
 357 }
 358
 359 int level_sound(Level *level, Sound_samples *sound_samples)
 360 {
 361     if (goals_sound(level->goals, sound_samples) < 0) {
 362         return -1;
 363     }
 364
 365     if (player_sound(level->player, sound_samples) < 0) {
 366         return -1;
 367     }
 368
 369     return 0;
 370 }
 371
 372 void level_toggle_debug_mode(Level *level)
 373 {
 374     background_toggle_debug_mode(level->background);
 375 }
 376
 377 int level_enter_camera_event(Level *level, Camera *camera)
 378 {
 379     player_focus_camera(level->player, camera);
 380     goals_cue(level->goals, camera);
 381     goals_checkpoint(level->goals, level->player);
 382     labels_enter_camera_event(level->labels, camera);
 383     return 0;
 384 }
 385
 386 Rigid_rect *level_rigid_rect(Level *level,
 387                              const char *rigid_rect_id)
 388 {
 389     trace_assert(level);
 390     trace_assert(rigid_rect_id);
 391
 392     Rigid_rect *rigid_rect = player_rigid_rect(level->player,
 393                                                rigid_rect_id);
 394     if (rigid_rect != NULL) {
 395         return rigid_rect;
 396     }
 397
 398     rigid_rect = boxes_rigid_rect(level->boxes, rigid_rect_id);
 399     if (rigid_rect != NULL) {
 400         return rigid_rect;
 401     }
 402
 403     return NULL;
 404 }
 405
 406 void level_hide_goal(Level *level, const char *goal_id)
 407 {
 408     goals_hide(level->goals, goal_id);
 409 }
 410
 411 void level_show_goal(Level *level, const char *goal_id)
 412 {
 413     goals_show(level->goals, goal_id);
 414 }
 415
 416 void level_hide_label(Level *level, const char *label_id)
 417 {
 418     trace_assert(level);
 419     trace_assert(label_id);
 420
 421     labels_hide(level->labels, label_id);
 422 }