added attack and improved animation

src/player.c

@@ -7,21 +7,22 @@
 #include "game_world.h"
 #include <SDL2/SDL_gamecontroller.h>
 
-static const float _anim_speed = 1.0/8.0;
+static const float _regular_animation_speed = 1.0/4.0;
+
 
 static
-void player_input_h(Player* self, InputEvent val) {
+void player_input_h(Player* self, InputEvent event) {
-    self->directional.x = val.as_float * 5.f;
+    self->directional.x = event.as_float * 5.f;
-    if(val.as_float > 0.0) {
+    if(event.as_float > 0.0) {
         sprite_flip_horizontal(self->sprite, 0);
-    } else if(val.as_float < 0.0) {
+    } else if(event.as_float < 0.0) {
         sprite_flip_horizontal(self->sprite, 1);
     }
 }
 
 static
-void player_input_jump(Player* self, InputEvent down) {
+void player_input_jump(Player* self, InputEvent event) {
-    if(down.as_bool && self->is_grounded) {
+    if(event.as_bool && self->is_grounded && (self->state & PlayerState_CanMove) != 0) {
         Vector velocity = rigidbody_get_velocity(self->rigidbody);
         self->directional.y = 0;
         velocity.y = -20.f;
@@ -29,6 +30,15 @@ void player_input_jump(Player* self, InputEvent down) {
     }
 }
 
+static
+void player_input_attack(Player* self, InputEvent event) {
+    if(event.as_bool && (self->state & PlayerState_CanAttack) != 0) {
+        self->frame_timer = self->frame_interval = _regular_animation_speed;
+        sprite_set_tile(self->sprite, 1);
+        self->state &= ~PlayerState_CanAttack;
+    }
+}
+
 static inline
 void _internal_player_init_input(Player* self) {
     // default to keyboard if no controllers are available
@@ -46,8 +56,12 @@ void _internal_player_init_input(Player* self) {
     )), (InputDelegateFn)player_input_h);
     // JUMP
     playerinput_add(self->player_input, KeyBind_as_InputAxis(
-        keybind_new(SDL_SCANCODE_W)
+        keybind_new(SDL_SCANCODE_K)
     ), (InputDelegateFn)player_input_jump);
+    // ATTACK
+    playerinput_add(self->player_input, KeyBind_as_InputAxis(keybind_new(
+        SDL_SCANCODE_J
+    )), (InputDelegateFn)player_input_attack);
 
     // CONTROLLER ------------------------------------------------
     // WALK
@@ -70,13 +84,20 @@ Player* player_new() {
     Player* self = malloc(sizeof(Player));
     *self = (Player) {
         .transform = {ZeroVector, {4, 4}, 0},
-        .sprite = sprite_from_spritesheet(spr_player_standing, 0),
+        .rigidbody = NULL,
         .shape = shape_new((Vector[]){
             {ex_w, -rr}, {ex_w-r, 0.f},
             {r-ex_w, 0.f}, {-ex_w, -rr},
             {-ex_w, rr-h}, {r-ex_w, -h},
             {ex_w-r, -h}, {ex_w, rr-h},
-        }, 8)
+        }, 8),
+        .directional = ZeroVector,
+        .sprite = sprite_from_spritesheet(spr_player_standing, 0),
+        .is_grounded = 0,
+        .player_input = NULL,
+        .frame_interval = 0.0,
+        .frame_timer = 0.0,
+        .state = PlayerState_CanMove | PlayerState_CanAttack,
     };
 
     self->rigidbody = rigidbody_make(Player_as_Transformable(self));
@@ -101,18 +122,29 @@ void player_collision_solver(Player* self, List* contacts) {
 
 void player_start(Player* self) {}
 
-void player_update(Player* self, float dt) {
+static
-    Vector velocity = rigidbody_get_velocity(self->rigidbody);
+void _internal_player_update_anim(Player* self, float dt) {
-    Vector velocity_target = {self->is_grounded ? self->directional.x : velocity.x, velocity.y};
+    if(self->frame_interval == 0.0)
-    rigidbody_accelerate(self->rigidbody, vmulff(vsubf(velocity_target, velocity), 50.f), 0);
+        return;
-    rigidbody_accelerate(self->rigidbody, (Vector){0.0f, 100.f}, 0);
-    self->is_grounded = 0;
 
     self->frame_timer -= dt;
     if(self->frame_timer <= 0.0) {
         sprite_set_tile(self->sprite, sprite_get_tile(self->sprite) + 1);
-        self->frame_timer = _anim_speed;
+        self->frame_timer = _regular_animation_speed;
+        if(sprite_get_tile(self->sprite) == 0) {
+            self->state |= PlayerState_CanAttack;
+            self->frame_interval = 0.0;
         }
+    }
+}
+
+void player_update(Player* self, float dt) {
+    Vector velocity = rigidbody_get_velocity(self->rigidbody);
+    Vector velocity_target = {self->is_grounded ? self->directional.x : velocity.x, velocity.y};
+    rigidbody_accelerate(self->rigidbody, vmulff(vsubf(velocity_target, velocity), 100.f), 0);
+    rigidbody_accelerate(self->rigidbody, (Vector){0.0f, 100.f}, 0);
+    self->is_grounded = 0;
+    _internal_player_update_anim(self, dt);
 }
 
 void player_draw(Player* self) {

src/player.h

@@ -10,6 +10,11 @@
 #include "sprite_entity.h"
 #include "player_input.h"
 
+typedef enum PlayerState {
+    PlayerState_CanMove = 0x1,
+    PlayerState_CanAttack = 0x2,
+} PlayerState;
+
 typedef struct Player {
     Transform transform;
     RigidBody* rigidbody;
@@ -22,6 +27,8 @@ typedef struct Player {
     PlayerInput* player_input;
 
     float frame_timer;
+    float frame_interval;
+    PlayerState state;
 } Player;
 
 extern Player* player_new();