diff options
| author | Schark <jordan@schark.online> | 2026-09-29 23:36:45 -0400 |
|---|---|---|
| committer | Schark <jordan@schark.online> | 2026-09-29 23:36:45 -0400 |
| commit | 8af1210d45c3fa3f41a174d2906ab597dcc22f1c (patch) | |
| tree | 43f1a9814faae852af943f71de53d4ca38dc6cd2 | |
| parent | fdc8c951fc72d9dc4c8faa58a21b2b9de0599698 (diff) | |
| download | gamedev-8af1210d45c3fa3f41a174d2906ab597dcc22f1c.tar.gz gamedev-8af1210d45c3fa3f41a174d2906ab597dcc22f1c.zip | |
| -rw-r--r-- | platformer/README.md | 9 | ||||
| -rw-r--r-- | platformer/game_feel.md | 58 | ||||
| -rw-r--r-- | platformer/src/camera.c | 105 | ||||
| -rw-r--r-- | platformer/src/camera.h | 13 | ||||
| -rw-r--r-- | platformer/src/config.h | 14 | ||||
| -rw-r--r-- | platformer/src/level.c | 40 | ||||
| -rw-r--r-- | platformer/src/level.h | 4 | ||||
| -rw-r--r-- | platformer/src/main.c | 9 | ||||
| -rw-r--r-- | platformer/src/physics.c | 46 | ||||
| -rw-r--r-- | platformer/src/physics.h | 4 | ||||
| -rw-r--r-- | platformer/src/player.c | 44 | ||||
| -rw-r--r-- | platformer/src/player.h | 11 | ||||
| -rw-r--r-- | platformer/src/render.c | 6 | ||||
| -rw-r--r-- | platformer/src/world.c | 18 | ||||
| -rw-r--r-- | platformer/src/world.h | 11 |
15 files changed, 352 insertions, 40 deletions
diff --git a/platformer/README.md b/platformer/README.md index 9adbe7b..4d79ed0 100644 --- a/platformer/README.md +++ b/platformer/README.md @@ -110,6 +110,10 @@ arrow keys = camera, C = recenter camera, Space = jump, R = reset, Esc = quit. ## Architecture +**Terms:** an **object** is anything solid in the game world: a platform, cliff, pillar, wall or +moving platform (all boxes). A **zone** is a non-solid region where an effect applies (such as the +locked-pan zone). Zones are box-shaped too, but they're never objects: nothing collides with them. + | File | Purpose | |---|---| | `src/main.c` | Entry point. Starts every module, runs the fixed-timestep game loop, shuts down. | @@ -132,7 +136,7 @@ controls ──► window (keyboard fallback needs the window handle) player ──► physics, world, controls (Input struct only) physics ──► world world ──► level (level.c only uses world.h's Box type; it never calls world) -camera ──► controls (Input struct only) +camera ──► controls (Input struct only), world (keeps the eye out of objects) render ──► player, camera, world (reads only, never modifies) everything ──► config.h, math3d.h ``` @@ -192,8 +196,7 @@ Suggested fill-in order (each step can be compiled before moving on): ## Roadmap (explicitly *not* now) -- Richer level geometry: slopes, moving platforms, step-up onto small ledges, hand-built or loaded levels -- Camera collision (the camera can currently pass through tall platforms) +- Richer level geometry: slopes, hand-built or loaded levels (moving platforms and stairs exist) - Loading levels - SM64-style extra moves: triple jump, long jump, ground pound (the second jump, the skid's retreat jump and the wall hang/wall jump exist) diff --git a/platformer/game_feel.md b/platformer/game_feel.md index 602ded0..68d650f 100644 --- a/platformer/game_feel.md +++ b/platformer/game_feel.md @@ -123,11 +123,12 @@ and eased, not snappier. (`heightened_movement`, 0.2 s), so skid → retreat jump → second jump chains. `heightened_movement` is also on for the whole retreat jump, so it can grab a wall. - **`heightened_movement` rules, all in one place.** It's on during the second jump, retreat jump, - every wall jump and every wall hang, and for a 0.2 s window after landing a normal or retreat jump - (the window only counts down while not in a jump). It is **not** on during a plain first jump, so a + every wall jump and every wall hang, and for a 0.2 s window after **any landing except the second + jump's**: a normal or retreat jump, or a plain fall (walking off a platform, letting go of a wall), so + walking off a ledge sets up a second jump. The window only counts down while not in a jump. It is **not** on during a plain first jump, so a single jump can't grab a wall. **We tried it the other way:** players expected to wall hang off one jump, but it made wall hangs too strong, so it was reverted. It turns off when the window runs out, - when landing a second jump or plain fall, or when a wall hang runs out. On the ground it means "A + when landing a second jump, or when a wall hang runs out. On the ground it means "A gives the second jump"; in the air it means "can wall hang". - **The wall hang (`WALL_HANG`).** Grabbing a wall needs all of these: `heightened_movement` is on, the player is in the air (JUMP or FALL), they hit the side of a box with `allows_wall_hang`, and @@ -234,6 +235,18 @@ keep this model or you'll lose several properties below at once. otherwise look like a 100 m sprint. - **Floor guard:** the eye never drops below `CAMERA_MIN_HEIGHT` (0.5 m) above the player's feet, so it stays out of the floor at low pitch. +- **The camera never goes INTO objects** (solid boxes; zones never count). Objects **between** the + player and the camera are fine: a platform in the shot stays in the shot (checked: a cliff strip in + the line of sight leaves the camera at its full 10 m). Only when the spot the eye wants is **inside** + an object does the eye **jump through it at once** to its near side, along the line to the player + (so the player stays on the same screen spot). When the spot is free again, it **eases back out**, + the same speed-up, cruise, brake style as the auto-tilt (`CAMERA_RETURN_ACCEL` 3 m/s², + `CAMERA_RETURN_SPEED` 3 m/s; doubled from 1.5 / 1.5 after feedback; a 6 m return takes ~3.0 s). + If that way out would pass into an object, it jumps through to the far side instead of stopping + inside. **History:** the first version also pulled in whenever an object merely blocked the line + of sight; the user wanted objects in view to stay in view. Measured: the wanted spot inside the + far cliff puts the eye at the cliff's face (0.25 m off it), and in 10 s of orbiting the eye was + never inside an object. ### Manual camera control @@ -259,6 +272,10 @@ New automatic camera behaviors should follow the same approach: slow, eased, and ## Level and collision +**Terms:** *objects* are solid gameworld boxes (platforms, cliffs, pillars, walls, moving platforms). +*Zones* are non-solid regions where an effect applies (locked-pan). Even though zones are box-shaped, +they are not objects, and nothing collides with them. + > **Platform size rule: platforms are ~5 m across at minimum.** Only the most extreme challenges > (or secrets) go smaller. **Why:** the player is heavy. Starts build up, stops skid for half a > second, and a normal jump lands with momentum. At this size or larger, the player feels they have @@ -336,8 +353,7 @@ New automatic camera behaviors should follow the same approach: slow, eased, and the face are singles, so they can't grab the face on an overshoot. - **The river** is 13 overlapping water tiles (`BOX_STYLE_WATER`, a solid 5 cm sheet, no swimming) along the diagonal, parallel to the third side. - - **Known rough edges:** there's no camera collision, so the camera passes into the cliff and - through platforms (it's even more noticeable here). A fall from the top is a 55 m drop with no + - **Known rough edges:** a fall from the top is a 55 m drop with no damage, and Back resets. Jumping off a moving platform doesn't keep its momentum (SM64 mostly doesn't either). Changing the seed gives a new climb; re-run the course test if you do, or after changing movement numbers. @@ -356,6 +372,28 @@ New automatic camera behaviors should follow the same approach: slow, eased, and - The floor check uses the height *before* the move, so even a terminal-velocity fall can't tunnel through a 0.5 m slab. - Jumping into an underside bonks. + - **Stairs: ledges under `STEP_HEIGHT` (0.25 m, raised from 0.2) are walked, not jumped.** On the ground, walking into + an object whose top is less than 0.2 m above the feet (with room up there) lifts the body onto it. + Walking off one onto a floor less than 0.2 m below snaps down to it. The body never leaves the + ground, so there's **no FALL state and no landing, and so no `heightened_movement` window**. Taller + drops still fall normally. Test staircases, east of spawn: **stairwell 1**, 40 steps of 0.2 m × 0.5 m + (20 m long, 8 m tall, z −2..2); **stairwell 2**, 100 steps of 0.2 m × **0.12 m** (12 m long, 20 m + tall, z 4..8). **Minimum stair depth ≈ one tick of travel:** the step logic handles one stair per + tick, and the fastest the player moves is 7 m/s ÷ 60 = 0.117 m, so shallower steps get crossed two + at a time and block the climb. Tested: 0.05 and 0.08 m can't be climbed, 0.10 m fails running + down at 7 m/s, and 0.11 m and up work. (Sub-stepping the horizontal move would lift this limit; + not done.) Measured: up in 3.9 s and down in 4.1 s at full 6 m/s, with 0 ticks in FALL, 0 off + the ground, and 0 heightened either way. Jumping on a stair still jumps. + - **Stairs look smooth without being ramps.** Physics still steps the body a whole stair in one + tick (collision and timing stay exact), but it reports each step (`Body.step_dy`). The player + keeps a `visual_offset` that cancels the step and glides back to 0 at `STEP_SMOOTH_RATE` + (14 /s). `player_visual_pos()` is where the box is **drawn** and what the **camera follows**; + gameplay, the shadow and zones use the real position. This works on any ledge under 0.2 m, not + just the test stairs, and real jumps and landings are never smoothed. Measured climbing at 6 m/s: + per-tick height unevenness goes from 0.060 m (raw) to 0.010 m drawn and 0.009 m for the camera, + and the biggest one-tick change from 0.15 m to 0.045 m. The drawn body lags the real height by up + to 0.17 m (about one stair). Lower the rate for smoother (8 → 0.006 m, but a 0.27 m lag) or raise + it for tighter (18 → 0.0125 m, 0.14 m lag). - Every push out of a box's side sets `Body.hit_wall`, the side's `wall_normal` and its `wall` box. That's how the wall hang knows what it touched. `Body.gravity_scale` (normally 1) lets the player switch gravity off while it drives its own wall slide. @@ -387,9 +425,8 @@ New automatic camera behaviors should follow the same approach: slow, eased, and slower runs is listed under `NOT IN SCOPE` in `player.c`. - **High-angle auto-tilt resets are long** (60° → 15° takes about 15.7 s of motion). For big tilts the top speed (`CAMERA_AUTO_PITCH_SPEED`) sets the time; for small ones, the acceleration does. -- **No camera collision:** the camera can pass through tall platforms (it's on the roadmap). -- **Rough edges not yet addressed:** there's no step-up (even a 0.6 m block needs a jump); - `forward_speed` isn't reduced by walls (the title shows 6 m/s while pushing into one); the drawn +- **Rough edges not yet addressed:** ledges of 0.2 m or more still need a jump (by design; stairs + under 0.2 m are walked); `forward_speed` isn't reduced by walls (the title shows 6 m/s while pushing into one); the drawn box rotates but the collision box doesn't (up to about 17 cm visual overlap with walls at diagonals). @@ -428,6 +465,11 @@ New automatic camera behaviors should follow the same approach: slow, eased, and | Skid pull-back angle | 120° → 130° (must pull more squarely back) | 130° | | First jump heightened (revert) | on → off again (wall hangs off one jump were too strong); clear-the-top rule kept | off | | Cliff course platforms | 3–4.5 m → 4–6 m, 1.5–13 m out from the face, heights on a 1.5 m tier grid, no back-to-back doubles, far cliff 60 → 58 m | 39 | +| Second-jump window from falls | walking off an edge closed it → any landing but the second jump's opens it | on | +| Step height | none (any ledge needed a jump) → ledges under 0.2 m walked up/down, no fall → 0.25 m | 0.25 m | +| Stair smoothing | none (visual pop per step) → drawn/camera height glides at 14 /s | 14 /s | +| Camera vs. objects | passes through → snaps in front of any object in the line of sight → only when the eye would be INSIDE one (objects in view stay in view); eases back out at 1.5 → 3 m/s (accel 1.5 → 3) | 3 m/s | +| Locked-pan zones | none → one box round the cliff (ground to the 55 m top): no auto swing inside | 1 zone | | Second jump top speed | 6 m/s (same as running) → 4 → 5 m/s until it lands (4 felt a tad harsh) | 5 m/s | | Second jump slowdown | air accel 9 m/s² (0.25 s, "wall of syrup") → own rate 3.5 m/s² (0.60 s) | 3.5 m/s² | | Skid | none (full-speed U-turn) → 18 m/s² even braking, turn at the end (0.33 s) → face the stick at once, glide-then-plant curve (power 2) | 0.5 s | diff --git a/platformer/src/camera.c b/platformer/src/camera.c index 7663003..b11f6bb 100644 --- a/platformer/src/camera.c +++ b/platformer/src/camera.c @@ -130,7 +130,18 @@ * Framing is in NDC so it matches what you see on screen, and it * converts to meters via depth * tan(fov/2) (times aspect for x). * - * NOT IN SCOPE: Camera collision, snapping directly behind the player on its + * - Step 7, objects (keep_eye_clear): the eye never sits INSIDE an object + * (world_object_at; zones never count). Objects BETWEEN the player and the + * eye are fine: a platform in the shot stays in the shot. Only when the + * spot the eye wants is inside an object does the eye jump THROUGH it, the + * same tick, to the object's near side, along its line to the player (so + * the player stays on the same screen spot and the framing model is + * untouched). When the wanted spot is free again, ease the eye back out: + * speed up at CAMERA_RETURN_ACCEL, cruise at CAMERA_RETURN_SPEED, brake to + * arrive exactly (like the auto-tilt). If that path would take it into an + * object, it jumps through to the far side instead of stopping inside. + * + * NOT IN SCOPE: Snapping directly behind the player on its * own (only the recenter button does that), shake, vertical * look-ahead. (Good candidates for later tuning, not for now.) * @@ -151,6 +162,7 @@ #include "camera.h" #include "config.h" +#include "world.h" #define THIRD (1.0f / 3.0f) /* the thirds lines, as window fractions */ #define STILL_EPSILON 1e-5f /* m moved per tick below which the player is "still" */ @@ -236,6 +248,90 @@ static void orbit(Camera *c, const Input *in, float dt) /* Auto-pitch: after CAMERA_AUTO_PITCH_DELAY seconds of the camera not being * moved by hand, slowly tilt to the preferred downward viewing angle. The * timer is capped at the delay so it can't grow forever. */ +/* Where the line from `from` along `dir` enters and leaves box b grown by + * `radius` (the slab test: along each axis the line is inside the box's + * range between two distances; it's inside the box where all three ranges + * overlap). */ +static void line_through_box(Vec3 from, Vec3 dir, Box b, float radius, float *enter, float *leave) +{ + float lo[3] = { b.min.x - radius, b.min.y - radius, b.min.z - radius }; + float hi[3] = { b.max.x + radius, b.max.y + radius, b.max.z + radius }; + float o[3] = { from.x, from.y, from.z }; + float d[3] = { dir.x, dir.y, dir.z }; + *enter = -1e9f; + *leave = 1e9f; + for (int axis = 0; axis < 3; axis++) { + if (fabsf(d[axis]) < 1e-6f) + continue; /* parallel: the point is inside this slab (it was found inside the box) */ + float t0 = (lo[axis] - o[axis]) / d[axis]; + float t1 = (hi[axis] - o[axis]) / d[axis]; + *enter = fmaxf(*enter, fminf(t0, t1)); + *leave = fminf(*leave, fmaxf(t0, t1)); + } +} + +/* Moves a distance along the eye line out of any object it's inside: toward + * the player (`toward_player`), to that object's near side, or away from + * them, to its far side. A few passes, since objects can touch or overlap. */ +static float step_out_of_objects(Vec3 subject, Vec3 dir, float distance, bool toward_player) +{ + for (int pass = 0; pass < 4; pass++) { + Box hit; + if (!world_object_at(vec3_add(subject, vec3_scale(dir, distance)), CAMERA_COLLISION_RADIUS, &hit)) + break; + float enter, leave; + line_through_box(subject, dir, hit, CAMERA_COLLISION_RADIUS, &enter, &leave); + distance = toward_player ? fmaxf(enter, 0.0f) : leave; + } + return distance; +} + +/* The eye never sits inside an object. An object may be between the player + * and the eye (a platform in the shot is fine); only when the eye itself + * would end up inside one does it jump THROUGH it, the same tick, to the + * object's near side (the player's side), along its line to the player, so + * the player stays on the same screen spot and the framing is untouched. + * When the wanted spot is free again, the eye eases back out (speed up, + * cruise, brake, like the auto-tilt) instead of popping; if that path takes + * it into an object, it jumps through to the far side rather than stopping + * inside. Zones never count. */ +static void keep_eye_clear(Camera *c, float dt) +{ + Vec3 to_eye = vec3_sub(c->position, c->subject); + float wanted = vec3_length(to_eye); + if (wanted < 1e-4f) + return; + Vec3 dir = vec3_scale(to_eye, 1.0f / wanted); + float allowed = step_out_of_objects(c->subject, dir, wanted, true); + bool blocked = allowed < wanted - 1e-4f; + + if (allowed <= c->eye_distance || !c->pulled_in) { + /* The wanted spot is inside an object nearer than we are (jump in + * now), or we're not recovering: simply sit where allowed. */ + c->eye_distance = allowed; + c->return_speed = 0.0f; + c->pulled_in = blocked; + } else { + /* Free further out again: ease back toward it. */ + float remaining = allowed - c->eye_distance; + float brake_limit = sqrtf(2.0f * CAMERA_RETURN_ACCEL * remaining); + c->return_speed = fminf(c->return_speed + CAMERA_RETURN_ACCEL * dt, + fminf(CAMERA_RETURN_SPEED, brake_limit)); + float next = c->eye_distance + c->return_speed * dt; + next = fminf(step_out_of_objects(c->subject, dir, next, false), allowed); + if (next >= allowed) { + next = allowed; + c->return_speed = 0.0f; + c->pulled_in = blocked; + } + c->eye_distance = next; + } + + Vec3 look = vec3_sub(c->target, c->position); /* keep looking the same way */ + c->position = vec3_add(c->subject, vec3_scale(dir, c->eye_distance)); + c->target = vec3_add(c->position, look); +} + static void auto_pitch(Camera *c, const Input *in, float dt) { bool touched = in->look.x != 0.0f || in->look.y != 0.0f || in->recenter_pressed; @@ -394,6 +490,10 @@ void camera_init(Camera *c, Vec3 follow_point) c->auto_pitch_speed = 0.0f; /* The aspect ratio only matters for a non-zero framing, which is 0 here. */ place_camera(c, 1.0f); + c->eye_distance = vec3_length(vec3_sub(c->position, c->subject)); + c->pulled_in = false; + c->return_speed = 0.0f; + keep_eye_clear(c, 0.0f); } void camera_update(Camera *c, const Input *in, Vec3 follow_point, float follow_facing, @@ -460,8 +560,9 @@ void camera_update(Camera *c, const Input *in, Vec3 follow_point, float follow_f if (c->framing.y > max_y) c->framing.y = max_y; - /* 6. Derive the eye from the framing. */ + /* 6. Derive the eye from the framing, then keep it out of objects. */ place_camera(c, aspect); + keep_eye_clear(c, dt); } float camera_yaw(const Camera *c) diff --git a/platformer/src/camera.h b/platformer/src/camera.h index 7dc2cc1..eeafe6c 100644 --- a/platformer/src/camera.h +++ b/platformer/src/camera.h @@ -32,6 +32,11 @@ * CAMERA_AUTO_PITCH_DELAY; drives the auto-pitch * float auto_pitch_speed; current auto-pitch speed, rad/s (>= 0), so the * tilt can ease in and out instead of moving linearly + * float eye_distance; how far the eye really is from the player along + * its line of sight (shorter than wanted when an + * object is in the way) + * bool pulled_in; an object pulled the eye in and it's easing back + * float return_speed; m/s of that ease back out * } Camera; * * void camera_init(Camera *c, Vec3 follow_point); @@ -61,8 +66,9 @@ * * CONVENTIONS: Include guard: CAMERA_H. * - * NOT IN SCOPE: Collision with geometry, automatic "behind the player" - * rotation, cutscene/fixed cameras, zoom levels. + * NOT IN SCOPE: Automatic "behind the player" rotation, cutscene/fixed + * cameras, zoom levels. (The eye does stay out of objects: see + * camera.c step 7.) * * DONE WHEN: player.c and render.c can be written against this header alone. * ============================================================ @@ -88,6 +94,9 @@ typedef struct Camera { float recenter_yaw; /* the yaw that glide is headed for */ float hands_off_time; /* s since the camera was last moved by hand (capped) */ float auto_pitch_speed; /* current auto-pitch speed, rad/s (>= 0), for easing */ + float eye_distance; /* how far the eye actually is from the player along its line of sight */ + bool pulled_in; /* an object pulled the eye in; it's easing back out */ + float return_speed; /* current speed of that ease back out, m/s */ } Camera; void camera_init(Camera *c, Vec3 follow_point); diff --git a/platformer/src/config.h b/platformer/src/config.h index 86677ac..58520ab 100644 --- a/platformer/src/config.h +++ b/platformer/src/config.h @@ -95,6 +95,11 @@ * GRAVITY 40.0f m/s^2 (stronger than real 9.8 on purpose: * platformers feel floaty with real gravity) * TERMINAL_VELOCITY 50.0f m/s max fall speed + * STEP_HEIGHT 0.25f m; a grounded body walks up or down any ledge + * lower than this (stairs), with no jump or fall + * STEP_SMOOTH_RATE 14.0f 1/s; how fast the DRAWN and camera-followed + * height catches up after a stair step (physics + * steps instantly; this hides the pop) * * Player: size (used by render, and later by collision) * PLAYER_HALF_WIDTH 0.4f m @@ -130,6 +135,10 @@ * CAMERA_AUTO_PITCH_SPEED 0.054f rad/s; top speed of that tilt * CAMERA_AUTO_PITCH_ACCEL 0.045f rad/s^2; how gently the tilt speeds up * and slows down (ease in/out) + * CAMERA_COLLISION_RADIUS 0.25f m the eye keeps from objects + * CAMERA_RETURN_SPEED 3.0f m/s top speed the eye slides back out once an + * object stops blocking it (it snaps IN at once) + * CAMERA_RETURN_ACCEL 3.0f m/s^2 ease in/out of that return * CAMERA_FOV_DEG 60.0f vertical field of view * CAMERA_NEAR 0.1f * CAMERA_FAR 500.0f @@ -216,6 +225,8 @@ /* ---- Physics ----------------------------------------------------------- */ #define GRAVITY 40.0f /* m/s^2; stronger than real 9.8 on purpose, real gravity feels floaty */ +#define STEP_HEIGHT 0.25f /* m; ledges lower than this are walked up/down (stairs): no jump, no fall */ +#define STEP_SMOOTH_RATE 14.0f /* 1/s the drawn/camera height glides onto the body after a stair step; lower = smoother, laggier */ #define TERMINAL_VELOCITY 50.0f /* m/s max fall speed; lower = long falls feel more controlled */ /* ---- Player: size (used by render, and later by collision) ------------- */ @@ -243,6 +254,9 @@ #define CAMERA_AUTO_PITCH_DEG 15.0f /* degrees above horizontal the camera prefers to look down at the player */ #define CAMERA_AUTO_PITCH_SPEED 0.054f /* rad/s top tilt speed toward that angle; lower = slower, subtler tilt */ #define CAMERA_AUTO_PITCH_ACCEL 0.045f /* rad/s^2 ease in/out of the tilt; lower = softer start and stop */ +#define CAMERA_COLLISION_RADIUS 0.25f /* m the eye keeps from objects (never zones) */ +#define CAMERA_RETURN_SPEED 3.0f /* m/s top speed back out after an object stopped blocking; lower = slower, calmer */ +#define CAMERA_RETURN_ACCEL 3.0f /* m/s^2 ease in/out of that return, like the auto-tilt */ #define CAMERA_FOV_DEG 60.0f /* vertical field of view, degrees; higher = wider, faster-feeling view */ #define CAMERA_NEAR 0.1f /* m; near clip plane */ #define CAMERA_FAR 500.0f /* m; far clip plane (must reach past the world edge) */ diff --git a/platformer/src/level.c b/platformer/src/level.c index 3ae45be..34e03c3 100644 --- a/platformer/src/level.c +++ b/platformer/src/level.c @@ -89,6 +89,10 @@ * choice ("how do I get up there?") instead of one correct jump after * another, and the route makes sure a way up always exists. * + * 4. Two test staircases east of spawn, 0.2 m steps (under STEP_HEIGHT): + * stairwell 1 (z -2..2) has 40 steps 0.5 m deep (20 m long, 8 m tall); + * stairwell 2 (z 4..8) has 100 steps 0.12 m deep (12 m long, 20 m tall): + * the shallowest steps the step-up can take at full speed, for fun. * - level_build_zones(): TEST_ZONES, hand-placed. One locked-pan zone covers the * whole cliff and its climb band (south and east faces, out to where the * climb platforms reach), from the ground up to exactly CLIFF_TOP, so the @@ -900,6 +904,40 @@ static void add_crossing(void) } } +/* ---- 4. The staircase -------------------------------------------------- */ + +/* Two test staircases east of spawn, side by side, each 4 m wide. Every step + * is lower than STEP_HEIGHT (0.25 m), so the player walks up them, never + * jumping. */ +#define STAIR_START_X 32.0f /* m, both staircases' bottom step starts here */ +#define STAIR_WIDTH 4.0f /* m */ +#define STAIR_RISE 0.2f /* m high per step (under STEP_HEIGHT) */ +/* Stairwell 1: 40 steps 0.5 m deep: 20 m long, 8 m tall. */ +#define STAIR1_Z -2.0f /* m, its south edge */ +#define STAIR1_RUN 0.5f +#define STAIR1_COUNT 40 +/* Stairwell 2 (for fun): 100 steps as shallow as the step-up allows: 12 m + * long, 20 m tall. WHY 0.12 m: the step-up/down handles one stair per tick, + * and the fastest the player moves in a tick is 7 m/s / 60 = 0.117 m. A + * shallower step gets crossed two at a time and blocks the climb (tested: + * 0.10 m fails running down at 7 m/s, 0.11 m and up work). */ +#define STAIR2_Z 4.0f +#define STAIR2_RUN 0.12f +#define STAIR2_COUNT 100 + +/* One staircase rising toward +x: `count` steps `run` deep and STAIR_RISE + * high, each a box from the ground up to its step. */ +static void add_staircase(float south_z, float run, int count) +{ + for (int i = 0; i < count; i++) { + float x = STAIR_START_X + run * (float)i; + Box step = { { x, 0.0f, south_z }, + { x + run, STAIR_RISE * (float)(i + 1), south_z + STAIR_WIDTH }, + false, BOX_STYLE_PLATFORM }; + add_box(step, no_motion()); + } +} + /* ---- Zones ------------------------------------------------------------- */ /* Non-solid regions (see world.h). Bounds: min corner, max corner; the Box's @@ -932,6 +970,8 @@ int level_build(LevelBox *out, int capacity) add_rock_pillars(); add_scatter(); add_crossing(); + add_staircase(STAIR1_Z, STAIR1_RUN, STAIR1_COUNT); /* last, so the cliff course's boxes keep their order */ + add_staircase(STAIR2_Z, STAIR2_RUN, STAIR2_COUNT); return s_count; } diff --git a/platformer/src/level.h b/platformer/src/level.h index b66414e..6984f19 100644 --- a/platformer/src/level.h +++ b/platformer/src/level.h @@ -32,7 +32,7 @@ * typedef struct LevelBox { Box box; BoxMotion motion; } LevelBox; * box is where the box sits at offset 0. * - * #define LEVEL_MAX_BOXES 256 + * #define LEVEL_MAX_BOXES 384 * #define LEVEL_MAX_ZONES 16 * int level_build(LevelBox *out, int capacity); * Fills out[] with every box in the level and returns how many. @@ -77,7 +77,7 @@ typedef struct LevelBox { BoxMotion motion; } LevelBox; -#define LEVEL_MAX_BOXES 256 +#define LEVEL_MAX_BOXES 384 #define LEVEL_MAX_ZONES 16 int level_build(LevelBox *out, int capacity); diff --git a/platformer/src/main.c b/platformer/src/main.c index 8e1d139..040ad37 100644 --- a/platformer/src/main.c +++ b/platformer/src/main.c @@ -39,8 +39,10 @@ * camera_init(&camera, player.body.pos); // see WHY below * player_update(&player, &input, camera_yaw(&camera), TICK_DT); * pan_locked = world_in_zone(player's body center, ZONE_LOCKED_PAN); - * camera_update(&camera, &input, player.body.pos, player.facing_yaw, - * pan_locked, window_aspect(), TICK_DT); + * camera_update(&camera, &input, player_visual_pos(&player), + * player.facing_yaw, pan_locked, window_aspect(), TICK_DT); + * (the visual position smooths stair steps, so the camera + * doesn't jolt on stairs) * accumulator -= TICK_DT; * * render_frame(&camera, &player, window_aspect(), fps); @@ -178,7 +180,8 @@ int main(void) /* In a locked-pan zone the camera doesn't swing behind the player. */ Vec3 body_center = vec3_add(player.body.pos, vec3_make(0.0f, 0.5f * PLAYER_HEIGHT, 0.0f)); pan_locked = world_in_zone(body_center, ZONE_LOCKED_PAN); - camera_update(&camera, &input, player.body.pos, player.facing_yaw, + /* The camera follows the smoothed position, so stairs don't jolt it. */ + camera_update(&camera, &input, player_visual_pos(&player), player.facing_yaw, pan_locked, window_aspect(), TICK_DT); accumulator -= TICK_DT; } diff --git a/platformer/src/physics.c b/platformer/src/physics.c index 4e842f6..07bc38a 100644 --- a/platformer/src/physics.c +++ b/platformer/src/physics.c @@ -29,6 +29,9 @@ * 2. Move X: pos.x += vel.x * dt. If the body now overlaps a box * (world_find_overlap), push it back out on the side it came from and * zero vel.x. Repeat a few times in case the push lands in another box. + * Step up first: if the body was on the ground and the box's top is less + * than STEP_HEIGHT above the feet, and there's room there, lift the body + * onto it instead of pushing it back (walking up a stair; no hit_wall). * Each push records hit_wall = true, the side's outward normal (moving * +x into a box means its -x side, normal (-1, 0, 0)) and the box, so the * owner can react to walls (the player's wall hang). @@ -40,7 +43,13 @@ * Floor: floor = world_floor_below((x, prev_y, z), half_width, &box), * the highest surface the feet were above at the START of the move. * If pos.y <= floor: land (pos.y = floor, vel.y = 0 if falling, - * on_ground = true, ground_box = box). Otherwise ground_box = -1. Using prev_y means a fast fall can never skip + * on_ground = true, ground_box = box). Step down: if the body WAS on + * the ground, isn't moving up, and the floor is less than STEP_HEIGHT + * below where the feet were, snap down onto it the same way, so + * walking down a stair never leaves the ground (no fall, no landing). + * Both stair moves add to step_dy (reset each step), which the owner + * uses to smooth the visual pop; the collision itself stays exact. + * Otherwise ground_box = -1. Using prev_y means a fast fall can never skip * through a thin platform between two ticks. * Otherwise on_ground = false, and check the ceiling the same way from * the previous head height: if the head crossed a box bottom, stop at @@ -52,7 +61,7 @@ * than the constant so the function stays general. * * NOT IN SCOPE: Friction/acceleration (that's player movement *intent*, in - * player.c), slopes, step-up onto small ledges, sub-stepping. + * player.c), slopes, sub-stepping. * * DONE WHEN: A body placed at y = 10 falls, speeds up, lands exactly on * y = 0 with on_ground = true, and stays there. It lands on @@ -117,12 +126,33 @@ static void step_out_of_boxes(Body *b) /* Pushes the body out of any box it overlaps along ONE horizontal axis, * back toward where it came from. pos_axis/vel_axis point at the x or z * members of the body, so the same code handles both axes. */ +/* Step 2-3: walking into a box whose top is less than STEP_HEIGHT above the + * feet (a stair) lifts the body onto it, if there's room up there, instead + * of stopping it. Only on the ground: jumps and falls collide as usual. */ +static bool step_up_onto(Body *b, Box hit) +{ + float rise = hit.max.y - b->pos.y; + if (!b->on_ground || rise <= 0.0f || rise >= STEP_HEIGHT) + return false; + Vec3 raised = vec3_make(b->pos.x, hit.max.y, b->pos.z); + Box above; + if (world_find_overlap(raised, b->half_width, b->height, &above)) + return false; /* no room up there: it's a wall after all */ + b->step_dy += hit.max.y - b->pos.y; /* reported so the owner can smooth the pop */ + b->pos.y = hit.max.y; + if (b->vel.y < 0.0f) + b->vel.y = 0.0f; + return true; +} + static void resolve_axis(Body *b, float *pos_axis, float *vel_axis, bool axis_is_x) { for (int pass = 0; pass < MAX_PUSH_PASSES; pass++) { Box hit; if (!world_find_overlap(b->pos, b->half_width, b->height, &hit)) return; + if (step_up_onto(b, hit)) + continue; /* stepped up a stair: check again from the new height */ float box_min = axis_is_x ? hit.min.x : hit.min.z; float box_max = axis_is_x ? hit.max.x : hit.max.z; float side; /* which way the touched side faces along this axis */ @@ -147,7 +177,8 @@ static void resolve_axis(Body *b, float *pos_axis, float *vel_axis, bool axis_is /* Step 4: vertical movement with floor and ceiling. */ static void move_vertically(Body *b, float dt) { - float prev_y = b->pos.y; + float prev_y = b->pos.y; + bool was_grounded = b->on_ground; /* Semi-implicit Euler: vel.y was already updated by gravity, and the * position moves with that NEW velocity. Unlike plain Euler (which uses * the old velocity) it doesn't gain energy over time, and with a fixed dt @@ -160,7 +191,13 @@ static void move_vertically(Body *b, float dt) * first one it crossed, no matter how fast it was going. */ int floor_box; float floor_y = world_floor_below(vec3_make(b->pos.x, prev_y, b->pos.z), b->half_width, &floor_box); - if (b->pos.y <= floor_y) { + /* Land on it, or, walking off a stair (the floor just under STEP_HEIGHT + * below and we weren't going up), step down onto it without leaving the + * ground. */ + bool step_down = was_grounded && b->vel.y <= 0.0f && prev_y - floor_y < STEP_HEIGHT; + if (b->pos.y <= floor_y || step_down) { + if (b->pos.y > floor_y) + b->step_dy += floor_y - prev_y; /* a stair down, not a landing: report it */ b->pos.y = floor_y; if (b->vel.y < 0.0f) b->vel.y = 0.0f; @@ -186,6 +223,7 @@ void physics_step(Body *b, float dt) /* 0. Walls are reported fresh every step. Ride whatever we stand on, and * step out of anything that moved into us. */ b->hit_wall = false; + b->step_dy = 0.0f; ride_ground_box(b); step_out_of_boxes(b); diff --git a/platformer/src/physics.h b/platformer/src/physics.h index 9da41ac..9976aca 100644 --- a/platformer/src/physics.h +++ b/platformer/src/physics.h @@ -28,6 +28,9 @@ * Vec3 wall_normal; that side's outward normal (+-x or +-z, y = 0); * only meaningful if hit_wall * Box wall; the box that side belongs to; only meaningful if hit_wall + * float step_dy; how far a stair step moved the body up (+) or down (-) + * during the last step (0 if it didn't step), so the + * owner can smooth the pop out of what it draws * int ground_box; index (world_box) of the box the body stands on, or -1 * for the ground / in the air. Used to ride moving boxes. * } Body; @@ -64,6 +67,7 @@ typedef struct Body { Vec3 wall_normal; /* that side's outward normal (+-x or +-z); only if hit_wall */ Box wall; /* the box that side belongs to; only if hit_wall */ int ground_box; /* world_box index stood on (-1 = ground or airborne); for riding moving boxes */ + float step_dy; /* m a stair step moved the body this step (+ up, - down; 0 if none), for smoothing visuals */ } Body; void physics_step(Body *b, float dt); diff --git a/platformer/src/player.c b/platformer/src/player.c index 9f0e822..429baa8 100644 --- a/platformer/src/player.c +++ b/platformer/src/player.c @@ -98,11 +98,12 @@ * jump_kind = JUMP_NORMAL. heightened_movement stays OFF, so a * first jump can't grab walls (tried; it made wall hangs too easy). * - * 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 + * C2. Landing: every landing turns heightened_movement on with + * heightened_timer = PLAYER_SECOND_JUMP_WINDOW (after a normal jump, + * a retreat jump, or a plain fall: walking off a platform, letting go + * of a wall), so any of them can lead into the second jump. The one + * exception is landing the second jump itself: that turns it off, so + * second jumps can't chain. Every * landing turns retreating_movement off and resets jump_kind to * JUMP_NONE, and clears has_last_wall. The heightened timer counts * down (turning it off at 0) only while jump_kind == JUMP_NONE and @@ -187,6 +188,13 @@ * body.gravity_scale = 0 in WALL_HANG, else 1. * Then physics_step(&p->body, dt). * + * G. Stairs look smooth: after physics_step, visual_offset -= body.step_dy + * (so the drawn height stays put when physics steps a stair), clamped to + * +-2 * STEP_HEIGHT, then decays toward 0 by exp(-STEP_SMOOTH_RATE * dt). + * player_visual_pos() = body.pos + (0, visual_offset, 0): render.c draws + * the player there and main.c points the camera at it. Gameplay, the + * shadow and zones all use the real body.pos. + * * - player_state_name: a switch that returns string literals. * * CONVENTIONS: Facing vector = (sin(yaw), 0, cos(yaw)). Speeds are in m/s, @@ -336,13 +344,14 @@ static void start_retreat_jump(Player *p) 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. */ +/* C2. Touching down. Every landing opens the short window for the second + * jump (after a normal or retreat jump, and after a plain fall such as + * walking off a platform or letting go of a wall), EXCEPT landing the + * second jump itself, so second jumps can't chain. Any landing ends a + * retreat jump's retreating_movement. */ static void land(Player *p) { - if (p->jump_kind == JUMP_NORMAL || p->jump_kind == JUMP_RETREAT) { + if (p->jump_kind != JUMP_SECOND) { p->heightened_movement = true; p->heightened_timer = PLAYER_SECOND_JUMP_WINDOW; } else { @@ -682,6 +691,8 @@ void player_init(Player *p, Vec3 spawn) p->skid_speed = 0.0f; p->skid_yaw = 0.0f; p->jump_buffer = 0.0f; + p->visual_offset = 0.0f; + p->body.step_dy = 0.0f; p->wall_time = 0.0f; p->wall_jump_yaw = 0.0f; p->has_last_wall = false; @@ -735,6 +746,19 @@ void player_update(Player *p, const Input *in, float camera_yaw, float dt) p->body.vel.z = cosf(move_yaw) * move_speed; p->body.gravity_scale = hanging ? 0.0f : 1.0f; physics_step(&p->body, dt); + + /* G. Stairs: physics lifts or drops the body a whole stair in one tick, + * which would pop on screen (and jolt the camera). Keep the DRAWN height + * where it was and let it glide onto the body, so stairs look smooth + * while collision and timing stay exact. Real jumps and landings aren't + * steps, so they're never smoothed. */ + p->visual_offset = clampf(p->visual_offset - p->body.step_dy, -2.0f * STEP_HEIGHT, 2.0f * STEP_HEIGHT); + p->visual_offset *= expf(-STEP_SMOOTH_RATE * dt); +} + +Vec3 player_visual_pos(const Player *p) +{ + return vec3_add(p->body.pos, vec3_make(0.0f, p->visual_offset, 0.0f)); } const char *player_state_name(PlayerState s) diff --git a/platformer/src/player.h b/platformer/src/player.h index 035a344..b39f4c5 100644 --- a/platformer/src/player.h +++ b/platformer/src/player.h @@ -36,7 +36,8 @@ * float forward_speed; ground speed along facing_yaw, m/s (>= 0) * PlayerState state; * bool heightened_movement; on for PLAYER_SECOND_JUMP_WINDOW s after - * landing a normal or retreat jump, and for the + * any landing except the second jump's (normal + * or retreat jump, or a plain fall), and for the * whole second jump, retreat jump, wall hang and * every wall jump (NOT a plain first jump). On the ground, A gives the second * jump; in the air, it lets the player wall hang. @@ -51,6 +52,9 @@ * float skid_speed; forward_speed when the skid began * float skid_yaw; direction the skid slides (the old run * direction; the player already faces the stick) + * float visual_offset; m the drawn height is off the body's feet after a + * stair step (physics steps instantly; this eases + * back to 0 at STEP_SMOOTH_RATE so it looks smooth) * float jump_buffer; s left on the last A press: while > 0, the first * moment a jump is possible, it happens * float wall_time; s since the current wall hang began @@ -67,6 +71,9 @@ * void player_init(Player *p, Vec3 spawn); * void player_reset(Player *p, Vec3 spawn); * void player_update(Player *p, const Input *in, float camera_yaw, float dt); + * Vec3 player_visual_pos(const Player *p); + * Where to DRAW the player and point the camera: body.pos, + * but with stair steps smoothed out (see visual_offset). * camera_yaw is a plain float so player.c doesn't depend on camera.h. * const char *player_state_name(PlayerState s); "IDLE", "RUN", ... for debug * @@ -122,6 +129,7 @@ typedef struct Player { float skid_time; /* s since the current skid began */ float skid_speed; /* forward_speed when the skid began */ float skid_yaw; /* direction the skid slides; facing_yaw already points at the stick */ + float visual_offset; /* m the drawn/followed height lags the body after stair steps; eases to 0 */ float jump_buffer; /* s left on the last A press; a jump fires as soon as one is possible */ float wall_time; /* s since the current wall hang began */ float wall_jump_yaw; /* a wall jump's launch direction: the approach mirrored off the wall */ @@ -133,6 +141,7 @@ typedef struct Player { void player_init(Player *p, Vec3 spawn); void player_reset(Player *p, Vec3 spawn); void player_update(Player *p, const Input *in, float camera_yaw, float dt); +Vec3 player_visual_pos(const Player *p); const char *player_state_name(PlayerState s); #endif /* PLAYER_H */ diff --git a/platformer/src/render.c b/platformer/src/render.c index 65237f5..3fd2ca6 100644 --- a/platformer/src/render.c +++ b/platformer/src/render.c @@ -60,7 +60,8 @@ * floor_y = world_floor_below(body.pos, body.half_width, NULL): the surface * the player would land on, whether that's the ground or a platform. * 7. Player box: - * model = translate(body.pos) * rotate_y(facing_yaw) + * model = translate(player_visual_pos()) * rotate_y(facing_yaw) + * (body.pos with stair steps smoothed out) * * scale(2*PLAYER_HALF_WIDTH, PLAYER_HEIGHT, 2*PLAYER_HALF_WIDTH) * Bright color (e.g. red). Also draw a small second box as a "nose" on * the front face (+Z in model space) so the facing direction is visible. @@ -459,7 +460,8 @@ static void draw_shadow(Mat4 vp, const Player *player) * so you can see which way it faces and tune the turn rate by eye. */ static void draw_player(Mat4 vp, const Player *player) { - Mat4 placed = mat4_mul(mat4_translate(player->body.pos), mat4_rotate_y(player->facing_yaw)); + /* The visual position smooths out stair steps (see player_visual_pos). */ + Mat4 placed = mat4_mul(mat4_translate(player_visual_pos(player)), mat4_rotate_y(player->facing_yaw)); Mat4 body = mat4_mul(placed, mat4_scale(vec3_make(2.0f * PLAYER_HALF_WIDTH, PLAYER_HEIGHT, diff --git a/platformer/src/world.c b/platformer/src/world.c index c999f41..4c088aa 100644 --- a/platformer/src/world.c +++ b/platformer/src/world.c @@ -29,7 +29,9 @@ * WORLD_NO_CEILING. * world_find_overlap: the first box that overlaps the body's full volume * (footprint AND height range). - * - Zones (level_build_zones()): stored separately from the boxes, so no + * - world_object_at(point, radius, hit): the first object (never a zone) + * that, grown by `radius` on every side, contains the point. + * - Zones (level_build_zones()): stored separately from the objects, so no * collision query ever sees them. world_in_zone(point, kind): is the point * inside (edges count) any zone of that kind. * - world_clamp_to_bounds, world_spawn_point (level_spawn_point()), @@ -176,6 +178,20 @@ Vec3 world_spawn_point(void) return level_spawn_point(); } +bool world_object_at(Vec3 point, float radius, Box *hit) +{ + for (int i = 0; i < s_box_count; i++) { + Box b = s_boxes[i]; + if (point.x > b.min.x - radius && point.x < b.max.x + radius && + point.y > b.min.y - radius && point.y < b.max.y + radius && + point.z > b.min.z - radius && point.z < b.max.z + radius) { + *hit = b; + return true; + } + } + return false; +} + int world_zone_count(void) { return s_zone_count; diff --git a/platformer/src/world.h b/platformer/src/world.h index 4cfcf71..422be28 100644 --- a/platformer/src/world.h +++ b/platformer/src/world.h @@ -3,8 +3,10 @@ * FILE: world.h * * PURPOSE: Public interface for "the level" while the game runs: a flat - * square of ground with box-shaped platforms and terrain on it - * (some of them moving). This API is how other modules ask + * square of ground with OBJECTS on it (solid boxes: platforms, + * terrain, walls; some of them moving) and ZONES (non-solid + * regions that change behavior inside them, even when box-shaped). + * "Box" here means an object unless it's a zone's bounds. This API is how other modules ask * questions about the level's geometry. * What's IN the level is decided by level.c (level.h). * @@ -68,6 +70,10 @@ * Vec3 world_spawn_point(void); * Where the player starts / resets to (level_spawn_point()). The * area around it is kept clear of platforms. + * bool world_object_at(Vec3 point, float radius, Box *hit); + * True (and *hit = that object) if the point is within `radius` of + * the inside of an OBJECT (zones never count). The camera uses it + * to keep the eye out of objects. * int world_zone_count(void); * Zone world_zone(int i); 0 <= i < world_zone_count() (render.c draws them) * bool world_in_zone(Vec3 point, ZoneKind kind); @@ -131,6 +137,7 @@ float world_ceiling_above(Vec3 head, float half_width); bool world_find_overlap(Vec3 feet, float half_width, float height, Box *hit); Vec3 world_clamp_to_bounds(Vec3 p); Vec3 world_spawn_point(void); +bool world_object_at(Vec3 point, float radius, Box *hit); int world_zone_count(void); Zone world_zone(int i); bool world_in_zone(Vec3 point, ZoneKind kind); |
