-#include <SDL2/SDL.h>
-#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
-#include "game/level/player/dying_rect.h"
-#include "game/level/player/rigid_rect.h"
-#include "game/level/script.h"
+#include <SDL.h>
+
+#include "game/level/explosion.h"
+#include "game/level/rigid_bodies.h"
#include "goals.h"
-#include "math/point.h"
+#include "math/vec.h"
#include "platforms.h"
#include "player.h"
#include "system/line_stream.h"
#include "system/log.h"
#include "system/lt.h"
#include "system/nth_alloc.h"
+#include "system/stacktrace.h"
+#include "config.h"
#define PLAYER_WIDTH 25.0f
#define PLAYER_HEIGHT 25.0f
Lt *lt;
Player_state state;
- Rigid_rect *alive_body;
- Dying_rect *dying_body;
- Script *script;
+ RigidBodies *rigid_bodies;
+
+ RigidBodyId alive_body_id;
+ Explosion *dying_body;
int jump_threshold;
- int jump_count;
Color color;
- Vec checkpoint;
+ Vec2f checkpoint;
int play_die_cue;
};
-Player *create_player_from_line_stream(LineStream *line_stream, Level *level)
+Player *create_player_from_player_layer(const PlayerLayer *player_layer,
+ RigidBodies *rigid_bodies)
{
- assert(line_stream);
+ trace_assert(player_layer);
+ trace_assert(rigid_bodies);
Lt *lt = create_lt();
- if (lt == NULL) {
- return NULL;
- }
-
- Player *player = PUSH_LT(lt, nth_alloc(sizeof(Player)), free);
+ Player *player = PUSH_LT(lt, nth_calloc(1, sizeof(Player)), free);
if (player == NULL) {
RETURN_LT(lt, NULL);
}
player->lt = lt;
- float x = 0.0f, y = 0.0f;
- char colorstr[7];
-
- if (sscanf(
- line_stream_next(line_stream),
- "%f%f%6s",
- &x, &y, colorstr) == EOF) {
- log_fail("Could not read player\n");
- RETURN_LT(lt, NULL);
- }
-
- player->script = PUSH_LT(
- lt,
- create_script_from_line_stream(line_stream, level),
- destroy_script);
- if (player->script == NULL) {
- RETURN_LT(lt, NULL);
- }
-
- const Color color = hexstr(colorstr);
+ player->rigid_bodies = rigid_bodies;
- player->alive_body = PUSH_LT(
- lt,
- create_rigid_rect(
- rect(x, y, PLAYER_WIDTH, PLAYER_HEIGHT),
- color,
- "player"),
- destroy_rigid_rect);
- if (player->alive_body == NULL) {
- RETURN_LT(lt, NULL);
- }
+ player->alive_body_id = rigid_bodies_add(
+ rigid_bodies,
+ rect(
+ player_layer->position.x,
+ player_layer->position.y,
+ PLAYER_WIDTH,
+ PLAYER_HEIGHT));
player->dying_body = PUSH_LT(
lt,
- create_dying_rect(
- color,
+ create_explosion(
+ color_picker_rgba(&player_layer->color_picker),
PLAYER_DEATH_DURATION),
- destroy_dying_rect);
+ destroy_explosion);
if (player->dying_body == NULL) {
RETURN_LT(lt, NULL);
}
player->jump_threshold = 0;
- player->jump_count = 0;
- player->color = color;
- player->checkpoint = vec(x, y);
+ player->color = color_picker_rgba(&player_layer->color_picker);
+ player->checkpoint = player_layer->position;
player->play_die_cue = 0;
player->state = PLAYER_STATE_ALIVE;
void destroy_player(Player * player)
{
+ rigid_bodies_remove(player->rigid_bodies, player->alive_body_id);
RETURN_LT0(player->lt);
}
-Solid_ref player_as_solid(Player *player)
-{
- Solid_ref ref = {
- .tag = SOLID_PLAYER,
- .ptr = (void*) player
- };
-
- return ref;
-}
-
int player_render(const Player * player,
- Camera *camera)
+ const Camera *camera)
{
- assert(player);
- assert(camera);
+ trace_assert(player);
+ trace_assert(camera);
+
+ char debug_text[256];
switch (player->state) {
- case PLAYER_STATE_ALIVE:
- return rigid_rect_render(player->alive_body, camera);
+ case PLAYER_STATE_ALIVE: {
+ snprintf(debug_text, 256, "Jump: %d", player->jump_threshold);
+ Rect hitbox = rigid_bodies_hitbox(player->rigid_bodies, player->alive_body_id);
+
+ if (camera_render_debug_text(camera, debug_text, vec(hitbox.x, hitbox.y - 20.0f)) < 0) {
+ return -1;
+ }
+
+ return rigid_bodies_render(
+ player->rigid_bodies,
+ player->alive_body_id,
+ player->color,
+ camera);
+ }
case PLAYER_STATE_DYING:
- return dying_rect_render(player->dying_body, camera);
+ return explosion_render(player->dying_body, camera);
default: {}
}
void player_update(Player *player,
float delta_time)
{
- assert(player);
+ trace_assert(player);
switch (player->state) {
case PLAYER_STATE_ALIVE: {
- rigid_rect_update(player->alive_body, delta_time);
+ rigid_bodies_update(player->rigid_bodies, player->alive_body_id, delta_time);
- const Rect hitbox = rigid_rect_hitbox(player->alive_body);
+ const Rect hitbox = rigid_bodies_hitbox(player->rigid_bodies, player->alive_body_id);
- if (hitbox.y > 1000.0f) {
+
+ if (hitbox.y > PLAYER_DEATH_LEVEL) {
player_die(player);
}
} break;
case PLAYER_STATE_DYING: {
- dying_rect_update(player->dying_body, delta_time);
+ explosion_update(player->dying_body, delta_time);
- if (dying_rect_is_dead(player->dying_body)) {
- rigid_rect_transform_velocity(
- player->alive_body,
+ if (explosion_is_done(player->dying_body)) {
+ rigid_bodies_disable(player->rigid_bodies, player->alive_body_id, false);
+ rigid_bodies_transform_velocity(
+ player->rigid_bodies,
+ player->alive_body_id,
make_mat3x3(0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f));
- rigid_rect_teleport_to(player->alive_body, player->checkpoint);
+ rigid_bodies_teleport_to(
+ player->rigid_bodies,
+ player->alive_body_id,
+ player->checkpoint);
player->state = PLAYER_STATE_ALIVE;
}
} break;
}
}
-void player_collide_with_solid(Player *player, Solid_ref solid)
-{
- if (player->state == PLAYER_STATE_ALIVE) {
- rigid_rect_collide_with_solid(player->alive_body, solid);
-
- if (rigid_rect_touches_ground(player->alive_body)) {
- player->jump_threshold = 0;
- }
- }
-}
-
void player_move_left(Player *player)
{
- assert(player);
- rigid_rect_move(player->alive_body, vec(-PLAYER_SPEED, 0.0f));
+ trace_assert(player);
+ rigid_bodies_move(player->rigid_bodies, player->alive_body_id, vec(-PLAYER_SPEED, 0.0f));
}
void player_move_right(Player *player)
{
- assert(player);
+ trace_assert(player);
- rigid_rect_move(player->alive_body, vec(PLAYER_SPEED, 0.0f));
+ rigid_bodies_move(player->rigid_bodies, player->alive_body_id, vec(PLAYER_SPEED, 0.0f));
}
void player_stop(Player *player)
{
- assert(player);
+ trace_assert(player);
- rigid_rect_move(player->alive_body, vec(0.0f, 0.0f));
+ rigid_bodies_move(player->rigid_bodies, player->alive_body_id, vec(0.0f, 0.0f));
}
void player_jump(Player *player)
{
- assert(player);
- if (player->jump_threshold < PLAYER_MAX_JUMP_THRESHOLD) {
- rigid_rect_transform_velocity(player->alive_body,
- make_mat3x3(1.0f, 0.0f, 0.0f,
- 0.0f, 0.0f, 0.0f,
- 0.0f, 0.0f, 1.0f));
- rigid_rect_apply_force(player->alive_body,
- vec(0.0f, -PLAYER_JUMP));
- player->jump_threshold++;
+ trace_assert(player);
- if (script_has_scope_value(player->script, "on-jump")) {
- script_eval(player->script, "(on-jump)");
- }
+ if (rigid_bodies_touches_ground(player->rigid_bodies, player->alive_body_id)) {
+ player->jump_threshold = 0;
+ }
- player->jump_count++;
+ if (player->jump_threshold < PLAYER_MAX_JUMP_THRESHOLD) {
+ rigid_bodies_transform_velocity(
+ player->rigid_bodies,
+ player->alive_body_id,
+ make_mat3x3(1.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 1.0f));
+ rigid_bodies_apply_force(
+ player->rigid_bodies,
+ player->alive_body_id,
+ vec(0.0f, -PLAYER_JUMP));
+ player->jump_threshold++;
}
}
void player_die(Player *player)
{
- assert(player);
+ trace_assert(player);
if (player->state == PLAYER_STATE_ALIVE) {
const Rect hitbox =
- rigid_rect_hitbox(player->alive_body);
+ rigid_bodies_hitbox(
+ player->rigid_bodies,
+ player->alive_body_id);
player->play_die_cue = 1;
- dying_rect_start_dying(player->dying_body, vec(hitbox.x, hitbox.y));
+ explosion_start(player->dying_body, vec(hitbox.x, hitbox.y));
player->state = PLAYER_STATE_DYING;
+ rigid_bodies_disable(player->rigid_bodies, player->alive_body_id, true);
}
}
void player_focus_camera(Player *player,
Camera *camera)
{
- assert(player);
- assert(camera);
+ trace_assert(player);
+ trace_assert(camera);
- const Rect player_hitbox = rigid_rect_hitbox(player->alive_body);
+ const Rect player_hitbox = rigid_bodies_hitbox(
+ player->rigid_bodies,
+ player->alive_body_id);
camera_center_at(
camera,
vec(0.0f, -player_hitbox.h * 0.5f)));
}
-void player_hide_goals(const Player *player,
- Goals *goals)
-{
- assert(player);
- assert(goals);
- goals_hide_from_player(goals, rigid_rect_hitbox(player->alive_body));
-}
-
void player_die_from_lava(Player *player,
const Lava *lava)
{
- if (lava_overlaps_rect(lava, rigid_rect_hitbox(player->alive_body))) {
+ if (lava_overlaps_rect(
+ lava,
+ rigid_bodies_hitbox(
+ player->rigid_bodies,
+ player->alive_body_id))) {
player_die(player);
}
}
-void player_checkpoint(Player *player, Vec checkpoint)
+void player_checkpoint(Player *player, Vec2f checkpoint)
{
player->checkpoint = checkpoint;
}
if (player->play_die_cue) {
player->play_die_cue = 0;
- if (sound_samples_play_sound(sound_samples, 0, 0) < 0) {
+ if (sound_samples_play_sound(sound_samples, 0) < 0) {
return -1;
}
}
return 0;
}
-void player_touches_rect_sides(Player *player,
- Rect object,
- int sides[RECT_SIDE_N])
-{
- if (player->state == PLAYER_STATE_ALIVE) {
- rigid_rect_touches_rect_sides(player->alive_body, object, sides);
- }
-}
-
-void player_apply_force(Player *player, Vec force)
-{
- if (player->state == PLAYER_STATE_ALIVE) {
- rigid_rect_apply_force(player->alive_body, force);
- }
-}
-
-Rigid_rect *player_rigid_rect(Player *player, const char *id)
-{
- assert(player);
- assert(id);
-
- if (player->state == PLAYER_STATE_ALIVE) {
- if (rigid_rect_has_id(player->alive_body, id)) {
- return player->alive_body;
- }
- }
-
- return NULL;
-}
-
bool player_overlaps_rect(const Player *player,
Rect rect)
{
- assert(player);
+ trace_assert(player);
return player->state == PLAYER_STATE_ALIVE
&& rects_overlap(
- rect, rigid_rect_hitbox(
- player->alive_body));
+ rect, rigid_bodies_hitbox(
+ player->rigid_bodies,
+ player->alive_body_id));
}
-long int player_jump_count(const Player *player)
+Rect player_hitbox(const Player *player)
{
- assert(player);
- return player->jump_count;
+ return rigid_bodies_hitbox(
+ player->rigid_bodies,
+ player->alive_body_id);
}
projects / nothing.git / blobdiff