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 */
|