/* * ============================================================ * FILE: player.h * * PURPOSE: Public interface for the player character: its state and the * one function that advances it each tick. * * FITS IN: main.c owns one Player, calls player_update() each tick, and * calls player_reset() on Input.reset_pressed. render.c reads it * to draw it. * * INTERFACE: Use these exact names: * * typedef enum PlayerState { * PLAYER_IDLE, on ground, not moving * PLAYER_RUN, on ground, moving (walk vs run is just speed) * PLAYER_JUMP, in air, going up after a jump * PLAYER_FALL, in air, going down (or walked off something) * PLAYER_SKID, on ground, braking after pulling the stick back at * full run; retreating_movement is on * PLAYER_WALL_HANG in air, clinging to a hangable wall and sliding down * } PlayerState; * * typedef enum JumpKind { which jump the player is in the air from * JUMP_NONE, on the ground, or airborne without jumping * JUMP_NORMAL, a normal jump * JUMP_SECOND, the higher jump from heightened_movement * JUMP_RETREAT the jump out of a skid, from retreating_movement * } JumpKind; * * typedef struct Player { * Body body; position / velocity / on_ground (physics.h) * float facing_yaw; direction the player faces, radians. * Facing vector = (sin(yaw), 0, cos(yaw)), * which matches mat4_rotate_y in math3d.h. * 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 * 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. * float heightened_timer; s left before heightened_movement ends * (not counted down during the second jump) * bool retreating_movement; on for the whole skid (PLAYER_SKID) and * the retreat jump out of it. While skidding, A * gives the retreat jump. Later moves will read * it too. * JumpKind jump_kind; which jump the player is in the air from * 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 (the old run * direction; the player already faces the stick) * 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 * float wall_jump_yaw; where a wall jump from this hang launches: the * approach direction mirrored off the wall * bool has_last_wall; a wall was jumped off since the last landing * Vec3 last_wall_normal; that wall's surface: which way it faces... * float last_wall_plane; ...and where its face lies along that * direction. That surface can't be hung on * again until the player lands (no climbing * one wall, even one built from several boxes) * } 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); * 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 * * Include "math3d.h", "physics.h", "controls.h". * * CONVENTIONS: Include guard: PLAYER_H. * * NOT IN SCOPE: Health, animation, extra moves beyond the second jump, the * skid's retreat jump and the wall hang (see the README roadmap). * * DONE WHEN: main.c and render.c compile against this header alone. * ============================================================ */ #ifndef PLAYER_H #define PLAYER_H #include "controls.h" #include "math3d.h" #include "physics.h" /* SM64-style "actions". Add states here only when a new move needs one; * see the README roadmap (triple jump, long jump, wall kick, ...). The second * and retreat jumps didn't need one: they're a JUMP with a different launch * (see JumpKind). The skid and wall hang did, because each follows its own * movement rules. */ typedef enum PlayerState { PLAYER_IDLE, /* on ground, not moving */ PLAYER_RUN, /* on ground, moving (walk vs run is just speed) */ PLAYER_JUMP, /* in air, going up after a jump */ PLAYER_FALL, /* in air, going down (or walked off something) */ PLAYER_SKID, /* on ground, braking after pulling back at full run */ PLAYER_WALL_HANG /* in air, clinging to a hangable wall and sliding down */ } PlayerState; /* Which jump the player is in the air from. It decides the top speed in the * air and what landing turns on or off. */ typedef enum JumpKind { JUMP_NONE, /* on the ground, or airborne without jumping (walked off an edge) */ JUMP_NORMAL, /* a normal jump */ JUMP_SECOND, /* the higher jump from heightened_movement */ JUMP_RETREAT /* the jump out of a skid, from retreating_movement */ } JumpKind; typedef struct Player { Body body; /* position / velocity / on_ground */ float facing_yaw; /* radians; facing vector = (sin(yaw), 0, cos(yaw)) */ float forward_speed; /* ground speed along facing_yaw, m/s (>= 0) */ PlayerState state; bool heightened_movement; /* second-jump window, and on through second/retreat/wall jumps and hangs */ float heightened_timer; /* s left before heightened_movement ends; paused during the second jump */ bool retreating_movement; /* skidding (or in the jump out of a skid); later moves read it too */ JumpKind jump_kind; /* which jump the player is in the air from */ 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 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 */ bool has_last_wall; /* a wall was jumped off since the last landing... */ Vec3 last_wall_normal; /* ...facing this way... */ float last_wall_plane; /* ...with its face here along that direction; no regrab until landing */ } 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); const char *player_state_name(PlayerState s); #endif /* PLAYER_H */