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 };
  47
  48 Level *create_level_from_file(const char *file_name, Broadcast *broadcast)
  49 {
  50     trace_assert(file_name);
  51
  52     Lt *const lt = create_lt();
  53     if (lt == NULL) {
  54         return NULL;
  55     }
  56
  57     Level *const level = PUSH_LT(lt, nth_alloc(sizeof(Level)), free);
  58     if (level == NULL) {
  59         RETURN_LT(lt, NULL);
  60     }
  61
  62     LineStream *level_stream = PUSH_LT(
  63         lt,
  64         create_line_stream(
  65             file_name,
  66             "r",
  67             LEVEL_LINE_MAX_LENGTH),
  68         destroy_line_stream);
  69     if (level_stream == NULL) {
  70         RETURN_LT(lt, NULL);
  71     }
  72     level->background = PUSH_LT(
  73         lt,
  74         create_background_from_line_stream(level_stream),
  75         destroy_background);
  76     if (level->background == NULL) {
  77         RETURN_LT(lt, NULL);
  78     }
  79
  80     level->player = PUSH_LT(
  81         lt,
  82         create_player_from_line_stream(level_stream, broadcast),
  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_line_stream(level_stream),
  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_line_stream(level_stream),
  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_line_stream(level_stream),
 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_line_stream(level_stream),
 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_line_stream(level_stream),
 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_line_stream(level_stream),
 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_line_stream(level_stream, broadcast),
 139         destroy_regions);
 140     if (level->regions == NULL) {
 141         RETURN_LT(lt, NULL);
 142     }
 143
 144     level->physical_world = PUSH_LT(lt, create_physical_world(), destroy_physical_world);
 145     if (level->physical_world == NULL) {
 146         RETURN_LT(lt, NULL);
 147     }
 148     if (physical_world_add_solid(
 149             level->physical_world,
 150             player_as_solid(level->player)) < 0) { RETURN_LT(lt, NULL); }
 151     if (boxes_add_to_physical_world(
 152             level->boxes,
 153             level->physical_world) < 0) { RETURN_LT(lt, NULL); }
 154
 155     level->rigid_bodies = PUSH_LT(lt, create_rigid_bodies(1024), destroy_rigid_bodies);
 156     if (level->rigid_bodies == NULL) {
 157         RETURN_LT(lt, NULL);
 158     }
 159
 160     level->flying_mode = false;
 161     level->flying_camera_position = vec(0.0f, 0.0f);
 162
 163     level->lt = lt;
 164
 165     destroy_line_stream(RELEASE_LT(lt, level_stream));
 166
 167     return level;
 168 }
 169
 170 void destroy_level(Level *level)
 171 {
 172     trace_assert(level);
 173     RETURN_LT0(level->lt);
 174 }
 175
 176 int level_render(const Level *level, Camera *camera)
 177 {
 178     trace_assert(level);
 179
 180     if (background_render(level->background, camera) < 0) {
 181         return -1;
 182     }
 183
 184     if (platforms_render(level->back_platforms, camera) < 0) {
 185         return -1;
 186     }
 187
 188     if (player_render(level->player, camera) < 0) {
 189         return -1;
 190     }
 191
 192     if (boxes_render(level->boxes, camera) < 0) {
 193         return -1;
 194     }
 195
 196     if (lava_render(level->lava, camera) < 0) {
 197         return -1;
 198     }
 199
 200     if (platforms_render(level->platforms, camera) < 0) {
 201         return -1;
 202     }
 203
 204     if (goals_render(level->goals, camera) < 0) {
 205         return -1;
 206     }
 207
 208     if (labels_render(level->labels, camera) < 0) {
 209         return -1;
 210     }
 211
 212     if (regions_render(level->regions, camera) < 0) {
 213         return -1;
 214     }
 215
 216     if (rigid_bodies_render(level->rigid_bodies, camera) < 0) {
 217         return -1;
 218     }
 219
 220     return 0;
 221 }
 222
 223 int level_update(Level *level, float delta_time)
 224 {
 225     trace_assert(level);
 226     trace_assert(delta_time > 0);
 227
 228     physical_world_apply_gravity(level->physical_world);
 229     boxes_float_in_lava(level->boxes, level->lava);
 230     rigid_bodies_apply_omniforce(level->rigid_bodies, vec(0.0f, LEVEL_GRAVITY));
 231
 232     rigid_bodies_update(level->rigid_bodies, delta_time);
 233     boxes_update(level->boxes, delta_time);
 234     player_update(level->player, delta_time);
 235
 236     rigid_bodies_collide(level->rigid_bodies, level->platforms);
 237     physical_world_collide_solids(level->physical_world, level->platforms);
 238
 239     player_hide_goals(level->player, level->goals);
 240     player_die_from_lava(level->player, level->lava);
 241     regions_player_enter(level->regions, level->player);
 242     regions_player_leave(level->regions, level->player);
 243
 244     goals_update(level->goals, delta_time);
 245     lava_update(level->lava, delta_time);
 246     labels_update(level->labels, delta_time);
 247
 248     return 0;
 249 }
 250
 251 int level_event(Level *level, const SDL_Event *event)
 252 {
 253     trace_assert(level);
 254     trace_assert(event);
 255
 256     switch (event->type) {
 257     case SDL_KEYDOWN:
 258         switch (event->key.keysym.sym) {
 259         case SDLK_SPACE:
 260             player_jump(level->player);
 261             break;
 262         }
 263         break;
 264
 265     case SDL_JOYBUTTONDOWN:
 266         if (event->jbutton.button == 1) {
 267             player_jump(level->player);
 268         }
 269         break;
 270
 271     case SDL_MOUSEMOTION:
 272         if (level->flying_mode) {
 273             vec_add(&level->flying_camera_position,
 274                     vec((float) event->motion.xrel, (float) event->motion.yrel));
 275         }
 276         break;
 277     }
 278
 279     return 0;
 280 }
 281
 282 int level_input(Level *level,
 283                 const Uint8 *const keyboard_state,
 284                 SDL_Joystick *the_stick_of_joy)
 285 {
 286     trace_assert(level);
 287     trace_assert(keyboard_state);
 288     (void) the_stick_of_joy;
 289
 290     if (keyboard_state[SDL_SCANCODE_A]) {
 291         player_move_left(level->player);
 292     } else if (keyboard_state[SDL_SCANCODE_D]) {
 293         player_move_right(level->player);
 294     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) < 0) {
 295         player_move_left(level->player);
 296     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) > 0) {
 297         player_move_right(level->player);
 298     } else {
 299         player_stop(level->player);
 300     }
 301
 302     return 0;
 303 }
 304
 305 int level_reload_preserve_player(Level *level, const char *file_name, Broadcast *broadcast)
 306 {
 307     Lt * const lt = create_lt();
 308     if (lt == NULL) {
 309         return -1;
 310     }
 311
 312     /* TODO(#104): duplicate code in create_level_from_file and level_reload_preserve_player */
 313
 314     LineStream * const level_stream = PUSH_LT(
 315         lt,
 316         create_line_stream(
 317             file_name,
 318             "r",
 319             LEVEL_LINE_MAX_LENGTH),
 320         destroy_line_stream);
 321     if (level_stream == NULL) {
 322         RETURN_LT(lt, -1);
 323     }
 324
 325     Background * const background = create_background_from_line_stream(level_stream);
 326     if (background == NULL) {
 327         RETURN_LT(lt, -1);
 328     }
 329     level->background = RESET_LT(level->lt, level->background, background);
 330
 331     Player * const skipped_player = create_player_from_line_stream(level_stream, broadcast);
 332     if (skipped_player == NULL) {
 333         RETURN_LT(lt, -1);
 334     }
 335     destroy_player(skipped_player);
 336
 337     Platforms * const platforms = create_platforms_from_line_stream(level_stream);
 338     if (platforms == NULL) {
 339         RETURN_LT(lt, -1);
 340     }
 341     level->platforms = RESET_LT(level->lt, level->platforms, platforms);
 342
 343     Goals * const goals = create_goals_from_line_stream(level_stream);
 344     if (goals == NULL) {
 345         RETURN_LT(lt, -1);
 346     }
 347     level->goals = RESET_LT(level->lt, level->goals, goals);
 348
 349     Lava * const lava = create_lava_from_line_stream(level_stream);
 350     if (lava == NULL) {
 351         RETURN_LT(lt, -1);
 352     }
 353     level->lava = RESET_LT(level->lt, level->lava, lava);
 354
 355     Platforms * const back_platforms = create_platforms_from_line_stream(level_stream);
 356     if (back_platforms == NULL) {
 357         RETURN_LT(lt, -1);
 358     }
 359     level->back_platforms = RESET_LT(level->lt, level->back_platforms, back_platforms);
 360
 361     Boxes * const boxes = create_boxes_from_line_stream(level_stream);
 362     if (boxes == NULL) {
 363         RETURN_LT(lt, -1);
 364     }
 365     level->boxes = RESET_LT(level->lt, level->boxes, boxes);
 366
 367     Labels * const labels = create_labels_from_line_stream(level_stream);
 368     if (labels == NULL) {
 369         RETURN_LT(lt, -1);
 370     }
 371     level->labels = RESET_LT(level->lt, level->labels, labels);
 372
 373     Regions * const regions = create_regions_from_line_stream(level_stream, broadcast);
 374     if (regions == NULL) {
 375         RETURN_LT(lt, -1);
 376     }
 377     level->regions = RESET_LT(level->lt, level->regions, regions);
 378
 379     physical_world_clean(level->physical_world);
 380     if (physical_world_add_solid(
 381             level->physical_world,
 382             player_as_solid(level->player)) < 0) { RETURN_LT(lt, -1); }
 383     if (boxes_add_to_physical_world(
 384             level->boxes,
 385             level->physical_world) < 0) { RETURN_LT(lt, -1); }
 386
 387     RETURN_LT(lt, 0);
 388 }
 389
 390 int level_sound(Level *level, Sound_samples *sound_samples)
 391 {
 392     if (goals_sound(level->goals, sound_samples) < 0) {
 393         return -1;
 394     }
 395
 396     if (player_sound(level->player, sound_samples) < 0) {
 397         return -1;
 398     }
 399
 400     return 0;
 401 }
 402
 403 void level_toggle_debug_mode(Level *level)
 404 {
 405     background_toggle_debug_mode(level->background);
 406 }
 407
 408 int level_enter_camera_event(Level *level, Camera *camera)
 409 {
 410     if (!level->flying_mode) {
 411         player_focus_camera(level->player, camera);
 412     } else {
 413         camera_center_at(camera, level->flying_camera_position);
 414     }
 415
 416     goals_cue(level->goals, camera);
 417     goals_checkpoint(level->goals, level->player);
 418     labels_enter_camera_event(level->labels, camera);
 419     return 0;
 420 }
 421
 422 Rigid_rect *level_rigid_rect(Level *level,
 423                              const char *rigid_rect_id)
 424 {
 425     trace_assert(level);
 426     trace_assert(rigid_rect_id);
 427
 428     Rigid_rect *rigid_rect = player_rigid_rect(level->player,
 429                                                rigid_rect_id);
 430     if (rigid_rect != NULL) {
 431         return rigid_rect;
 432     }
 433
 434     rigid_rect = boxes_rigid_rect(level->boxes, rigid_rect_id);
 435     if (rigid_rect != NULL) {
 436         return rigid_rect;
 437     }
 438
 439     return NULL;
 440 }
 441
 442 struct EvalResult level_send(Level *level, Gc *gc, struct Scope *scope, struct Expr path)
 443 {
 444     trace_assert(level);
 445     trace_assert(gc);
 446     trace_assert(scope);
 447
 448     const char *target = NULL;
 449     struct Expr rest = void_expr();
 450     struct EvalResult res = match_list(gc, "q*", path, &target, &rest);
 451     if (res.is_error) {
 452         return res;
 453     }
 454
 455     if (strcmp(target, "goal") == 0) {
 456         return goals_send(level->goals, gc, scope, rest);
 457     } else if (strcmp(target, "label") == 0) {
 458         return labels_send(level->labels, gc, scope, rest);
 459     } else if (strcmp(target, "box") == 0) {
 460         return boxes_send(level->boxes, gc, scope, rest);
 461     } else if (strcmp(target, "body-push") == 0) {
 462         long int id = 0, x = 0, y = 0;
 463         res = match_list(gc, "ddd", rest, &id, &x, &y);
 464         if (res.is_error) {
 465             return res;
 466         }
 467
 468         rigid_bodies_apply_force(level->rigid_bodies, (size_t) id, vec((float) x, (float) y));
 469
 470         return eval_success(NIL(gc));
 471     } else if (strcmp(target, "body-add") == 0) {
 472         long int x = 0, y = 0, w = 0, h = 0;
 473         const char *color = 0;
 474         res = match_list(gc, "dddds", rest, &x, &y, &w, &h, &color);
 475         if (res.is_error) {
 476             return res;
 477         }
 478
 479         return eval_success(
 480             NUMBER(
 481                 gc,
 482                 (long int) rigid_bodies_add(
 483                     level->rigid_bodies,
 484                     rect((float)x, (float)y, (float)w, (float)h),
 485                     hexstr(color))));
 486     } else if (strcmp(target, "fly") == 0) {
 487         level->flying_mode = !level->flying_mode;
 488         return eval_success(NIL(gc));
 489     }
 490
 491     return unknown_target(gc, "level", target);
 492 }