summaryrefslogtreecommitdiff
path: root/platformer/src/player.c
diff options
context:
space:
mode:
authorSchark <jordan@schark.online>2026-09-29 19:14:39 -0400
committerSchark <jordan@schark.online>2026-09-29 19:14:39 -0400
commit0b99c49ef6ff75e3adfa08cd03dc6bc4b1602742 (patch)
treee09a815472001b9097a2bdea07ef63994aa45cd9 /platformer/src/player.c
parent923b5928eeafd9bf969b95c4d49699d280b1ce0f (diff)
downloadgamedev-0b99c49ef6ff75e3adfa08cd03dc6bc4b1602742.tar.gz
gamedev-0b99c49ef6ff75e3adfa08cd03dc6bc4b1602742.zip
Flip jump looking amazing
Diffstat (limited to 'platformer/src/player.c')
-rw-r--r--platformer/src/player.c242
1 files changed, 189 insertions, 53 deletions
diff --git a/platformer/src/player.c b/platformer/src/player.c
index 88df0c4..b4341de 100644
--- a/platformer/src/player.c
+++ b/platformer/src/player.c
@@ -15,10 +15,12 @@
* - player_init / player_reset: body.pos = spawn, vel = 0, on_ground = true,
* body.half_width = PLAYER_HALF_WIDTH, body.height = PLAYER_HEIGHT,
* facing_yaw = 0, forward_speed = 0, state = PLAYER_IDLE,
- * heightened_movement = false, heightened_timer = 0, jump_number = 0.
+ * heightened_movement = false, heightened_timer = 0,
+ * retreating_movement = false, jump_kind = JUMP_NONE, skid_time = 0,
+ * skid_speed = 0, skid_yaw = 0.
*
* - player_update(p, in, camera_yaw, dt). Use one static helper per state
- * (update_idle / update_run / update_jump / update_fall), dispatched by a
+ * (update_ground for IDLE + RUN / update_skid / update_jump / update_fall), dispatched by a
* `switch (p->state)`. Keep each helper short. Shared steps:
*
* A. Stick -> world direction (camera-relative). Using camera.h's convention:
@@ -42,31 +44,60 @@
* purpose: starts build up and stops skid briefly, so the player
* feels like a heavy, real object rather than a cursor.
* - State: forward_speed > 0 -> RUN, otherwise IDLE.
+ * - Pulling back at full run -> SKID (see B2), checked before steering.
*
- * C. Jump (from IDLE / RUN): if in->jump_pressed and body.on_ground:
- * on_ground = false; state = JUMP, and then either
+ * B2. Skid (SM64's turnaround skid). In IDLE/RUN, if mag > 0,
+ * forward_speed >= PLAYER_MAX_SPEED * PLAYER_SKID_SPEED_FRACTION ("full
+ * run and above", so faster future moves count too), and wish_yaw is
+ * more than PLAYER_SKID_ANGLE_DEG from facing_yaw: state = SKID,
+ * retreating_movement = true, skid_yaw = facing_yaw (the slide keeps
+ * going the old way), skid_speed = forward_speed, skid_time = 0.
+ * While skidding:
+ * - The player FACES THE STICK at once (and keeps tracking it), while
+ * still sliding along skid_yaw: turned around, sliding backward.
+ * - No steering. Speed follows a curve, whatever the stick does:
+ * forward_speed = skid_speed * (1 - (skid_time / PLAYER_SKID_DURATION)
+ * ^ PLAYER_SKID_GLIDE_POWER)
+ * Braking starts near zero, so it glides like a short slide, then
+ * builds so the player stops exactly at PLAYER_SKID_DURATION.
+ * - At PLAYER_SKID_DURATION: speed 0, retreating_movement off, IDLE.
+ * - Sliding off an edge ends the skid too (facing_yaw goes back to
+ * skid_yaw, so the fall keeps the slide's direction).
+ * WHY: at full run a U-turn used to keep all its speed; the skid
+ * makes reversing a committed, weighty slide.
+ *
+ * C. Jump (from IDLE / RUN / SKID): if in->jump_pressed and body.on_ground:
+ * on_ground = false; state = JUMP, and then one of
+ * - in SKID: the RETREAT jump, like SM64's side flip. The player
+ * already faces the stick (or where it last pointed), forward_speed =
+ * PLAYER_RETREAT_JUMP_SPEED, body.vel.y = PLAYER_RETREAT_JUMP_VELOCITY
+ * (2x the height, the highest jump); jump_kind = JUMP_RETREAT.
+ * retreating_movement stays on until it lands.
* - heightened_movement on: the SECOND jump, SM64's double jump.
* body.vel.y = PLAYER_SECOND_JUMP_VELOCITY (1.75x the height);
- * jump_number = 2. heightened_movement stays on for the whole jump,
- * however long it lasts. Until it lands, the top speed is
- * PLAYER_SECOND_JUMP_MAX_SPEED instead of PLAYER_MAX_SPEED (see D).
+ * jump_kind = JUMP_SECOND. heightened_movement stays on for the
+ * whole jump, however long it lasts.
* - otherwise a normal jump: body.vel.y = PLAYER_JUMP_VELOCITY;
- * jump_number = 1.
+ * jump_kind = JUMP_NORMAL.
*
- * C2. heightened_movement: landing from a normal jump (jump_number == 1,
- * short hop or full) turns it on with heightened_timer =
- * PLAYER_SECOND_JUMP_WINDOW. Landing any other way (from the second
- * jump, or after walking off an edge) turns it off. Every tick,
- * unless the player is in the second jump, the timer counts down and
- * it turns off at 0. WHY a named state rather than a private "can
- * double jump" flag: later moves will key off it too.
+ * C2. Landing: landing from a normal jump (JUMP_NORMAL, short hop or
+ * full) or a retreat jump (JUMP_RETREAT) turns heightened_movement on
+ * with heightened_timer = PLAYER_SECOND_JUMP_WINDOW, so either one
+ * can lead into the second jump. Landing any other way (from the
+ * second jump, or after walking off an edge) turns it off. Every
+ * landing turns retreating_movement off and resets jump_kind to
+ * JUMP_NONE. Every tick, unless the player is in the second jump, the
+ * heightened timer counts down and it turns off at 0. WHY named
+ * states rather than private "can double jump" flags: later moves
+ * will key off them too.
*
* D. Air movement (JUMP / FALL): the same as B, but the turn rate is
* multiplied by PLAYER_AIR_CONTROL, accel is PLAYER_AIR_ACCEL, there's
* no instant turn from a standstill, and there's NO friction when the
* stick is released (you keep your momentum, like SM64).
* - Top speed: steering aims for top_speed() * mag, where top_speed()
- * is PLAYER_SECOND_JUMP_MAX_SPEED while jump_number == 2 and
+ * is PLAYER_SECOND_JUMP_MAX_SPEED in the second jump,
+ * PLAYER_RETREAT_JUMP_SPEED in the retreat jump, and
* PLAYER_MAX_SPEED otherwise. While forward_speed is ABOVE it (a
* full run into the second jump), the stick only turns: the extra
* speed bleeds off at PLAYER_SECOND_JUMP_SLOWDOWN, whatever the
@@ -74,9 +105,9 @@
* 5 m/s over ~0.3 s. WHY a separate, gentle rate: slowing at
* PLAYER_AIR_ACCEL (~0.25 s) felt like hitting a wall of syrup
* right at takeoff. 6 m/s only comes back (through normal ground
- * accel) after landing. WHY no new state:
- * jump_number == 2 already means "in the second jump".
- * - Variable jump height (both jumps): in JUMP, if !in->jump_held and vel.y > 0,
+ * accel) after landing. WHY no new state: jump_kind already says
+ * which jump the player is in.
+ * - Variable jump height (every jump): in JUMP, if !in->jump_held and vel.y > 0,
* multiply vel.y by PLAYER_JUMP_CUT ONCE (don't repeat it every tick;
* either switch to FALL right away or keep a flag). Comment WHY: tapping A
* gives a hop, holding it gives a full jump.
@@ -86,8 +117,9 @@
* - If the player is on the ground state-wise but body.on_ground is false
* (walked off a platform edge) -> FALL.
*
- * E. Apply: body.vel.x = sin(facing_yaw) * forward_speed
- * body.vel.z = cos(facing_yaw) * forward_speed
+ * E. Apply: move_yaw = skid_yaw while in SKID, else facing_yaw.
+ * body.vel.x = sin(move_yaw) * forward_speed
+ * body.vel.z = cos(move_yaw) * forward_speed
* then physics_step(&p->body, dt).
*
* - player_state_name: a switch that returns string literals.
@@ -96,8 +128,8 @@
* accelerations in m/s^2, and every one of them multiplies by dt.
* No magic numbers; everything comes from config.h.
*
- * NOT IN SCOPE: Triple jump, long jump, wall kick, ground pound,
- * skidding/turnaround, slopes, coyote time, jump buffering.
+ * NOT IN SCOPE: Triple jump, long jump, wall kick, ground pound, skids
+ * below full run speed, slopes, coyote time, jump buffering.
* Leave a short comment at the state enum pointing to the
* README roadmap as the place to grow.
*
@@ -106,9 +138,12 @@
* not instant while moving, and instant for big turns from a standstill. Letting go
* of the stick skids the player to a short, smooth stop. A tap of A
* gives a short hop and holding A gives a full ~2.4 m jump. Pressing
- * A within 0.3 s of landing gives a second jump 1.75x as high, with
+ * A within 0.2 s of landing gives a second jump 1.75x as high, with
* heightened_movement on from that landing until the second jump
- * lands. The player lands cleanly back in IDLE/RUN.
+ * lands. Pulling the stick back at full run turns the player to
+ * face the stick and slides them backward to a stop over 0.5 s,
+ * and A during that slide launches a 2x-height jump toward the
+ * stick at 4 m/s; landing it opens the second-jump window too. The player lands cleanly back in IDLE/RUN.
* ============================================================
*/
@@ -122,6 +157,7 @@ typedef struct {
} Wish;
static void update_ground(Player *p, const Input *in, Wish wish, float dt);
+static void update_skid(Player *p, const Input *in, Wish wish, float dt);
static void update_fall(Player *p, const Input *in, Wish wish, float dt);
/* A. Stick -> world direction. "Up" on the stick means "away from the
@@ -139,11 +175,27 @@ static Wish compute_wish(const Input *in, float camera_yaw)
return wish;
}
-/* The fastest the player may go right now. The second jump trades
- * horizontal speed for its extra height, until it lands. */
+/* The fastest the player may go right now. The second and retreat jumps
+ * trade horizontal speed for their extra height, until they land. */
static float top_speed(const Player *p)
{
- return p->jump_number == 2 ? PLAYER_SECOND_JUMP_MAX_SPEED : PLAYER_MAX_SPEED;
+ switch (p->jump_kind) {
+ case JUMP_SECOND: return PLAYER_SECOND_JUMP_MAX_SPEED;
+ case JUMP_RETREAT: return PLAYER_RETREAT_JUMP_SPEED;
+ default: return PLAYER_MAX_SPEED;
+ }
+}
+
+/* Degrees to radians, for the _DEG tunables. */
+static float deg_to_rad(float deg)
+{
+ return deg * (M3D_PI / 180.0f);
+}
+
+/* How far the stick points from where the player faces, 0..PI radians. */
+static float angle_off_facing(const Player *p, Wish wish)
+{
+ return fabsf(wrap_angle(wish.yaw - p->facing_yaw));
}
/* Turns the facing toward the stick, at most turn_rate. */
@@ -166,49 +218,75 @@ static PlayerState grounded_state(const Player *p)
return p->forward_speed > 0.0f ? PLAYER_RUN : PLAYER_IDLE;
}
-/* C. Leaving the ground. While heightened_movement is on (just after landing
- * a normal jump), A gives the higher second jump instead, like SM64's
- * double jump. heightened_movement stays on through the whole second jump. */
-static void start_jump(Player *p)
+/* C. Leaves the ground with the given upward speed. */
+static void leave_ground(Player *p, float vel_y, JumpKind kind)
{
- if (p->heightened_movement) {
- p->body.vel.y = PLAYER_SECOND_JUMP_VELOCITY;
- p->jump_number = 2;
- } else {
- p->body.vel.y = PLAYER_JUMP_VELOCITY;
- p->jump_number = 1;
- }
+ p->body.vel.y = vel_y;
p->body.on_ground = false;
+ p->jump_kind = kind;
p->state = PLAYER_JUMP;
}
-/* C2. Touching down. Landing a normal jump (a hop or a full one) opens the
- * short window for the second jump; landing any other way closes it, so
- * the second jump can't chain into another one. */
+/* C. A jump from IDLE/RUN. While heightened_movement is on (just after
+ * landing a normal jump), A gives the higher second jump instead, like
+ * SM64's double jump. heightened_movement stays on through the whole
+ * second jump. */
+static void start_jump(Player *p)
+{
+ if (p->heightened_movement)
+ leave_ground(p, PLAYER_SECOND_JUMP_VELOCITY, JUMP_SECOND);
+ else
+ leave_ground(p, PLAYER_JUMP_VELOCITY, JUMP_NORMAL);
+}
+
+/* C. The jump out of a skid, like SM64's side flip: the player already faces
+ * where the stick points (the skid turned them) and launches that way,
+ * higher than any other jump but slower. retreating_movement stays on
+ * until it lands. */
+static void start_retreat_jump(Player *p)
+{
+ p->forward_speed = PLAYER_RETREAT_JUMP_SPEED;
+ leave_ground(p, PLAYER_RETREAT_JUMP_VELOCITY, JUMP_RETREAT);
+}
+
+/* C2. Touching down. Landing a normal jump (a hop or a full one) or a
+ * retreat jump opens the short window for the second jump; landing any
+ * other way closes it, so the second jump can't chain into another one.
+ * Any landing ends a retreat jump's retreating_movement. */
static void land(Player *p)
{
- if (p->jump_number == 1) {
+ if (p->jump_kind == JUMP_NORMAL || p->jump_kind == JUMP_RETREAT) {
p->heightened_movement = true;
p->heightened_timer = PLAYER_SECOND_JUMP_WINDOW;
} else {
p->heightened_movement = false;
}
- p->jump_number = 0;
+ p->retreating_movement = false;
+ p->jump_kind = JUMP_NONE;
}
/* C2. The window after landing runs out on its own. It doesn't during the
* second jump: heightened_movement lasts as long as that jump does. */
static void count_down_heightened(Player *p, float dt)
{
- if (!p->heightened_movement || p->jump_number == 2)
+ if (!p->heightened_movement || p->jump_kind == JUMP_SECOND)
return;
p->heightened_timer -= dt;
if (p->heightened_timer <= 0.0f)
p->heightened_movement = false;
}
+/* B2. Pulling the stick back while running flat out. "Full run and above",
+ * so the faster moves still to come can skid too. */
+static bool wants_skid(const Player *p, Wish wish)
+{
+ return wish.mag > 0.0f
+ && p->forward_speed >= PLAYER_MAX_SPEED * PLAYER_SKID_SPEED_FRACTION
+ && angle_off_facing(p, wish) > deg_to_rad(PLAYER_SKID_ANGLE_DEG);
+}
+
/* B + C. IDLE and RUN: full control, friction when the stick is released,
- * and the only place a jump can start. */
+ * and where normal jumps start. */
static void update_ground(Player *p, const Input *in, Wish wish, float dt)
{
/* Walked off a platform edge: start falling. */
@@ -218,12 +296,21 @@ static void update_ground(Player *p, const Input *in, Wish wish, float dt)
return;
}
+ if (wants_skid(p, wish)) {
+ p->state = PLAYER_SKID;
+ p->retreating_movement = true;
+ p->skid_yaw = p->facing_yaw; /* keep sliding the way we were running */
+ p->skid_speed = p->forward_speed;
+ p->skid_time = 0.0f;
+ update_skid(p, in, wish, dt);
+ return;
+ }
+
if (wish.mag > 0.0f) {
/* Standing still there's no momentum to swing around, so a big turn
* faces the stick right away. Small ones keep the quick turn rate so
* nudging the stick to adjust your aim still looks smooth. */
- float turn = fabsf(wrap_angle(wish.yaw - p->facing_yaw));
- if (p->forward_speed == 0.0f && turn > PLAYER_SNAP_TURN_DEG * (M3D_PI / 180.0f))
+ if (p->forward_speed == 0.0f && angle_off_facing(p, wish) > deg_to_rad(PLAYER_SNAP_TURN_DEG))
p->facing_yaw = wish.yaw;
steer(p, wish, PLAYER_TURN_RATE, PLAYER_GROUND_ACCEL, dt);
} else {
@@ -235,6 +322,46 @@ static void update_ground(Player *p, const Input *in, Wish wish, float dt)
start_jump(p);
}
+/* B2 + C. SKID: pulled back at full run. The player turns to face the stick
+ * right away but keeps sliding the old way (skid_yaw), like a short
+ * slide on the heels. retreating_movement is on the whole time, and A
+ * launches the retreat jump. */
+static void update_skid(Player *p, const Input *in, Wish wish, float dt)
+{
+ /* Slid off a platform edge: the skid (and its jump) is over. The air
+ * moves along facing_yaw, so point it back along the slide to keep the
+ * player's momentum going the same way. */
+ if (!p->body.on_ground) {
+ p->retreating_movement = false;
+ p->facing_yaw = p->skid_yaw;
+ p->state = PLAYER_FALL;
+ update_fall(p, in, wish, dt);
+ return;
+ }
+
+ /* Face the stick immediately; the slide direction doesn't change. */
+ if (wish.mag > 0.0f)
+ p->facing_yaw = wish.yaw;
+
+ if (in->jump_pressed) {
+ start_retreat_jump(p);
+ return;
+ }
+
+ /* Glide, then plant: braking starts near zero and builds, so the first
+ * part feels like a free slide and the player stops exactly when the skid
+ * ends. PLAYER_SKID_GLIDE_POWER shapes the curve (1 = even braking). */
+ p->skid_time += dt;
+ float t = clampf(p->skid_time / PLAYER_SKID_DURATION, 0.0f, 1.0f);
+ p->forward_speed = p->skid_speed * (1.0f - powf(t, PLAYER_SKID_GLIDE_POWER));
+
+ if (t >= 1.0f) {
+ p->forward_speed = 0.0f;
+ p->retreating_movement = false;
+ p->state = PLAYER_IDLE;
+ }
+}
+
/* D. Air movement: weaker steering, and NO friction when the stick is
* released, so you keep your momentum like in SM64. */
static void air_steer(Player *p, Wish wish, float dt)
@@ -284,7 +411,7 @@ static void update_jump(Player *p, const Input *in, Wish wish, float dt)
/* Variable jump height: letting go of A while rising cuts the upward speed.
* Tapping A gives a short hop, holding it gives the full jump (for the
- * second jump too). Switching to
+ * second and retreat jumps too). Switching to
* FALL right away makes sure the cut happens only once. */
if (!in->jump_held) {
p->body.vel.y *= PLAYER_JUMP_CUT;
@@ -304,7 +431,11 @@ void player_init(Player *p, Vec3 spawn)
p->state = PLAYER_IDLE;
p->heightened_movement = false;
p->heightened_timer = 0.0f;
- p->jump_number = 0;
+ p->retreating_movement = false;
+ p->jump_kind = JUMP_NONE;
+ p->skid_time = 0.0f;
+ p->skid_speed = 0.0f;
+ p->skid_yaw = 0.0f;
}
void player_reset(Player *p, Vec3 spawn)
@@ -321,13 +452,17 @@ void player_update(Player *p, const Input *in, float camera_yaw, float dt)
switch (p->state) {
case PLAYER_IDLE:
case PLAYER_RUN: update_ground(p, in, wish, dt); break;
+ case PLAYER_SKID: update_skid(p, in, wish, dt); break;
case PLAYER_JUMP: update_jump(p, in, wish, dt); break;
case PLAYER_FALL: update_fall(p, in, wish, dt); break;
}
- /* E. Turn "speed along facing" into a velocity, then let physics move us. */
- p->body.vel.x = sinf(p->facing_yaw) * p->forward_speed;
- p->body.vel.z = cosf(p->facing_yaw) * p->forward_speed;
+ /* E. Turn speed into a velocity, then let physics move us. The player
+ * moves where they face, except in a skid: they've already turned to
+ * the stick but keep sliding the way they were running. */
+ float move_yaw = p->state == PLAYER_SKID ? p->skid_yaw : p->facing_yaw;
+ p->body.vel.x = sinf(move_yaw) * p->forward_speed;
+ p->body.vel.z = cosf(move_yaw) * p->forward_speed;
physics_step(&p->body, dt);
}
@@ -338,6 +473,7 @@ const char *player_state_name(PlayerState s)
case PLAYER_RUN: return "RUN";
case PLAYER_JUMP: return "JUMP";
case PLAYER_FALL: return "FALL";
+ case PLAYER_SKID: return "SKID";
}
return "?";
}