src/game/level.c

   1 #include <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 "game/level_metadata.h"
  20 #include "game/level/level_editor/rect_layer.h"
  21 #include "game/level/level_editor/point_layer.h"
  22 #include "game/level/level_editor/player_layer.h"
  23 #include "game/level/level_editor/label_layer.h"
  24 #include "game/level/level_editor/background_layer.h"
  25 #include "system/line_stream.h"
  26 #include "system/log.h"
  27 #include "system/lt.h"
  28 #include "system/nth_alloc.h"
  29 #include "system/str.h"
  30 #include "game/level/level_editor.h"
  31 #include "game/level/script.h"
  32
  33 #define LEVEL_GRAVITY 1500.0f
  34 #define JOYSTICK_THRESHOLD 1000
  35
  36 struct Level
  37 {
  38     Lt *lt;
  39
  40     LevelMetadata *metadata;
  41     Background *background;
  42     RigidBodies *rigid_bodies;
  43     Player *player;
  44     Platforms *platforms;
  45     Goals *goals;
  46     Lava *lava;
  47     Platforms *back_platforms;
  48     Boxes *boxes;
  49     Labels *labels;
  50     Regions *regions;
  51     Broadcast *broadcast;
  52     Script *supa_script;
  53 };
  54
  55 Level *create_level_from_level_editor(const LevelEditor *level_editor,
  56                                       Broadcast *broadcast)
  57 {
  58     trace_assert(level_editor);
  59     trace_assert(broadcast);
  60
  61     Lt *lt = create_lt();
  62
  63     Level *level = PUSH_LT(
  64         lt,
  65         nth_calloc(1, sizeof(Level)),
  66         free);
  67     if (level == NULL) {
  68         RETURN_LT(lt, NULL);
  69     }
  70     level->lt = lt;
  71
  72     level->background = PUSH_LT(
  73         lt,
  74         create_background(
  75             color_picker_rgba(
  76                 &level_editor->background_layer.color_picker)),
  77         destroy_background);
  78     if (level->background == NULL) {
  79         RETURN_LT(lt, NULL);
  80     }
  81
  82     level->rigid_bodies = PUSH_LT(lt, create_rigid_bodies(1024), destroy_rigid_bodies);
  83     if (level->rigid_bodies == NULL) {
  84         RETURN_LT(lt, NULL);
  85     }
  86
  87     level->player = PUSH_LT(
  88         lt,
  89         create_player_from_player_layer(
  90             &level_editor->player_layer,
  91             level->rigid_bodies,
  92             broadcast),
  93         destroy_player);
  94     if (level->player == NULL) {
  95         RETURN_LT(lt, NULL);
  96     }
  97
  98     level->platforms = PUSH_LT(
  99         lt,
 100         create_platforms_from_rect_layer(level_editor->platforms_layer),
 101         destroy_platforms);
 102     if (level->platforms == NULL) {
 103         RETURN_LT(lt, NULL);
 104     }
 105
 106     level->goals = PUSH_LT(
 107         lt,
 108         create_goals_from_point_layer(level_editor->goals_layer),
 109         destroy_goals);
 110     if (level->goals == NULL) {
 111         RETURN_LT(lt, NULL);
 112     }
 113
 114     level->lava = PUSH_LT(
 115         lt,
 116         create_lava_from_rect_layer(level_editor->lava_layer),
 117         destroy_lava);
 118     if (level->lava == NULL) {
 119         RETURN_LT(lt, NULL);
 120     }
 121
 122     level->back_platforms = PUSH_LT(
 123         lt,
 124         create_platforms_from_rect_layer(level_editor->back_platforms_layer),
 125         destroy_platforms);
 126     if (level->back_platforms == NULL) {
 127         RETURN_LT(lt, NULL);
 128     }
 129
 130     level->boxes = PUSH_LT(
 131         lt,
 132         create_boxes_from_rect_layer(level_editor->boxes_layer, level->rigid_bodies),
 133         destroy_boxes);
 134     if (level->boxes == NULL) {
 135         RETURN_LT(lt, NULL);
 136     }
 137
 138     level->labels = PUSH_LT(
 139         lt,
 140         create_labels_from_label_layer(level_editor->label_layer),
 141         destroy_labels);
 142     if (level->labels == NULL) {
 143         RETURN_LT(lt, NULL);
 144     }
 145
 146     level->regions = PUSH_LT(
 147         lt,
 148         create_regions_from_rect_layer(level_editor->regions_layer),
 149         destroy_regions);
 150     if (level->regions == NULL) {
 151         RETURN_LT(lt, NULL);
 152     }
 153
 154     level->broadcast = broadcast;
 155
 156     level->supa_script = PUSH_LT(
 157         lt,
 158         create_script_from_string(
 159             broadcast,
 160             level_editor->supa_script_source),
 161         destroy_script);
 162     if (level->supa_script == NULL) {
 163         log_fail("Could not construct Supa Script for the level\n");
 164         RETURN_LT(lt, NULL);
 165     }
 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
 177 int level_render(const Level *level, const Camera *camera)
 178 {
 179     trace_assert(level);
 180
 181     if (background_render(level->background, camera) < 0) {
 182         return -1;
 183     }
 184
 185     if (platforms_render(level->back_platforms, camera) < 0) {
 186         return -1;
 187     }
 188
 189     if (player_render(level->player, camera) < 0) {
 190         return -1;
 191     }
 192
 193     if (boxes_render(level->boxes, camera) < 0) {
 194         return -1;
 195     }
 196
 197     if (lava_render(level->lava, camera) < 0) {
 198         return -1;
 199     }
 200
 201     if (platforms_render(level->platforms, camera) < 0) {
 202         return -1;
 203     }
 204
 205     if (goals_render(level->goals, camera) < 0) {
 206         return -1;
 207     }
 208
 209     if (labels_render(level->labels, camera) < 0) {
 210         return -1;
 211     }
 212
 213     if (regions_render(level->regions, camera) < 0) {
 214         return -1;
 215     }
 216
 217     return 0;
 218 }
 219
 220 int level_update(Level *level, float delta_time)
 221 {
 222     trace_assert(level);
 223     trace_assert(delta_time > 0);
 224
 225     boxes_float_in_lava(level->boxes, level->lava);
 226     rigid_bodies_apply_omniforce(level->rigid_bodies, vec(0.0f, LEVEL_GRAVITY));
 227
 228     boxes_update(level->boxes, delta_time);
 229     player_update(level->player, delta_time);
 230
 231     rigid_bodies_collide(level->rigid_bodies, level->platforms);
 232
 233     player_hide_goals(level->player, level->goals);
 234     player_die_from_lava(level->player, level->lava);
 235     regions_player_enter(level->regions, level->player, level->supa_script);
 236     regions_player_leave(level->regions, level->player, level->supa_script);
 237
 238     goals_update(level->goals, delta_time);
 239     lava_update(level->lava, delta_time);
 240     labels_update(level->labels, delta_time);
 241
 242     return 0;
 243 }
 244
 245 int level_event(Level *level, const SDL_Event *event)
 246 {
 247     trace_assert(level);
 248     trace_assert(event);
 249
 250     switch (event->type) {
 251     case SDL_KEYDOWN:
 252         switch (event->key.keysym.sym) {
 253         case SDLK_SPACE: {
 254             player_jump(level->player, level->supa_script);
 255         } break;
 256         }
 257         break;
 258
 259     case SDL_JOYBUTTONDOWN:
 260         if (event->jbutton.button == 1) {
 261             player_jump(level->player, level->supa_script);
 262         }
 263         break;
 264     }
 265
 266     return 0;
 267 }
 268
 269 int level_input(Level *level,
 270                 const Uint8 *const keyboard_state,
 271                 SDL_Joystick *the_stick_of_joy)
 272 {
 273     trace_assert(level);
 274     trace_assert(keyboard_state);
 275     (void) the_stick_of_joy;
 276
 277     if (keyboard_state[SDL_SCANCODE_A]) {
 278         player_move_left(level->player);
 279     } else if (keyboard_state[SDL_SCANCODE_D]) {
 280         player_move_right(level->player);
 281     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) < -JOYSTICK_THRESHOLD) {
 282         player_move_left(level->player);
 283     } else if (the_stick_of_joy && SDL_JoystickGetAxis(the_stick_of_joy, 0) > JOYSTICK_THRESHOLD) {
 284         player_move_right(level->player);
 285     } else {
 286         player_stop(level->player);
 287     }
 288
 289     return 0;
 290 }
 291
 292 int level_sound(Level *level, Sound_samples *sound_samples)
 293 {
 294     if (goals_sound(level->goals, sound_samples) < 0) {
 295         return -1;
 296     }
 297
 298     if (player_sound(level->player, sound_samples) < 0) {
 299         return -1;
 300     }
 301
 302     return 0;
 303 }
 304
 305 void level_toggle_debug_mode(Level *level)
 306 {
 307     background_toggle_debug_mode(level->background);
 308 }
 309
 310 int level_enter_camera_event(Level *level, Camera *camera)
 311 {
 312     player_focus_camera(level->player, camera);
 313     camera_scale(camera, 1.0f);
 314
 315     goals_cue(level->goals, camera);
 316     goals_checkpoint(level->goals, level->player);
 317     labels_enter_camera_event(level->labels, camera);
 318     return 0;
 319 }
 320
 321 struct EvalResult level_send(Level *level, Gc *gc, struct Scope *scope, struct Expr path)
 322 {
 323     trace_assert(level);
 324     trace_assert(gc);
 325     trace_assert(scope);
 326
 327     const char *target = NULL;
 328     struct Expr rest = void_expr();
 329     struct EvalResult res = match_list(gc, "q*", path, &target, &rest);
 330     if (res.is_error) {
 331         return res;
 332     }
 333
 334     if (strcmp(target, "goal") == 0) {
 335         return goals_send(level->goals, gc, scope, rest);
 336     } else if (strcmp(target, "label") == 0) {
 337         return labels_send(level->labels, gc, scope, rest);
 338     } else if (strcmp(target, "box") == 0) {
 339         return boxes_send(level->boxes, gc, scope, rest);
 340     } else if (strcmp(target, "body-push") == 0) {
 341         long int id = 0, x = 0, y = 0;
 342         res = match_list(gc, "ddd", rest, &id, &x, &y);
 343         if (res.is_error) {
 344             return res;
 345         }
 346
 347         rigid_bodies_apply_force(level->rigid_bodies, (size_t) id, vec((float) x, (float) y));
 348
 349         return eval_success(NIL(gc));
 350     } else if (strcmp(target, "edit") == 0) {
 351         return eval_success(NIL(gc));
 352     }
 353
 354     return unknown_target(gc, "level", target);
 355 }