src/game/level.c

   1 #include <SDL2/SDL.h>
   2 #include "system/stacktrace.h"
   3
   4 #include "broadcast.h"
   5 #include "color.h"
   6 #include "ebisp/builtins.h"
   7 #include "ebisp/interpreter.h"
   8 #include "game/camera.h"
   9 #include "game/level.h"
  10 #include "game/level/background.h"
  11 #include "game/level/boxes.h"
  12 #include "game/level/goals.h"
  13 #include "game/level/labels.h"
  14 #include "game/level/lava.h"
  15 #include "game/level/physical_world.h"
  16 #include "game/level/platforms.h"
  17 #include "game/level/player.h"
  18 #include "game/level/regions.h"
  19 #include "game/level/rigid_bodies.h"
  20 #include "system/line_stream.h"
  21 #include "system/lt.h"
  22 #include "system/lt/lt_adapters.h"
  23 #include "system/nth_alloc.h"
  24
  25 #define LEVEL_LINE_MAX_LENGTH 512
  26 #define LEVEL_GRAVITY 1500.0f
  27
  28 struct Level
  29 {
  30     Lt *lt;
  31
  32     Background *background;
  33     Player *player;
  34     Platforms *platforms;
  35     Goals *goals;
  36     Lava *lava;
  37     Platforms *back_platforms;
  38     Boxes *boxes;
  39     Labels *labels;
  40     Regions *regions;
  41     Physical_world *physical_world;
  42     RigidBodies *rigid_bodies;
  43
  44     bool flying_mode;
  45     Vec flying_camera_position;
  46     float flying_camera_scale;
  47 };
  48
  49 Level *create_level_from_file(const char *file_name, Broadcast *broadcast)
  50 {
  51     trace_assert(file_name);
  52
  53     Lt *const lt = create_lt();
  54     if (lt == NULL) {
  55         return NULL;
  56     }
  57
  58     Level *const level = PUSH_LT(lt, nth_alloc(sizeof(Level)), free);
  59     if (level == NULL) {
  60         RETURN_LT(lt, NULL);
  61     }
  62
  63     LineStream *level_stream = PUSH_LT(
  64         lt,
  65         create_line_stream(
  66             file_name,
  67             "r",
  68             LEVEL_LINE_MAX_LENGTH),
  69         destroy_line_stream);
  70     if (level_stream == NULL) {
  71         RETURN_LT(lt, NULL);
  72     }
  73     level->background = PUSH_LT(
  74         lt,
  75         create_background_from_line_stream(level_stream),
  76         destroy_background);
  77     if (level->background == NULL) {
  78         RETURN_LT(lt, NULL);
  79     }
  80
  81     level->player = PUSH_LT(
  82         lt,
  83         create_player_from_line_stream(level_stream, broadcast),
  84         destroy_player);
  85     if (level->player == NULL) {
  86         RETURN_LT(lt, NULL);
  87     }
  88
  89     level->platforms = PUSH_LT(
  90         lt,
  91         create_platforms_from_line_stream(level_stream),
  92         destroy_platforms);
  93     if (level->platforms == NULL) {
  94         RETURN_LT(lt, NULL);
  95     }
  96
  97     level->goals = PUSH_LT(
  98         lt,
  99         create_goals_from_line_stream(level_stream),
 100         destroy_goals);
 101     if (level->goals == NULL) {
 102         RETURN_LT(lt, NULL);
 103     }
 104
 105     level->lava = PUSH_LT(
 106         lt,
 107         create_lava_from_line_stream(level_stream),
 108         destroy_lava);
 109     if (level->lava == NULL) {
 110         RETURN_LT(lt, NULL);
 111     }
 112
 113     level->back_platforms = PUSH_LT(
 114         lt,
 115         create_platforms_from_line_stream(level_stream),
 116         destroy_platforms);
 117     if (level->back_platforms == NULL) {
 118         RETURN_LT(lt, NULL);
 119     }
 120
 121     level->boxes = PUSH_LT(
 122         lt,
 123         create_boxes_from_line_stream(level_stream),
 124         destroy_boxes);
 125     if (level->boxes == NULL) {
 126         RETURN_LT(lt, NULL);
 127     }
 128
 129     level->labels = PUSH_LT(
 130         lt,
 131         create_labels_from_line_stream(level_stream),
 132         destroy_labels);
 133     if (level->labels == NULL) {
 134         RETURN_LT(lt, NULL);
 135     }
 136
 137     level->regions = PUSH_LT(
 138         lt,
 139         create_regions_from_line_stream(level_stream, broadcast),
 140         destroy_regions);
 141     if (level->regions == NULL) {
 142         RETURN_LT(lt, NULL);
 143     }
 144
 145     level->physical_world = PUSH_LT(lt, create_physical_world(), destroy_physical_world);
 146     if (level->physical_world == NULL) {
 147         RETURN_LT(lt, NULL);
 148     }
 149     if (physical_world_add_solid(
 150             level->physical_world,
 151             player_as_solid(level->player)) < 0) { RETURN_LT(lt, NULL); }
 152     if (boxes_add_to_physical_world(
 153             level->boxes,
 154             level->physical_world) < 0) { RETURN_LT(lt, NULL); }
 155
 156     level->rigid_bodies = PUSH_LT(lt, create_rigid_bodies(1024), destroy_rigid_bodies);
 157     if (level->rigid_bodies == NULL) {
 158         RETURN_LT(lt, NULL);
 159     }
 160
 161     level->flying_mode = false;
 162     level->flying_camera_position = vec(0.0f, 0.0f);
 163     level->flying_camera_scale = 1.0f;
 164
 165     level->lt = lt;
 166
 167     destroy_line_stream(RELEASE_LT(lt, level_stream));
 168
 169     return level;
 170 }
 171
 172 void destroy_level(Level *level)
 173 {
 174     trace_assert(level);
 175     RETURN_LT0(level->lt);
 176 }
 177
 178 int level_render(const Level *level, Camera *camera)
 179 {
 180     trace_assert(level);
 181
 182     if (background_render(level->background, camera) < 0) {
 183         return -1;
 184     }
 185
 186     if (platforms_render(level->back_platforms, camera) < 0) {
 187         return -1;
 188     }
 189
 190     if (player_render(level->player, camera) < 0) {
 191         return -1;
 192     }
 193
 194     if (boxes_render(level->boxes, camera) < 0) {
 195         return -1;
 196     }
 197
 198     if (lava_render(level->lava, camera) < 0) {
 199         return -1;
 200     }
 201
 202     if (platforms_render(level->platforms, camera) < 0) {
 203         return -1;
 204     }
 205
 206     if (goals_render(level->goals, camera) < 0) {
 207         return -1;
 208     }
 209
 210     if (labels_render(level->labels, camera) < 0) {
 211         return -1;
 212     }
 213
 214     if (regions_render(level->regions, camera) < 0) {
 215         return -1;
 216     }
 217
 218     if (rigid_bodies_render(level->rigid_bodies, camera) < 0) {
 219         return -1;
 220     }
 221
 222     return 0;
 223 }
 224
 225 int level_update(Level *level, float delta_time)
 226 {
 227     trace_assert(level);
 228     trace_assert(delta_time > 0);
 229
 230     physical_world_apply_gravity(level->physical_world);
 231     boxes_float_in_lava(level->boxes, level->lava);
 232     rigid_bodies_apply_omniforce(level->rigid_bodies, vec(0.0f, LEVEL_GRAVITY));
 233
 234     rigid_bodies_update(level->rigid_bodies, delta_time);
 235     boxes_update(level->boxes, delta_time);
 236     player_update(level->player, delta_time);
 237
 238     rigid_bodies_collide(level->rigid_bodies, level->platforms);
 239     physical_world_collide_solids(level->physical_world, level->platforms);
 240
 241     player_hide_goals(level->player, level->goals);
 242     player_die_from_lava(level->player, level->lava);
 243     regions_player_enter(level->regions, level->player);
 244     regions_player_leave(level->regions, level->player);
 245
 246     goals_update(level->goals, delta_time);
 247     lava_update(level->lava, delta_time);
 248     labels_update(level->labels, delta_time);
 249
 250     return 0;
 251 }
 252
 253 int level_event(Level *level, const SDL_Event *event)
 254 {
 255     trace_assert(level);
 256     trace_assert(event);
 257
 258     switch (event->type) {
 259     case SDL_KEYDOWN:
 260         switch (event->key.keysym.sym) {
 261         case SDLK_SPACE:
 262             player_jump(level->player);
 263             break;
 264         }
 265         break;
 266
 267     case SDL_JOYBUTTONDOWN:
 268         if (event->jbutton.button == 1) {
 269             player_jump(level->player);
 270         }
 271         break;
 272
 273     case SDL_MOUSEMOTION:
 274         if (level->flying_mode) {
 275             vec_add(&level->flying_camera_position,
 276                     vec((float) event->motion.xrel, (float) event->motion.yrel));
 277         }
 278         break;
 279
 280     case SDL_MOUSEWHEEL:
 281         if (level->flying_mode) {
 282             // TODO: zooming in flying mode is not smooth enough
 283             if (event->wheel.y > 0) {
 284                 level->flying_camera_scale += 0.1f;
 285             } else if (event->wheel.y < 0) {
 286                 level->flying_camera_scale = fmaxf(0.1f, level->flying_camera_scale - 0.1f);
 287             }
 288         }
 289         break;
 290     }
 291
 292     return 0;
 293 }
 294
 295 int level_input(Level *level,
 296                 const Uint8 *const keyboard_state,
 297                 SDL_Joystick *the_stick_of_joy)
 298 {
 299     trace_assert(level);
 300     trace_assert(keyboard_state);
 301     (void) the_stick_of_joy;
 302
 303     if (keyboard_state[SDL_SCANCODE_A]) {
 304         player_move_left(level->player);
 305     } else if (keyboard_state[SDL_SCANCODE_D]) {
 306         player_move_right(level->player);
 307     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) < 0) {
 308         player_move_left(level->player);
 309     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) > 0) {
 310         player_move_right(level->player);
 311     } else {
 312         player_stop(level->player);
 313     }
 314
 315     return 0;
 316 }
 317
 318 int level_reload_preserve_player(Level *level, const char *file_name, Broadcast *broadcast)
 319 {
 320     Lt * const lt = create_lt();
 321     if (lt == NULL) {
 322         return -1;
 323     }
 324
 325     /* TODO(#104): duplicate code in create_level_from_file and level_reload_preserve_player */
 326
 327     LineStream * const level_stream = PUSH_LT(
 328         lt,
 329         create_line_stream(
 330             file_name,
 331             "r",
 332             LEVEL_LINE_MAX_LENGTH),
 333         destroy_line_stream);
 334     if (level_stream == NULL) {
 335         RETURN_LT(lt, -1);
 336     }
 337
 338     Background * const background = create_background_from_line_stream(level_stream);
 339     if (background == NULL) {
 340         RETURN_LT(lt, -1);
 341     }
 342     level->background = RESET_LT(level->lt, level->background, background);
 343
 344     Player * const skipped_player = create_player_from_line_stream(level_stream, broadcast);
 345     if (skipped_player == NULL) {
 346         RETURN_LT(lt, -1);
 347     }
 348     destroy_player(skipped_player);
 349
 350     Platforms * const platforms = create_platforms_from_line_stream(level_stream);
 351     if (platforms == NULL) {
 352         RETURN_LT(lt, -1);
 353     }
 354     level->platforms = RESET_LT(level->lt, level->platforms, platforms);
 355
 356     Goals * const goals = create_goals_from_line_stream(level_stream);
 357     if (goals == NULL) {
 358         RETURN_LT(lt, -1);
 359     }
 360     level->goals = RESET_LT(level->lt, level->goals, goals);
 361
 362     Lava * const lava = create_lava_from_line_stream(level_stream);
 363     if (lava == NULL) {
 364         RETURN_LT(lt, -1);
 365     }
 366     level->lava = RESET_LT(level->lt, level->lava, lava);
 367
 368     Platforms * const back_platforms = create_platforms_from_line_stream(level_stream);
 369     if (back_platforms == NULL) {
 370         RETURN_LT(lt, -1);
 371     }
 372     level->back_platforms = RESET_LT(level->lt, level->back_platforms, back_platforms);
 373
 374     Boxes * const boxes = create_boxes_from_line_stream(level_stream);
 375     if (boxes == NULL) {
 376         RETURN_LT(lt, -1);
 377     }
 378     level->boxes = RESET_LT(level->lt, level->boxes, boxes);
 379
 380     Labels * const labels = create_labels_from_line_stream(level_stream);
 381     if (labels == NULL) {
 382         RETURN_LT(lt, -1);
 383     }
 384     level->labels = RESET_LT(level->lt, level->labels, labels);
 385
 386     Regions * const regions = create_regions_from_line_stream(level_stream, broadcast);
 387     if (regions == NULL) {
 388         RETURN_LT(lt, -1);
 389     }
 390     level->regions = RESET_LT(level->lt, level->regions, regions);
 391
 392     physical_world_clean(level->physical_world);
 393     if (physical_world_add_solid(
 394             level->physical_world,
 395             player_as_solid(level->player)) < 0) { RETURN_LT(lt, -1); }
 396     if (boxes_add_to_physical_world(
 397             level->boxes,
 398             level->physical_world) < 0) { RETURN_LT(lt, -1); }
 399
 400     RETURN_LT(lt, 0);
 401 }
 402
 403 int level_sound(Level *level, Sound_samples *sound_samples)
 404 {
 405     if (goals_sound(level->goals, sound_samples) < 0) {
 406         return -1;
 407     }
 408
 409     if (player_sound(level->player, sound_samples) < 0) {
 410         return -1;
 411     }
 412
 413     return 0;
 414 }
 415
 416 void level_toggle_debug_mode(Level *level)
 417 {
 418     background_toggle_debug_mode(level->background);
 419 }
 420
 421 int level_enter_camera_event(Level *level, Camera *camera)
 422 {
 423     if (!level->flying_mode) {
 424         player_focus_camera(level->player, camera);
 425         camera_scale(camera, 1.0f);
 426     } else {
 427         camera_center_at(camera, level->flying_camera_position);
 428         camera_scale(camera, level->flying_camera_scale);
 429     }
 430
 431     goals_cue(level->goals, camera);
 432     goals_checkpoint(level->goals, level->player);
 433     labels_enter_camera_event(level->labels, camera);
 434     return 0;
 435 }
 436
 437 Rigid_rect *level_rigid_rect(Level *level,
 438                              const char *rigid_rect_id)
 439 {
 440     trace_assert(level);
 441     trace_assert(rigid_rect_id);
 442
 443     Rigid_rect *rigid_rect = player_rigid_rect(level->player,
 444                                                rigid_rect_id);
 445     if (rigid_rect != NULL) {
 446         return rigid_rect;
 447     }
 448
 449     rigid_rect = boxes_rigid_rect(level->boxes, rigid_rect_id);
 450     if (rigid_rect != NULL) {
 451         return rigid_rect;
 452     }
 453
 454     return NULL;
 455 }
 456
 457 struct EvalResult level_send(Level *level, Gc *gc, struct Scope *scope, struct Expr path)
 458 {
 459     trace_assert(level);
 460     trace_assert(gc);
 461     trace_assert(scope);
 462
 463     const char *target = NULL;
 464     struct Expr rest = void_expr();
 465     struct EvalResult res = match_list(gc, "q*", path, &target, &rest);
 466     if (res.is_error) {
 467         return res;
 468     }
 469
 470     if (strcmp(target, "goal") == 0) {
 471         return goals_send(level->goals, gc, scope, rest);
 472     } else if (strcmp(target, "label") == 0) {
 473         return labels_send(level->labels, gc, scope, rest);
 474     } else if (strcmp(target, "box") == 0) {
 475         return boxes_send(level->boxes, gc, scope, rest);
 476     } else if (strcmp(target, "body-push") == 0) {
 477         long int id = 0, x = 0, y = 0;
 478         res = match_list(gc, "ddd", rest, &id, &x, &y);
 479         if (res.is_error) {
 480             return res;
 481         }
 482
 483         rigid_bodies_apply_force(level->rigid_bodies, (size_t) id, vec((float) x, (float) y));
 484
 485         return eval_success(NIL(gc));
 486     } else if (strcmp(target, "body-add") == 0) {
 487         long int x = 0, y = 0, w = 0, h = 0;
 488         const char *color = 0;
 489         res = match_list(gc, "dddds", rest, &x, &y, &w, &h, &color);
 490         if (res.is_error) {
 491             return res;
 492         }
 493
 494         return eval_success(
 495             NUMBER(
 496                 gc,
 497                 (long int) rigid_bodies_add(
 498                     level->rigid_bodies,
 499                     rect((float)x, (float)y, (float)w, (float)h),
 500                     hexstr(color))));
 501     } else if (strcmp(target, "fly") == 0) {
 502         level->flying_mode = !level->flying_mode;
 503         SDL_SetRelativeMouseMode(level->flying_mode);
 504         return eval_success(NIL(gc));
 505     }
 506
 507     return unknown_target(gc, "level", target);
 508 }