Table of Contents
src / player / player.gd
Attached Scenes
Code
extends CharacterBody2D
class_name Player
@export var GhostEffect : PackedScene
@export var LandedEffect : PackedScene
@export var fatigue_curve: Curve
signal dashed
signal jumped
signal landed
signal failed
signal reached(area: Area2D)
enum State {
CLIMBING,
DASHED,
DASHING,
EXHAUSTED,
FAILED,
FALLING,
GROUNDING,
JUMPED,
KICKED,
LOCKED,
}
const SPEED = 700.0
const DASH_SPEED = SPEED * 4
const CLIMBING_SPEED = SPEED / 6
const JUMP_VELOCITY = -1200.0
const GRAVITY = 4000
const ALLOWED_TIME_TO_JUMP = 0.13
const DASH_TIME = 0.1
const DASH_ATTENUATION = Vector2(55, 50)
const MAX_DASH_COUNT = 1
const MAX_CLIMBING_TIME = 7.0
const DEFAULT_SCALE = Vector2(6.0, 6.0)
var state : State = State.GROUNDING
var falling_time := 0.0
var dash_rest_time := 0.0
var dash_rest_count := MAX_DASH_COUNT
var climb_rest_time := 0.0
var sprite_tween : Tween
var restart_position : Vector2
var jump_boost : Vector2
static var last_owner_name : String
static var playable : bool = false
func _ready() -> void:
playable = true
turn_right()
if not owner: return
if last_owner_name == owner.name:
position = restart_position
else:
restart_position = position
last_owner_name = owner.name
func _physics_process(delta: float) -> void:
var dx := Input.get_axis(&'move_left', &'move_right')
var dy := Input.get_axis(&'move_up', &'move_down')
var direction := Vector2(dx, dy)
var last_state := state
state = compute_state(delta, direction)
match state:
State.CLIMBING:
dx = 0
velocity.y = dy * CLIMBING_SPEED
State.DASHED:
velocity = direction.normalized() * DASH_SPEED
State.DASHING:
velocity *= DASH_ATTENUATION * delta
State.EXHAUSTED:
dx = 0
State.FAILED:
velocity.x = lerp(velocity.x, 0.0, 0.2)
velocity.y = lerp(velocity.y, 0.0, 0.2)
State.FALLING:
if last_state == State.CLIMBING \
and dy < 0:
velocity.y = JUMP_VELOCITY * 0.8
else:
var move_x := dx * SPEED * 0.8
if velocity.x * dx < 0: move_x *= 0.1
velocity.x = lerp(velocity.x, move_x, 0.2)
if velocity.y < JUMP_VELOCITY * 0.85:
velocity.y += GRAVITY * 1.15 * delta
else:
velocity.y += GRAVITY * delta
State.JUMPED:
velocity.y = JUMP_VELOCITY
State.KICKED:
velocity.y = JUMP_VELOCITY * 0.9
velocity.x = get_wall_normal().x * DASH_SPEED * 0.4
State.LOCKED:
dx = 0
velocity = Vector2(0, 0)
_: pass
if not playable: dx = 0
if not (state == State.DASHED \
or state == State.DASHING \
or state == State.FALLING \
or state == State.KICKED
):
if dx: velocity.x = dx * SPEED
else: velocity.x = move_toward(velocity.x, 0, SPEED*0.2)
if state == State.JUMPED:
velocity += jump_boost
jump_boost = Vector2(0, 0)
animate(playable)
move_and_slide()
func compute_state(delta: float, direction: Vector2) -> State:
if state == State.FAILED: return State.FAILED
if state == State.LOCKED: return State.LOCKED
if is_just_input_action(&'move_dash') \
and dash_rest_count > 0 \
and direction:
compute_dashed()
return State.DASHED
elif dash_rest_time > 0:
dash_rest_time -= delta
return State.DASHING
else:
if not is_on_floor() and not state == State.CLIMBING:
falling_time += delta
else:
if state == State.FALLING: landed.emit()
falling_time = 0
if not state == State.CLIMBING:
dash_rest_count = MAX_DASH_COUNT
if direction.y > 0: may_drop_collisions()
var on_wall = %FrontRayCast.is_colliding()
if is_just_input_action(&'move_jump') \
and falling_time < ALLOWED_TIME_TO_JUMP:
jumped.emit()
return State.JUMPED
elif is_just_input_action(&'move_jump') \
and on_wall:
jumped.emit()
return State.KICKED
elif on_wall and is_input_action(&'move_climb') \
and (velocity.y >= 0 or state == State.CLIMBING) \
and not (state == State.FALLING and falling_time < 0.2):
falling_time = 0
climb_rest_time -= delta
if climb_rest_time > 0:
return State.CLIMBING
else:
return State.EXHAUSTED
if not is_on_floor():
return State.FALLING
else:
climb_rest_time = MAX_CLIMBING_TIME
return State.GROUNDING
func may_drop_collisions() -> void:
for i in get_slide_collision_count():
var collider = get_slide_collision(i).get_collider()
if collider.is_in_group('droppable'):
collider.drop()
func is_just_input_action(key: StringName) -> bool:
return playable and state != State.EXHAUSTED \
and Input.is_action_just_pressed(key)
func is_input_action(key: StringName) -> bool:
return playable and state != State.EXHAUSTED \
and Input.is_action_pressed(key)
func animate(force: bool = true) -> void:
if state == State.LOCKED: return
if force: animate_with(velocity)
update_sprite_states_shader_parameters()
if dash_rest_time > 0 && int(dash_rest_time*100)%3 > 0:
spawn_ghost_effect()
func animate_with(_velocity: Vector2) -> void:
if _velocity.x:
%FrontRayCast.target_position.x = sign(_velocity.x) \
* abs(%FrontRayCast.target_position.x)
for st in ['Idle', 'Run', 'Jump', 'Fall', 'Climb']:
%AnimationTree.set('parameters/%s/blend_position' % [st], _velocity.x)
%AnimationTree.get('parameters/playback').travel(get_state_by(_velocity))
func compute_dashed() -> void:
dashed.emit()
dash_rest_time = DASH_TIME
dash_rest_count -= 1
func idle() -> void:
%AnimationPlayer.play(&'RESET')
animate_with(Vector2(0, 0))
func walk_right() -> void:
animate_with(Vector2(1, 0))
func walk_left() -> void:
animate_with(Vector2(-1, 0))
func turn_right() -> void:
walk_right(); idle()
func turn_left() -> void:
walk_left(); idle()
func restart() -> void:
%RestartCurtain.play()
await get_tree().create_timer(1).timeout
position = restart_position
playable = true
jump_boost = Vector2(0, 0)
unlock()
idle.call_deferred()
func dash(direction: Vector2) -> void:
compute_dashed()
state = State.DASHED
velocity = direction.normalized() * DASH_SPEED
func lock() -> void:
state = State.LOCKED
%AnimationTree.active = false
func unlock() -> void:
state = State.EXHAUSTED
%AnimationTree.active = true
func vibrate(key: String):
var values = [0, 0, 0]
match key:
&'Dashed': values = [0.4, 0.6, 0.2]
&'Landed': values = [0.1, 0.3, 0.1]
Input.start_joy_vibration(0, values[0], values[1], values[2])
func get_state_by(_velocity) -> String:
if state == State.CLIMBING: return &'Climb'
if _velocity:
if _velocity.y < 0: return &'Jump'
if _velocity.y > 0: return &'Fall'
else: return &'Run'
else: return &'Idle'
func tween_sprite(key: StringName) -> void:
if sprite_tween: sprite_tween.kill()
sprite_tween = %Sprites.create_tween()
var coef = Vector2(1, 1)
match key:
&'dashed':
var dir := velocity.normalized()
coef = dir.abs().clamp(Vector2(0.75, 0.75), Vector2(1.0, 1.0))
&'landed': coef = Vector2(1.08, 0.92)
&'jumped': coef = Vector2(0.65, 1.45)
sprite_tween.tween_property(%Sprites, 'scale', coef * DEFAULT_SCALE, 0.10) \
.set_ease(Tween.EASE_IN_OUT).set_trans(Tween.TRANS_CUBIC)
sprite_tween.tween_property(%Sprites, 'scale', DEFAULT_SCALE, 0.16) \
.set_ease(Tween.EASE_OUT).set_trans(Tween.TRANS_SINE)
func update_sprite_states_shader_parameters() -> void:
for sprite in %SpriteStates.get_children():
sprite.material.set_shader_parameter(&'dashed', is_dashed())
var fatigue = 0.0
if state == State.CLIMBING:
fatigue = fatigue_curve.sample(climb_rest_time / MAX_CLIMBING_TIME)
sprite.material.set_shader_parameter(&'fatigue', fatigue)
func spawn_ghost_effect() -> void:
var ghost = GhostEffect.instantiate()
ghost.spawn(self)
func current_sprite_state() -> Sprite2D:
return %SpriteStates.get_children().filter(
func(c): return c.visible)[0]
func is_dashed() -> bool:
return true if dash_rest_count < MAX_DASH_COUNT else false
func _on_dashed() -> void:
vibrate(&'Dashed')
tween_sprite(&'dashed')
%Camera.shake(&'dash')
func _on_jumped() -> void:
tween_sprite(&'jumped')
func _on_landed() -> void:
vibrate(&'Landed')
tween_sprite(&'landed')
var effect = LandedEffect.instantiate()
effect.spawn(self)
idle()
func _on_failed() -> void:
playable = false
state = State.FAILED
velocity *= -1
%Camera.shake(&'failure')
%AnimationTree.active = false
%AnimationPlayer.play(&'burst')
func _on_reached(area: Area2D) -> void:
restart_position = area.position
func _on_frame_subject_area_entered(area: Area2D) -> void:
%Camera.add_frame(area)
func _on_frame_subject_area_exited(area: Area2D) -> void:
%Camera.remove_frame(area)
func _on_area_collision_area_entered(area: Area2D) -> void:
if area.get_collision_layer_value(4): # Failure
failed.emit()
elif area.get_collision_layer_value(6): # CheckPoint
reached.emit(area)