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