414 lines
11 KiB
GDScript
414 lines
11 KiB
GDScript
extends KinematicBody2D
|
|
|
|
signal hatch_exited
|
|
|
|
const ArrowProjectile = preload("res://objects/player/arrow_projectile.tscn")
|
|
|
|
##CLEAN UP CODE LATER
|
|
##Movement
|
|
export var use_iframes = false
|
|
export var walk_speed = 50
|
|
export var gravity = 12
|
|
export var max_fall_speed = INF
|
|
export var jump_time = 15
|
|
export var jump_force = 150
|
|
export var doublejump_force = 122
|
|
##Children
|
|
onready var sprite = $Sprite
|
|
onready var climb_ray = $ClimbRay
|
|
onready var anims = $AnimationPlayer
|
|
onready var sword_sprite = $SwordSprite
|
|
onready var sword_hitbox = $SwordArea
|
|
onready var death_particles = $DeathSplatter
|
|
onready var dust_particles = $DustParticles
|
|
onready var iframe_timer = $IframeTimer
|
|
onready var hitbox = $Area2D/CollisionShape2D2
|
|
|
|
#Map
|
|
onready var map = get_owner()
|
|
##States
|
|
enum State {IDLE,WALK,JUMP,FALL,STUNNED,CLIMB,SWORD,SHOOT,INACTIVE,TRANSPORT,HATCH}
|
|
var current_state = State.IDLE
|
|
var can_die = true
|
|
##Runtime
|
|
var axis = Vector2.ZERO #Current direction being held
|
|
var trail_color = Color(0.25,0,1,0.4)
|
|
#Physics
|
|
var velocity = Vector2.ZERO
|
|
var current_ladder = null #Used for checking climbing every frame instead of area entered
|
|
var jump_pressure = 0
|
|
var can_doublejump = true
|
|
var can_move_in_air = false
|
|
var transport_speed = 0.0
|
|
var transport_direction = Vector2.ZERO
|
|
#Positions
|
|
var arrowpos = Vector2(5,3)
|
|
##Preload
|
|
|
|
#Set initial respawn point
|
|
func _ready():
|
|
$LeftShoe.shape.length = 0.0
|
|
Game.respawn_point = global_position
|
|
|
|
func _physics_process(delta):
|
|
if current_state == State.INACTIVE:
|
|
return
|
|
axis = Vector2(Input.get_axis("ui_left","ui_right"),Input.get_axis("ui_up","ui_down"))
|
|
#Check ladder
|
|
check_ladder()
|
|
match current_state:
|
|
State.IDLE:
|
|
_process_idle()
|
|
continue
|
|
State.WALK:
|
|
_process_walk()
|
|
continue
|
|
State.IDLE, State.WALK:
|
|
_process_idle_walk()
|
|
continue
|
|
State.JUMP:
|
|
_process_jump()
|
|
continue
|
|
State.FALL:
|
|
_process_fall()
|
|
continue
|
|
State.JUMP, State.FALL:
|
|
_process_jump_fall()
|
|
continue
|
|
State.CLIMB:
|
|
_process_climb()
|
|
continue
|
|
State.SWORD:
|
|
_process_sword()
|
|
continue
|
|
State.SHOOT:
|
|
_process_shoot()
|
|
continue
|
|
State.TRANSPORT:
|
|
_process_transport(delta)
|
|
return
|
|
State.HATCH:
|
|
_process_hatch(delta)
|
|
return
|
|
|
|
#Gravity
|
|
if current_state != State.CLIMB:
|
|
velocity.y = min(velocity.y + gravity, max_fall_speed)
|
|
#Cut y velocity when hitting ceiling
|
|
if is_on_ceiling():
|
|
current_state = State.FALL
|
|
position.y += 1
|
|
velocity.y = 0
|
|
#Apply velocity
|
|
move_and_slide(velocity,Vector2.UP)
|
|
#Moon Jump
|
|
if Debug.moon_jump == true: can_doublejump = true
|
|
|
|
func _process_idle():
|
|
if anims.get_current_animation() != "idle": anims.play("idle")
|
|
#Stop
|
|
velocity.x = 0
|
|
#Goto Walk
|
|
if axis.x != 0: current_state = State.WALK
|
|
|
|
func _process_walk():
|
|
if anims.get_current_animation() != "walk": anims.play("walk")
|
|
#Move
|
|
move(walk_speed,0,true)
|
|
#Goto Idle
|
|
if axis.x == 0: current_state = State.IDLE
|
|
#Push Blocks
|
|
for i in get_slide_count():
|
|
var collision = get_slide_collision(i)
|
|
if collision.get_collider().is_in_group("pushable"):
|
|
collision.get_collider().push(collision.normal)
|
|
|
|
func _process_idle_walk():
|
|
can_doublejump = false
|
|
can_move_in_air = false
|
|
velocity.y = 0
|
|
#Goto Fall
|
|
if !is_on_floor(): current_state = State.FALL
|
|
#Goto Jump
|
|
check_jump()
|
|
#Goto Sword
|
|
if Debug.allow_sword && Input.is_action_just_pressed("sword"):
|
|
Audio.play_sound(Audio.a_sword,Audio.ac_jump)
|
|
current_state = State.SWORD
|
|
return
|
|
#Goto Shoot
|
|
check_shoot()
|
|
|
|
func _process_jump():
|
|
jump_pressure += 1
|
|
#Pressure sensitive jump
|
|
if jump_pressure >= jump_time or Input.is_action_just_released("jump"):
|
|
velocity.y = -jump_force / 4
|
|
#velocity.y = 0
|
|
current_state = State.FALL
|
|
|
|
func _process_fall():
|
|
if anims.get_current_animation() != "doublejump": anims.play("jump")
|
|
#Return to idle
|
|
if is_on_floor():
|
|
current_state = State.IDLE
|
|
return
|
|
#Cant move in air
|
|
if !can_move_in_air: velocity.x = 0
|
|
|
|
func _process_jump_fall():
|
|
check_double_jump()
|
|
move(walk_speed,0,true)
|
|
#Goto Shoot
|
|
check_shoot()
|
|
|
|
func _process_climb():
|
|
can_move_in_air = true
|
|
can_doublejump = true
|
|
#Graphics
|
|
anims.play("climb")
|
|
anims.set_speed_scale(abs(axis.y))
|
|
#Climb
|
|
position.y += axis.y * 0.65
|
|
#Sound
|
|
if axis.y == -1:
|
|
if Audio.ac_climb.get_stream() != Audio.a_climb_up: Audio.play_sound(Audio.a_climb_up,Audio.ac_climb)
|
|
if axis.y == 1:
|
|
if Audio.ac_climb.get_stream() != Audio.a_climb_down: Audio.play_sound(Audio.a_climb_down,Audio.ac_climb)
|
|
if axis.y == 0: Audio.ac_climb.set_stream(null)
|
|
#Manual Jump,, only works when holding neutral or away from ladder
|
|
if axis.x != sprite.scale.x && Input.is_action_just_pressed("jump"):
|
|
position.x -= sprite.scale.x * 3
|
|
velocity.y = -jump_force
|
|
anims.set_speed_scale(1)
|
|
current_state = State.FALL
|
|
Audio.ac_climb.set_stream(null)
|
|
return
|
|
if climb_ray.get_collider() == null:
|
|
if axis.y == -1:
|
|
#Auto Jump
|
|
velocity.y = -jump_force
|
|
Audio.play_sound(Audio.a_jump,Audio.ac_jump)
|
|
#Auto dismount
|
|
Audio.ac_climb.set_stream(null)
|
|
current_state = State.FALL
|
|
return
|
|
#Side dismount
|
|
if axis.x != sprite.scale.x && Input.is_action_just_pressed("shoot"):
|
|
position.x -= sprite.scale.x * 3
|
|
current_state = State.FALL
|
|
anims.set_speed_scale(1)
|
|
Audio.ac_climb.set_stream(null)
|
|
return
|
|
|
|
|
|
func _process_sword():
|
|
anims.play("stab")
|
|
#Stop
|
|
velocity.x = 0
|
|
sword_sprite.scale.x = sprite.scale.x
|
|
#Move hitbox with flip
|
|
sword_hitbox.position.x = sprite.scale.x * 10
|
|
#Return to idle after animationplayer end anim signal
|
|
|
|
func _process_shoot():
|
|
#Stop
|
|
velocity.x = 0
|
|
if anims.get_current_animation() == "shoot air":
|
|
#Cancel air shoot animation when grounded
|
|
if is_on_floor():
|
|
current_state = State.IDLE
|
|
return
|
|
move(walk_speed,0,true)
|
|
|
|
func _process_transport(delta):
|
|
position += transport_direction * transport_speed * delta
|
|
|
|
func _process_hatch(delta):
|
|
if Input.is_action_just_pressed("exit_hatch"):
|
|
anims.play("enter hatch", -1, -1.25,true)
|
|
emit_signal("hatch_exited")
|
|
|
|
func spawn_arrow():
|
|
Audio.play_sound(Audio.a_shoot,Audio.ac_jump)
|
|
var arrow = ArrowProjectile.instance()
|
|
arrow.global_position = Vector2(
|
|
global_position.x + arrowpos.x * sprite.scale.x,
|
|
global_position.y + arrowpos.y
|
|
)
|
|
arrow.direction = sprite.scale.x
|
|
arrow.add_to_group("player_arrow")
|
|
map.add_child(arrow)
|
|
|
|
func check_jump():
|
|
if Input.is_action_just_pressed("jump"):
|
|
#Detach ladder
|
|
if current_state == State.CLIMB:
|
|
Audio.ac_climb.set_stream(null) # stop climb sound
|
|
position.x -= sprite.scale.x * 3
|
|
else:
|
|
dust_particles.restart()
|
|
anims.set_speed_scale(1)
|
|
# Jump
|
|
can_doublejump = true
|
|
can_move_in_air = true
|
|
velocity.y = 0
|
|
jump_pressure = 0
|
|
current_state = State.JUMP
|
|
Audio.play_sound(Audio.a_jump,Audio.ac_jump)
|
|
anims.play("jump")
|
|
velocity.y = -jump_force
|
|
move(walk_speed,0,true)
|
|
|
|
func check_double_jump():
|
|
if is_on_floor():
|
|
check_jump()
|
|
if Input.is_action_just_pressed("jump") && can_doublejump:
|
|
Audio.play_sound(Audio.a_doublejump,Audio.ac_jump)
|
|
can_doublejump = false
|
|
velocity.y = -doublejump_force
|
|
anims.play("doublejump")
|
|
|
|
func check_shoot():
|
|
#Only Shoot if have arrows and there are no arrows onscreen
|
|
if Input.is_action_just_pressed("shoot") && Game.arrows > 0 && get_tree().get_nodes_in_group("player_arrow").size() == 0:
|
|
current_state = State.SHOOT
|
|
if is_on_floor():
|
|
anims.play("shoot grounded")
|
|
else:
|
|
anims.play("shoot air") #Shoot immediately in air
|
|
|
|
func move(hsp,vsp,flip:bool):
|
|
if is_on_floor() or can_move_in_air:
|
|
velocity.x = hsp * axis.x
|
|
#Flip
|
|
if flip: if sign(axis.x) != 0: sprite.scale.x = axis.x
|
|
|
|
func check_ladder():
|
|
if climb_ray.get_collider() != null:
|
|
current_ladder = climb_ray.get_collider().get_parent()
|
|
#Stop the velocity
|
|
velocity = Vector2.ZERO
|
|
#Snap to closest side
|
|
if position.x < current_ladder.middle:
|
|
position.x = current_ladder.left_snap.global_position.x
|
|
sprite.scale.x = 1
|
|
else:
|
|
position.x = current_ladder.right_snap.global_position.x
|
|
sprite.scale.x = -1
|
|
#Start Climbing
|
|
current_state = State.CLIMB
|
|
#Move the raycast
|
|
#climb_ray.position.x = 4 * sprite.scale.x
|
|
|
|
func enter_transport(speed, direction):
|
|
transport_speed = speed
|
|
transport_direction = direction
|
|
current_state = State.TRANSPORT
|
|
can_doublejump = false
|
|
anims.play("doublejump")
|
|
|
|
func exit_transport():
|
|
current_state = State.FALL
|
|
|
|
func enter_hatch(snap_position):
|
|
position = snap_position
|
|
current_state = State.INACTIVE
|
|
hitbox.disabled = true
|
|
collision_layer = 0
|
|
anims.play("enter hatch", -1, 1.25)
|
|
|
|
func die():
|
|
if can_die:
|
|
Audio.ac_climb.set_stream(null) # stop climbing sound\
|
|
#If the player is already dead, don't kill them again
|
|
if current_state == State.INACTIVE:
|
|
return
|
|
#Create particles
|
|
var new_particles = death_particles.duplicate()
|
|
get_parent().add_child(new_particles)
|
|
new_particles.global_position = global_position
|
|
new_particles.emitting = true
|
|
sprite.visible = false
|
|
current_state = State.INACTIVE # Set to state where player is not controllable
|
|
position = Game.respawn_point # Set respawn point
|
|
if Game.lives <= 0 && Game.use_lives:
|
|
#Gover
|
|
#Particles
|
|
new_particles.amount = 64
|
|
new_particles.lifetime = 0.45
|
|
new_particles.speed_scale = 1.5
|
|
current_state = State.INACTIVE # Set to state where player is not controllable
|
|
Audio.play_sound(Audio.a_gover, Audio.ac_die)
|
|
#Slow down time
|
|
var time_tween = get_tree().create_tween()
|
|
time_tween.tween_property(Engine, "time_scale", 0.1, 0.3)
|
|
Audio.ac_music.stream_paused = true
|
|
yield(time_tween, "finished") #Resume from freeze frame
|
|
yield(get_tree().create_timer(1.0 * 0.1), "timeout")
|
|
Game.call_deferred("restart_level")
|
|
else:
|
|
#Die
|
|
Game.lives -= 1
|
|
Game.deaths += 1
|
|
Audio.play_sound(Audio.a_die, Audio.ac_die)
|
|
yield(Game.freeze_frame(0.3), "timeout")
|
|
#Reduce points if playing in infinite lives mode
|
|
if Game.use_lives == false && Game.lives < 0:
|
|
Game.score = max(0,Game.score - 500)
|
|
#Iframes after respawn
|
|
if use_iframes:
|
|
iframe_timer.start()
|
|
can_die = false
|
|
#Respawn player
|
|
current_state = State.IDLE
|
|
sprite.visible = true
|
|
|
|
func _on_AnimationPlayer_animation_finished(anim_name):
|
|
#Set hatch state
|
|
if anim_name == "enter hatch":
|
|
match current_state:
|
|
State.INACTIVE:
|
|
current_state = State.HATCH
|
|
return
|
|
State.HATCH:
|
|
current_state = State.IDLE
|
|
hitbox.disabled = false
|
|
collision_layer = 2
|
|
if current_state == State.INACTIVE:
|
|
return
|
|
#Return to idle after slash
|
|
if anim_name == "stab":
|
|
current_state = State.IDLE
|
|
return
|
|
#Return to idle after grounded shoot
|
|
if anim_name == "shoot grounded":
|
|
current_state = State.IDLE
|
|
return
|
|
#Return to fall or idle after air shoot
|
|
if anim_name == "shoot air":
|
|
if is_on_floor():
|
|
current_state = State.IDLE
|
|
return
|
|
else:
|
|
current_state = State.FALL
|
|
return
|
|
|
|
|
|
func _on_SwordArea_area_entered(area):
|
|
if area.is_in_group("enemy_hitbox"):
|
|
var target = area.get_parent()
|
|
# create block text and return if blocked
|
|
if area.is_in_group("blocks_sword"):
|
|
var pos = target.global_position
|
|
Game.instance_node(Game.block_text, pos.x, pos.y, target.get_parent())
|
|
return
|
|
else:
|
|
target.die()
|
|
|
|
func _on_Area2D_body_entered(body):
|
|
if body.is_in_group("death"): die()
|
|
|
|
|
|
func _on_IframeTimer_timeout():
|
|
can_die = true
|