diff --git a/player.c b/player.c
index 571125f..0c02963 100644
--- a/player.c
+++ b/player.c
@@ -13,8 +13,6 @@
 State *update_state(Player *player, uint32_t state);
 State *idle_state(StateMachine *sm, Player *player);
 State *walk_state(StateMachine *sm, Player *player);
-State *jump_state(StateMachine *sm, Player *player);
-State *fall_state(StateMachine *sm, Player *player);
 State *dash_state(StateMachine *sm, Player *player);
 
 void player_init(Player *player, SDL_Renderer *renderer, SDL_Rect position) {
@@ -27,17 +25,11 @@ void player_init(Player *player, SDL_Renderer *renderer, SDL_Rect position) {
 			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_JUMP] = 
-			ap_init(renderer, "knight_player/Jump_KG_2.png",    125, SPRITE_WIDTH, SPRITE_HEIGHT, false);
-	player->animations[PLAYER_STATE_FALL] = 
-			ap_init(renderer, "knight_player/Fall_KG_2.png",    125, SPRITE_WIDTH, SPRITE_HEIGHT, false);
 	player->animations[PLAYER_STATE_DASH] = 
 			ap_init(renderer, "knight_player/Dashing_KG_1.png", 125, 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_JUMP] = (State){ .state_func = (StateFunc *)jump_state };
-	player->states[PLAYER_STATE_FALL] = (State){ .state_func = (StateFunc *)fall_state };
 	player->states[PLAYER_STATE_DASH] = (State){ .state_func = (StateFunc *)dash_state };
 
 	player->event_data    = (PlayerEventData){0};
@@ -50,55 +42,13 @@ void player_events(Player *player, const SDL_Event *event) {
 		return;
 	}
 
-	switch (event->type) {
-		case SDL_KEYDOWN:
-			switch (event->key.keysym.sym) {
-				case SDLK_LEFT:
-					player->movement.x     = PLAYER_DIRECTION_LEFT * player->velocity;
-					player->x_direction    = PLAYER_DIRECTION_LEFT;
-					player->event_data.key = PLAYER_CONTROL_LEFT_DOWN;
-					break;
-				case SDLK_RIGHT:
-					player->movement.x     = PLAYER_DIRECTION_RIGHT * player->velocity;
-					player->x_direction    = PLAYER_DIRECTION_RIGHT;
-					player->event_data.key = PLAYER_CONTROL_RIGHT_DOWN;
-					break;
-			}
-			break;
-		case SDL_KEYUP:
-			switch (event->key.keysym.sym) {
-				case SDLK_LEFT:
-					player->movement.x     = 0;
-					player->event_data.key = PLAYER_CONTROL_LEFT_UP;
-					break;
-				case SDLK_RIGHT:
-					player->movement.x     = 0;
-					player->event_data.key = PLAYER_CONTROL_RIGHT_UP;
-					break;
-				case SDLK_SPACE:
-					player->event_data.key = PLAYER_CONTROL_SPACE;
-					break;
-				case SDLK_LCTRL:
-					player->movement.x     = player->x_direction * player->velocity * 3;
-					player->event_data.key = PLAYER_CONTROL_LCTRL;
-
-					if (player->current_state == PLAYER_STATE_JUMP) {
-						player->event_data.dash_in_air = true;
-					} else {
-						player->event_data.dash_in_air = false;
-					}
-
-					break;
-			}
-			break;
-	}
+	player->event_data.event = event;
+	sm_run(&(player->state_machine), (void *)player);
 }
 
 void player_update(Player *player, uint32_t ticks) {
 	player->position.x += player->movement.x;
-	sm_run(&(player->state_machine), (void *)player);
 	ap_update(&(player->animations[player->current_state]), ticks);
-	player->event_data.key = PLAYER_CONTROL_NONE;
 }
 
 void player_draw(const Player *player, SDL_Renderer *renderer) {
@@ -115,61 +65,50 @@ State *update_state(Player *player, uint32_t state) {
 }
 
 State *idle_state(StateMachine *sm, Player *player) {
-	switch (player->event_data.key) {
-		case PLAYER_CONTROL_LEFT_DOWN:
-		case PLAYER_CONTROL_RIGHT_DOWN:
-			return update_state(player, PLAYER_STATE_WALK);
-		case PLAYER_CONTROL_SPACE:
-			return update_state(player, PLAYER_STATE_JUMP);
-	}
+	const SDL_Event *event = player->event_data.event;
+	uint32_t state         = PLAYER_STATE_IDLE;
 
-	return update_state(player, PLAYER_STATE_IDLE);
-}
-
-State *walk_state(StateMachine *sm, Player *player) {
-	switch (player->event_data.key) {
-		case PLAYER_CONTROL_LEFT_UP:
-		case PLAYER_CONTROL_RIGHT_UP:
-			return update_state(player, PLAYER_STATE_IDLE);
-		case PLAYER_CONTROL_SPACE:
-			return update_state(player, PLAYER_STATE_JUMP);
-		case PLAYER_CONTROL_LCTRL:
-			return update_state(player, PLAYER_STATE_DASH);
-	}
-
-	return update_state(player, PLAYER_STATE_WALK);
-}
-
-State *jump_state(StateMachine *sm, Player *player) {
-	bool reset     = false;
-	uint32_t state = PLAYER_STATE_JUMP;
-
-	if (player->animations[PLAYER_STATE_JUMP].finished) {
-		reset = true;
-		state = PLAYER_STATE_FALL;
-	} else if (player->event_data.key == PLAYER_CONTROL_LCTRL) {
-		reset = true;
-		state = PLAYER_STATE_DASH;
-	}
-
-	if (reset) {
-		ap_reset(&(player->animations[PLAYER_STATE_JUMP]));
+	switch (event->type) {
+		case SDL_KEYDOWN:
+			switch (event->key.keysym.sym) {
+				case SDLK_LEFT:
+					player->movement.x  = PLAYER_DIRECTION_LEFT * player->velocity;
+					player->x_direction = PLAYER_DIRECTION_LEFT;
+					state               = PLAYER_STATE_WALK;
+					break;
+				case SDLK_RIGHT:
+					player->movement.x  = PLAYER_DIRECTION_RIGHT * player->velocity;
+					player->x_direction = PLAYER_DIRECTION_RIGHT;
+					state               = PLAYER_STATE_WALK;
+					break;
+			}
+			break;
 	}
 
 	return update_state(player, state);
 }
 
-State *fall_state(StateMachine *sm, Player *player) {
-	bool reset     = false;
-	uint32_t state = PLAYER_STATE_FALL;
+State *walk_state(StateMachine *sm, Player *player) {
+	const SDL_Event *event = player->event_data.event;
+	uint32_t state         = PLAYER_STATE_WALK;
 
-	if (player->animations[PLAYER_STATE_FALL].finished) {
-		reset = true;
-		state = PLAYER_STATE_IDLE;
-	}
-
-	if (reset) {
-		ap_reset(&(player->animations[PLAYER_STATE_FALL]));
+	switch (event->type) {
+		case SDL_KEYUP:
+			switch (event->key.keysym.sym) {
+				case SDLK_LCTRL:
+					player->movement.x = player->x_direction * player->velocity * 3;
+					state              = PLAYER_STATE_DASH;
+					break;
+				case SDLK_LEFT:
+					player->movement.x = 0;
+					state              = PLAYER_STATE_IDLE;
+					break;
+				case SDLK_RIGHT:
+					player->movement.x = 0;
+					state              = PLAYER_STATE_IDLE;
+					break;
+			}
+			break;
 	}
 
 	return update_state(player, state);
@@ -179,17 +118,12 @@ State *dash_state(StateMachine *sm, Player *player) {
 	bool reset     = false;
 	uint32_t state = PLAYER_STATE_DASH;
 
-	player->movement.x += player->x_direction * 10;
+	player->movement.x += player->x_direction * 3;
 
 	if (player->animations[PLAYER_STATE_DASH].finished) {
-		reset = true;
 		player->movement.x = 0;
-
-		if (player->event_data.dash_in_air) {
-			state = PLAYER_STATE_FALL;
-		} else {
-			state = PLAYER_STATE_IDLE;
-		}
+		reset              = true;
+		state              = PLAYER_STATE_IDLE;
 	}
 
 	if (reset) {
diff --git a/player.h b/player.h
index b3ccfde..25df80c 100644
--- a/player.h
+++ b/player.h
@@ -11,25 +11,11 @@
 enum player_states {
 	PLAYER_STATE_IDLE,
 	PLAYER_STATE_WALK,
-	PLAYER_STATE_JUMP,
-	PLAYER_STATE_FALL,
 	PLAYER_STATE_DASH,
 
 	COUNT_PLAYER_STATES,
 };
 
-enum player_controls {
-	PLAYER_CONTROL_NONE,
-	PLAYER_CONTROL_LEFT_DOWN,
-	PLAYER_CONTROL_RIGHT_DOWN,
-	PLAYER_CONTROL_LEFT_UP,
-	PLAYER_CONTROL_RIGHT_UP,
-	PLAYER_CONTROL_SPACE,
-	PLAYER_CONTROL_LCTRL,
-
-	COUNT_PLAYER_CONTROLS,
-};
-
 enum player_direction {
 	PLAYER_DIRECTION_LEFT  = -1,
 	PLAYER_DIRECTION_RIGHT =  1,
@@ -39,8 +25,7 @@ enum player_direction {
 
 typedef struct player_event_data PlayerEventData;
 struct player_event_data {
-	uint32_t key;
-	bool     dash_in_air;
+	const SDL_Event *event;
 };
 
 typedef struct movement Movement;