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 #include "ebisp/interpreter.h"
  21 #include "ebisp/builtins.h"
  22
  23 #define LEVEL_LINE_MAX_LENGTH 512
  24
  25 struct Level
  26 {
  27     Lt *lt;
  28
  29     Physical_world *physical_world;
  30     Player *player;
  31     Platforms *platforms;
  32     Goals *goals;
  33     Lava *lava;
  34     Platforms *back_platforms;
  35     Background *background;
  36     Boxes *boxes;
  37     Labels *labels;
  38     Regions *regions;
  39 };
  40
  41 Level *create_level_from_file(const char *file_name, Game *game)
  42 {
  43     trace_assert(file_name);
  44
  45     Lt *const lt = create_lt();
  46     if (lt == NULL) {
  47         return NULL;
  48     }
  49
  50     Level *const level = PUSH_LT(lt, nth_alloc(sizeof(Level)), free);
  51     if (level == NULL) {
  52         RETURN_LT(lt, NULL);
  53     }
  54
  55     LineStream *level_stream = PUSH_LT(
  56         lt,
  57         create_line_stream(
  58             file_name,
  59             "r",
  60             LEVEL_LINE_MAX_LENGTH),
  61         destroy_line_stream);
  62     if (level_stream == NULL) {
  63         RETURN_LT(lt, NULL);
  64     }
  65     level->background = PUSH_LT(
  66         lt,
  67         create_background_from_line_stream(level_stream),
  68         destroy_background);
  69     if (level->background == NULL) {
  70         RETURN_LT(lt, NULL);
  71     }
  72
  73     level->player = PUSH_LT(
  74         lt,
  75         create_player_from_line_stream(level_stream, game),
  76         destroy_player);
  77     if (level->player == NULL) {
  78         RETURN_LT(lt, NULL);
  79     }
  80
  81     level->platforms = PUSH_LT(
  82         lt,
  83         create_platforms_from_line_stream(level_stream),
  84         destroy_platforms);
  85     if (level->platforms == NULL) {
  86         RETURN_LT(lt, NULL);
  87     }
  88
  89     level->goals = PUSH_LT(
  90         lt,
  91         create_goals_from_line_stream(level_stream),
  92         destroy_goals);
  93     if (level->goals == NULL) {
  94         RETURN_LT(lt, NULL);
  95     }
  96
  97     level->lava = PUSH_LT(
  98         lt,
  99         create_lava_from_line_stream(level_stream),
 100         destroy_lava);
 101     if (level->lava == NULL) {
 102         RETURN_LT(lt, NULL);
 103     }
 104
 105     level->back_platforms = PUSH_LT(
 106         lt,
 107         create_platforms_from_line_stream(level_stream),
 108         destroy_platforms);
 109     if (level->back_platforms == NULL) {
 110         RETURN_LT(lt, NULL);
 111     }
 112
 113     level->boxes = PUSH_LT(
 114         lt,
 115         create_boxes_from_line_stream(level_stream),
 116         destroy_boxes);
 117     if (level->boxes == NULL) {
 118         RETURN_LT(lt, NULL);
 119     }
 120
 121     level->labels = PUSH_LT(
 122         lt,
 123         create_labels_from_line_stream(level_stream),
 124         destroy_labels);
 125     if (level->labels == NULL) {
 126         RETURN_LT(lt, NULL);
 127     }
 128
 129     level->regions = PUSH_LT(
 130         lt,
 131         create_regions_from_line_stream(level_stream, game),
 132         destroy_regions);
 133     if (level->regions == NULL) {
 134         RETURN_LT(lt, NULL);
 135     }
 136
 137     level->physical_world = PUSH_LT(lt, create_physical_world(), destroy_physical_world);
 138     if (level->physical_world == NULL) {
 139         RETURN_LT(lt, NULL);
 140     }
 141     if (physical_world_add_solid(
 142             level->physical_world,
 143             player_as_solid(level->player)) < 0) { RETURN_LT(lt, NULL); }
 144     if (boxes_add_to_physical_world(
 145             level->boxes,
 146             level->physical_world) < 0) { RETURN_LT(lt, NULL); }
 147
 148     level->lt = lt;
 149
 150     destroy_line_stream(RELEASE_LT(lt, level_stream));
 151
 152     return level;
 153 }
 154
 155 void destroy_level(Level *level)
 156 {
 157     trace_assert(level);
 158     RETURN_LT0(level->lt);
 159 }
 160
 161 int level_render(const Level *level, Camera *camera)
 162 {
 163     trace_assert(level);
 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     trace_assert(level);
 207     trace_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     trace_assert(level);
 232     trace_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     trace_assert(level);
 258     trace_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, Game *game)
 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, game);
 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, game);
 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, Camera *camera)
 380 {
 381     player_focus_camera(level->player, camera);
 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     trace_assert(level);
 392     trace_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 void level_hide_label(Level *level, const char *label_id)
 419 {
 420     trace_assert(level);
 421     trace_assert(label_id);
 422
 423     labels_hide(level->labels, label_id);
 424 }
 425
 426 static struct EvalResult
 427 unknown_object(Gc *gc, const char *source, const char *target)
 428 {
 429     return eval_failure(
 430         list(gc, "qqq", "unknown-object", source, target));
 431 }
 432
 433 struct EvalResult level_send(Level *level, Gc *gc, struct Scope *scope, struct Expr path)
 434 {
 435     trace_assert(level);
 436     trace_assert(gc);
 437     trace_assert(scope);
 438
 439     const char *target = NULL;
 440     struct EvalResult res = match_list(gc, "q*", path, &target, NULL);
 441     if (res.is_error) {
 442         return res;
 443     }
 444
 445     return unknown_object(gc, "level", target);
 446 }