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