summaryrefslogtreecommitdiff
path: root/platformer/src/player.h
blob: 4d8fdc6ac8cb6e98d35b036ef0602041ed80b8c4 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/*
 * ============================================================
 * 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
 *   } 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. While on, A gives the second
 *                                   jump. Later moves will read it too.
 *       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)
 *   } 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 and the
 *              skid's retreat jump (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 did, because it follows its own ground 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 */
} 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 available (or in progress); later moves read it too */
    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 */
} 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 */