src/game/level.c

   1 #include <SDL2/SDL.h>
   2 #include <assert.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     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),
  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     assert(level);
 156     RETURN_LT0(level->lt);
 157 }
 158
 159 int level_render(const Level *level, Camera *camera)
 160 {
 161     assert(level);
 162
 163     player_focus_camera(level->player, camera);
 164
 165     if (background_render(level->background, camera) < 0) {
 166         return -1;
 167     }
 168
 169     if (platforms_render(level->back_platforms, camera) < 0) {
 170         return -1;
 171     }
 172
 173     if (player_render(level->player, camera) < 0) {
 174         return -1;
 175     }
 176
 177     if (boxes_render(level->boxes, camera) < 0) {
 178         return -1;
 179     }
 180
 181     if (lava_render(level->lava, camera) < 0) {
 182         return -1;
 183     }
 184
 185     if (platforms_render(level->platforms, camera) < 0) {
 186         return -1;
 187     }
 188
 189     if (goals_render(level->goals, camera) < 0) {
 190         return -1;
 191     }
 192
 193     if (labels_render(level->labels, camera) < 0) {
 194         return -1;
 195     }
 196
 197     if (regions_render(level->regions, camera) < 0) {
 198         return -1;
 199     }
 200
 201     return 0;
 202 }
 203
 204 int level_update(Level *level, float delta_time)
 205 {
 206     assert(level);
 207     assert(delta_time > 0);
 208
 209     physical_world_apply_gravity(level->physical_world);
 210     boxes_float_in_lava(level->boxes, level->lava);
 211
 212     boxes_update(level->boxes, delta_time);
 213     player_update(level->player, delta_time);
 214
 215     physical_world_collide_solids(level->physical_world, level->platforms);
 216
 217     player_hide_goals(level->player, level->goals);
 218     player_die_from_lava(level->player, level->lava);
 219     regions_player_enter(level->regions, level->player);
 220     regions_player_leave(level->regions, level->player);
 221
 222     goals_update(level->goals, delta_time);
 223     lava_update(level->lava, delta_time);
 224     labels_update(level->labels, delta_time);
 225
 226     return 0;
 227 }
 228
 229 int level_event(Level *level, const SDL_Event *event)
 230 {
 231     assert(level);
 232     assert(event);
 233
 234     switch (event->type) {
 235     case SDL_KEYDOWN:
 236         switch (event->key.keysym.sym) {
 237         case SDLK_SPACE:
 238             player_jump(level->player);
 239             break;
 240         }
 241         break;
 242
 243     case SDL_JOYBUTTONDOWN:
 244         if (event->jbutton.button == 1) {
 245             player_jump(level->player);
 246         }
 247         break;
 248     }
 249
 250     return 0;
 251 }
 252
 253 int level_input(Level *level,
 254                 const Uint8 *const keyboard_state,
 255                 SDL_Joystick *the_stick_of_joy)
 256 {
 257     assert(level);
 258     assert(keyboard_state);
 259     (void) the_stick_of_joy;
 260
 261     if (keyboard_state[SDL_SCANCODE_A]) {
 262         player_move_left(level->player);
 263     } else if (keyboard_state[SDL_SCANCODE_D]) {
 264         player_move_right(level->player);
 265     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) < 0) {
 266         player_move_left(level->player);
 267     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) > 0) {
 268         player_move_right(level->player);
 269     } else {
 270         player_stop(level->player);
 271     }
 272
 273     return 0;
 274 }
 275
 276 int level_reload_preserve_player(Level *level, const char *file_name)
 277 {
 278     Lt * const lt = create_lt();
 279     if (lt == NULL) {
 280         return -1;
 281     }
 282
 283     /* TODO(#104): duplicate code in create_level_from_file and level_reload_preserve_player */
 284
 285     LineStream * const level_stream = PUSH_LT(
 286         lt,
 287         create_line_stream(
 288             file_name,
 289             "r",
 290             LEVEL_LINE_MAX_LENGTH),
 291         destroy_line_stream);
 292     if (level_stream == NULL) {
 293         RETURN_LT(lt, -1);
 294     }
 295
 296     Background * const background = create_background_from_line_stream(level_stream);
 297     if (background == NULL) {
 298         RETURN_LT(lt, -1);
 299     }
 300     level->background = RESET_LT(level->lt, level->background, background);
 301
 302     Player * const skipped_player = create_player_from_line_stream(level_stream);
 303     if (skipped_player == NULL) {
 304         RETURN_LT(lt, -1);
 305     }
 306     destroy_player(skipped_player);
 307
 308     Platforms * const platforms = create_platforms_from_line_stream(level_stream);
 309     if (platforms == NULL) {
 310         RETURN_LT(lt, -1);
 311     }
 312     level->platforms = RESET_LT(level->lt, level->platforms, platforms);
 313
 314     Goals * const goals = create_goals_from_line_stream(level_stream);
 315     if (goals == NULL) {
 316         RETURN_LT(lt, -1);
 317     }
 318     level->goals = RESET_LT(level->lt, level->goals, goals);
 319
 320     Lava * const lava = create_lava_from_line_stream(level_stream);
 321     if (lava == NULL) {
 322         RETURN_LT(lt, -1);
 323     }
 324     level->lava = RESET_LT(level->lt, level->lava, lava);
 325
 326     Platforms * const back_platforms = create_platforms_from_line_stream(level_stream);
 327     if (back_platforms == NULL) {
 328         RETURN_LT(lt, -1);
 329     }
 330     level->back_platforms = RESET_LT(level->lt, level->back_platforms, back_platforms);
 331
 332     Boxes * const boxes = create_boxes_from_line_stream(level_stream);
 333     if (boxes == NULL) {
 334         RETURN_LT(lt, -1);
 335     }
 336     level->boxes = RESET_LT(level->lt, level->boxes, boxes);
 337
 338     Labels * const labels = create_labels_from_line_stream(level_stream);
 339     if (labels == NULL) {
 340         RETURN_LT(lt, -1);
 341     }
 342     level->labels = RESET_LT(level->lt, level->labels, labels);
 343
 344     Regions * const regions = create_regions_from_line_stream(level_stream, level);
 345     if (regions == NULL) {
 346         RETURN_LT(lt, -1);
 347     }
 348     level->regions = RESET_LT(level->lt, level->regions, regions);
 349
 350     physical_world_clean(level->physical_world);
 351     if (physical_world_add_solid(
 352             level->physical_world,
 353             player_as_solid(level->player)) < 0) { RETURN_LT(lt, -1); }
 354     if (boxes_add_to_physical_world(
 355             level->boxes,
 356             level->physical_world) < 0) { RETURN_LT(lt, -1); }
 357
 358     RETURN_LT(lt, 0);
 359 }
 360
 361 int level_sound(Level *level, Sound_samples *sound_samples)
 362 {
 363     if (goals_sound(level->goals, sound_samples) < 0) {
 364         return -1;
 365     }
 366
 367     if (player_sound(level->player, sound_samples) < 0) {
 368         return -1;
 369     }
 370
 371     return 0;
 372 }
 373
 374 void level_toggle_debug_mode(Level *level)
 375 {
 376     background_toggle_debug_mode(level->background);
 377 }
 378
 379 int level_enter_camera_event(Level *level,
 380                              const Camera *camera)
 381 {
 382     goals_cue(level->goals, camera);
 383     goals_checkpoint(level->goals, level->player);
 384     labels_enter_camera_event(level->labels, camera);
 385     return 0;
 386 }
 387
 388 Rigid_rect *level_rigid_rect(Level *level,
 389                              const char *rigid_rect_id)
 390 {
 391     assert(level);
 392     assert(rigid_rect_id);
 393
 394     Rigid_rect *rigid_rect = player_rigid_rect(level->player,
 395                                                rigid_rect_id);
 396     if (rigid_rect != NULL) {
 397         return rigid_rect;
 398     }
 399
 400     rigid_rect = boxes_rigid_rect(level->boxes, rigid_rect_id);
 401     if (rigid_rect != NULL) {
 402         return rigid_rect;
 403     }
 404
 405     return NULL;
 406 }
 407
 408 void level_hide_goal(Level *level, const char *goal_id)
 409 {
 410     goals_hide(level->goals, goal_id);
 411 }
 412
 413 void level_show_goal(Level *level, const char *goal_id)
 414 {
 415     goals_show(level->goals, goal_id);
 416 }
 417
 418 long int level_player_jump_count(Level *level)
 419 {
 420     assert(level);
 421     return player_jump_count(level->player);
 422 }
 423
 424 void level_hide_label(Level *level, const char *label_id)
 425 {
 426     assert(level);
 427     assert(label_id);
 428
 429     /* TODO: level_hide_label is not implemented */
 430 }