221 lines
7.1 KiB
C
221 lines
7.1 KiB
C
#include "player.h"
|
|
#include "animation_player.h"
|
|
#include "state_machine.h"
|
|
#include <SDL2/SDL_events.h>
|
|
#include <SDL2/SDL_keyboard.h>
|
|
#include <SDL2/SDL_scancode.h>
|
|
#include <SDL2/SDL_render.h>
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
|
|
#define SPRITE_WIDTH 100
|
|
#define SPRITE_HEIGHT 64
|
|
|
|
void print_state (Player *player) {
|
|
switch(player->current_state) {
|
|
case PLAYER_STATE_IDLE:
|
|
printf("IDLE\n");
|
|
break;
|
|
case PLAYER_STATE_WALK:
|
|
printf("WALK\n");
|
|
break;
|
|
case PLAYER_STATE_DASH:
|
|
printf("DASH\n");
|
|
break;
|
|
case PLAYER_STATE_JUMP:
|
|
printf("JUMP\n");
|
|
break;
|
|
case PLAYER_STATE_FALL:
|
|
printf("FALL\n");
|
|
break;
|
|
}
|
|
}
|
|
void get_player_controls(Player *player);
|
|
State *update_state (Player *player, uint32_t state);
|
|
State *idle_state (StateMachine *sm, Player *player);
|
|
State *walk_state (StateMachine *sm, Player *player);
|
|
State *dash_state (StateMachine *sm, Player *player);
|
|
State *jump_state (StateMachine *sm, Player *player);
|
|
State *fall_state (StateMachine *sm, Player *player);
|
|
|
|
void player_init(Player *player, SDL_Renderer *renderer, SDL_Rect position) {
|
|
player->base_y = position.y;
|
|
player->position = position;
|
|
player->movement = (Movement){0};
|
|
player->x_direction = PLAYER_DIRECTION_RIGHT;
|
|
player->velocity = 4;
|
|
|
|
player->animations[PLAYER_STATE_IDLE] =
|
|
ap_init(renderer, "knight_player/Idle_KG_2.png", 125, SPRITE_WIDTH, SPRITE_HEIGHT, true);
|
|
player->animations[PLAYER_STATE_WALK] =
|
|
ap_init(renderer, "knight_player/Walking_KG_2.png", 125, SPRITE_WIDTH, SPRITE_HEIGHT, true);
|
|
player->animations[PLAYER_STATE_DASH] =
|
|
ap_init(renderer, "knight_player/Dashing_KG_1.png", 125, SPRITE_WIDTH, SPRITE_HEIGHT, false);
|
|
player->animations[PLAYER_STATE_JUMP] =
|
|
ap_init(renderer, "knight_player/Jump_KG_2.png", 100, SPRITE_WIDTH, SPRITE_HEIGHT, false);
|
|
player->animations[PLAYER_STATE_FALL] =
|
|
ap_init(renderer, "knight_player/Fall_KG_2.png", 80, SPRITE_WIDTH, SPRITE_HEIGHT, false);
|
|
|
|
player->states[PLAYER_STATE_IDLE] = (State){ .state_func = (StateFunc *)idle_state };
|
|
player->states[PLAYER_STATE_WALK] = (State){ .state_func = (StateFunc *)walk_state };
|
|
player->states[PLAYER_STATE_DASH] = (State){ .state_func = (StateFunc *)dash_state };
|
|
player->states[PLAYER_STATE_JUMP] = (State){ .state_func = (StateFunc *)jump_state };
|
|
player->states[PLAYER_STATE_FALL] = (State){ .state_func = (StateFunc *)fall_state };
|
|
|
|
player->state_machine = (StateMachine){ .current_state = &(player->states[PLAYER_STATE_IDLE]) };
|
|
player->current_state = PLAYER_STATE_IDLE;
|
|
player->controls = (PlayerControl){0};
|
|
}
|
|
|
|
void player_update(Player *player, uint32_t ticks) {
|
|
get_player_controls(player);
|
|
|
|
if (player->controls.walk_left) {
|
|
player->movement.x = PLAYER_DIRECTION_LEFT * player->velocity;
|
|
player->x_direction = PLAYER_DIRECTION_LEFT;
|
|
} else if (player->controls.walk_right) {
|
|
player->movement.x = PLAYER_DIRECTION_RIGHT * player->velocity;
|
|
player->x_direction = PLAYER_DIRECTION_RIGHT;
|
|
} else if (!(player->controls.walk_left) && !(player->controls.walk_right)) {
|
|
player->movement.x = 0;
|
|
}
|
|
|
|
sm_run(&(player->state_machine), (void *)player);
|
|
|
|
player->position.x += player->movement.x;
|
|
player->position.y += player->movement.y;
|
|
if (player->position.y > player->base_y) {
|
|
player->position.y = player->base_y;
|
|
}
|
|
ap_update(&(player->animations[player->current_state]), ticks);
|
|
}
|
|
|
|
void player_draw(const Player *player, SDL_Renderer *renderer) {
|
|
ap_draw(renderer, &(player->animations[player->current_state]), &(player->position), player->x_direction == PLAYER_DIRECTION_LEFT);
|
|
}
|
|
|
|
void get_player_controls(Player *player) {
|
|
const uint8_t *keys = SDL_GetKeyboardState(NULL);
|
|
|
|
player->controls.walk_left = keys[SDL_SCANCODE_LEFT] == SDL_PRESSED;
|
|
player->controls.walk_right = keys[SDL_SCANCODE_RIGHT] == SDL_PRESSED;
|
|
|
|
player->controls.space_last = player->controls.space_pressed;
|
|
player->controls.space_pressed = keys[SDL_SCANCODE_SPACE] == SDL_PRESSED;
|
|
player->controls.jump = player->controls.space_last && !(player->controls.space_pressed);
|
|
|
|
player->controls.lctrl_last = player->controls.lctrl_pressed;
|
|
player->controls.lctrl_pressed = keys[SDL_SCANCODE_LCTRL] == SDL_PRESSED;
|
|
player->controls.dash = player->controls.lctrl_last && !(player->controls.lctrl_pressed);
|
|
}
|
|
|
|
State *update_state(Player *player, uint32_t state) {
|
|
if (state >= COUNT_PLAYER_STATES) {
|
|
return &(player->states[player->current_state]);
|
|
}
|
|
|
|
player->current_state = state;
|
|
return &(player->states[state]);
|
|
}
|
|
|
|
State *idle_state(StateMachine *sm, Player *player) {
|
|
uint32_t state = PLAYER_STATE_IDLE;
|
|
|
|
if (player->controls.jump) {
|
|
player->movement.y = player->velocity * 6 * -1;
|
|
state = PLAYER_STATE_JUMP;
|
|
} else if (player->controls.walk_left) {
|
|
state = PLAYER_STATE_WALK;
|
|
} else if (player->controls.walk_right) {
|
|
state = PLAYER_STATE_WALK;
|
|
}
|
|
|
|
return update_state(player, state);
|
|
}
|
|
|
|
State *walk_state(StateMachine *sm, Player *player) {
|
|
uint32_t state = PLAYER_STATE_WALK;
|
|
|
|
if (player->controls.jump) {
|
|
player->movement.y = player->velocity * 6 * -1;
|
|
state = PLAYER_STATE_JUMP;
|
|
} else if (player->controls.dash) {
|
|
player->controls.dash_in_air = false;
|
|
player->movement.x = player->x_direction * player->velocity * 2;
|
|
state = PLAYER_STATE_DASH;
|
|
}
|
|
|
|
if (!(player->controls.walk_left) && !(player->controls.walk_right)) {
|
|
state = PLAYER_STATE_IDLE;
|
|
}
|
|
|
|
return update_state(player, state);
|
|
}
|
|
|
|
State *dash_state(StateMachine *sm, Player *player) {
|
|
bool reset = false;
|
|
uint32_t state = PLAYER_STATE_DASH;
|
|
|
|
player->movement.x += player->x_direction * 20;
|
|
|
|
if (player->animations[PLAYER_STATE_DASH].finished) {
|
|
if (player->controls.dash_in_air) {
|
|
player->movement.y = player->velocity * 6;
|
|
state = PLAYER_STATE_FALL;
|
|
} else {
|
|
player->movement.x = 0;
|
|
state = PLAYER_STATE_IDLE;
|
|
}
|
|
|
|
reset = true;
|
|
}
|
|
|
|
if (reset) {
|
|
ap_reset(&(player->animations[PLAYER_STATE_DASH]));
|
|
}
|
|
|
|
return update_state(player, state);
|
|
}
|
|
|
|
State *jump_state(StateMachine *sm, Player *player) {
|
|
bool reset = false;
|
|
uint32_t state = PLAYER_STATE_JUMP;
|
|
|
|
player->movement.y += player->velocity * 0.5;
|
|
|
|
if (player->controls.dash) {
|
|
player->controls.dash_in_air = true;
|
|
player->movement.x = player->x_direction * player->velocity * 2;
|
|
player->movement.y = player->velocity * 0.5;
|
|
reset = true;
|
|
state = PLAYER_STATE_DASH;
|
|
} else if (player->animations[PLAYER_STATE_JUMP].finished) {
|
|
player->movement.y = player->velocity * 6;
|
|
reset = true;
|
|
state = PLAYER_STATE_FALL;
|
|
}
|
|
|
|
if (reset) {
|
|
ap_reset(&(player->animations[PLAYER_STATE_JUMP]));
|
|
}
|
|
|
|
return update_state(player, state);
|
|
}
|
|
|
|
State *fall_state(StateMachine *sm, Player *player) {
|
|
bool reset = false;
|
|
uint32_t state = PLAYER_STATE_FALL;
|
|
|
|
if (player->animations[PLAYER_STATE_FALL].finished) {
|
|
player->movement.y = 0;
|
|
reset = true;
|
|
state = PLAYER_STATE_IDLE;
|
|
}
|
|
|
|
if (reset) {
|
|
ap_reset(&(player->animations[PLAYER_STATE_FALL]));
|
|
}
|
|
|
|
return update_state(player, state);
|
|
}
|