diff options
| author | Schark <jordan@schark.online> | 2026-09-29 19:14:39 -0400 |
|---|---|---|
| committer | Schark <jordan@schark.online> | 2026-09-29 19:14:39 -0400 |
| commit | 0b99c49ef6ff75e3adfa08cd03dc6bc4b1602742 (patch) | |
| tree | e09a815472001b9097a2bdea07ef63994aa45cd9 /platformer/src/player.c | |
| parent | 923b5928eeafd9bf969b95c4d49699d280b1ce0f (diff) | |
| download | gamedev-0b99c49ef6ff75e3adfa08cd03dc6bc4b1602742.tar.gz gamedev-0b99c49ef6ff75e3adfa08cd03dc6bc4b1602742.zip | |
Flip jump looking amazing
Diffstat (limited to '')
| -rw-r--r-- | platformer/src/player.c | 242 |
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 "?"; } |
