diff options
Diffstat (limited to '')
| -rw-r--r-- | platformer/src/player.c | 152 |
1 files changed, 152 insertions, 0 deletions
diff --git a/platformer/src/player.c b/platformer/src/player.c index 1f1b94c..ed8da51 100644 --- a/platformer/src/player.c +++ b/platformer/src/player.c @@ -71,3 +71,155 @@ * player lands cleanly back in IDLE/RUN. * ============================================================ */ + +#include "config.h" +#include "player.h" + +/* What the stick is asking for this tick, in world space. */ +typedef struct { + float mag; /* 0..1, how far the stick is pushed */ + float yaw; /* world direction to move in; only meaningful if mag > 0 */ +} Wish; + +static void update_ground(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 + * camera", so the stick is rotated by the camera's yaw (camera.h's + * convention for forward/right on the ground plane). */ +static Wish compute_wish(const Input *in, float camera_yaw) +{ + Vec3 fwd = vec3_make(-sinf(camera_yaw), 0.0f, -cosf(camera_yaw)); + Vec3 right = vec3_make( cosf(camera_yaw), 0.0f, -sinf(camera_yaw)); + Vec3 dir = vec3_add(vec3_scale(fwd, in->move.y), vec3_scale(right, in->move.x)); + + Wish wish; + wish.mag = vec2_length(in->move); + wish.yaw = atan2f(dir.x, dir.z); /* inverse of facing = (sin(yaw), 0, cos(yaw)) */ + return wish; +} + +/* Turns toward the stick and speeds up toward a speed set by how far it's + * pushed. Shared by ground and air movement; the air passes smaller rates. */ +static void steer(Player *p, Wish wish, float turn_rate, float accel, float dt) +{ + p->facing_yaw = approach_angle(p->facing_yaw, wish.yaw, turn_rate * dt); + p->forward_speed = approachf(p->forward_speed, PLAYER_MAX_SPEED * wish.mag, accel * dt); +} + +/* Standing still vs walking vs running is only a matter of speed. */ +static PlayerState grounded_state(const Player *p) +{ + return p->forward_speed > 0.0f ? PLAYER_RUN : PLAYER_IDLE; +} + +/* B + C. IDLE and RUN: full control, friction when the stick is released, + * and the only place a jump can start. */ +static void update_ground(Player *p, const Input *in, Wish wish, float dt) +{ + /* Walked off an edge (once edges exist): start falling. */ + if (!p->body.on_ground) { + p->state = PLAYER_FALL; + update_fall(p, in, wish, dt); + return; + } + + if (wish.mag > 0.0f) + steer(p, wish, PLAYER_TURN_RATE, PLAYER_GROUND_ACCEL, dt); + else + p->forward_speed = approachf(p->forward_speed, 0.0f, PLAYER_GROUND_FRICTION * dt); + p->state = grounded_state(p); + + if (in->jump_pressed) { + p->body.vel.y = PLAYER_JUMP_VELOCITY; + p->body.on_ground = false; + p->state = PLAYER_JUMP; + } +} + +/* 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) +{ + if (wish.mag > 0.0f) + steer(p, wish, + PLAYER_TURN_RATE * PLAYER_AIR_CONTROL, + PLAYER_GROUND_ACCEL * PLAYER_AIR_CONTROL, dt); +} + +/* FALL: in the air, going down. Landing hands straight over to the ground + * logic on the same tick, so a jump pressed on the landing tick isn't lost. */ +static void update_fall(Player *p, const Input *in, Wish wish, float dt) +{ + if (p->body.on_ground) { + p->state = grounded_state(p); + update_ground(p, in, wish, dt); + return; + } + air_steer(p, wish, dt); +} + +/* JUMP: in the air, still rising from a jump. */ +static void update_jump(Player *p, const Input *in, Wish wish, float dt) +{ + /* Past the apex (or landed already): it's a fall now. */ + if (p->body.vel.y <= 0.0f) { + p->state = PLAYER_FALL; + update_fall(p, in, wish, dt); + return; + } + + air_steer(p, wish, 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. Switching to + * FALL right away makes sure the cut happens only once. */ + if (!in->jump_held) { + p->body.vel.y *= PLAYER_JUMP_CUT; + p->state = PLAYER_FALL; + } +} + +void player_init(Player *p, Vec3 spawn) +{ + p->body.pos = spawn; + p->body.vel = vec3_make(0.0f, 0.0f, 0.0f); + p->body.on_ground = true; + p->facing_yaw = 0.0f; + p->forward_speed = 0.0f; + p->state = PLAYER_IDLE; +} + +void player_reset(Player *p, Vec3 spawn) +{ + player_init(p, spawn); +} + +void player_update(Player *p, const Input *in, float camera_yaw, float dt) +{ + Wish wish = compute_wish(in, camera_yaw); + + /* IDLE and RUN share one helper: they differ only in speed. */ + switch (p->state) { + case PLAYER_IDLE: + case PLAYER_RUN: update_ground(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; + physics_step(&p->body, dt); +} + +const char *player_state_name(PlayerState s) +{ + switch (s) { + case PLAYER_IDLE: return "IDLE"; + case PLAYER_RUN: return "RUN"; + case PLAYER_JUMP: return "JUMP"; + case PLAYER_FALL: return "FALL"; + } + return "?"; +} |
