b47ce2316f
Dans un cas particulier où un saut emmenant la tête du personnage sur un pan incliné lui donnait une vélocité en x différente de zéro et qu'aucune command du joueur n'était envoyé via le controleur alors, la princesse glissait à l'infi et l'au delà (surement même un peu plus). Il en va donc de sa survie et de la santé mentale du joueur de limiter ces comportements ératiques et qui semblent tout bien d'être une fonctionalité pour certains. Je m'égare, je m'égare! En attendant l'écureil, la princesse freinera. voilà.
286 lines
9.8 KiB
GDScript
286 lines
9.8 KiB
GDScript
extends CharacterBody2D
|
|
|
|
## The player listens for input actions appended with this suffix.[br]
|
|
## Used to separate controls for multiple players in splitscreen.
|
|
@export var action_suffix := ""
|
|
|
|
var gravity: int = ProjectSettings.get("physics/2d/default_gravity")
|
|
@onready var wall_detect_left := $wall_detect_left as RayCast2D
|
|
@onready var wall_detect_right := $wall_detect_right as RayCast2D
|
|
@onready var ground_far_detect := $ground_far_detect as RayCast2D
|
|
@onready var animation := $AnimatedSprite2D as AnimatedSprite2D
|
|
@onready var camera := $Camera2D as Camera2D
|
|
|
|
|
|
@export var WALKING_SPEED = 400
|
|
@export var FALLING_SPEED = 400
|
|
@export var JUMPING_SPEED = 400
|
|
@export var X_SPEED_TABLE = [0, 0.1, 0.15, 0.2, 0.3, 0.6, 0.9, 1]
|
|
@export var X_SPEED_DECEL = [0, 0.1, 0.6, 1]
|
|
@export var FALL_SPEED_TABLE = [0, 0.1, 0.15, 0.2, 0.3, 0.6, 0.9, 1]
|
|
@export var JUMP_SPEED_TABLE = [0, 0.1, 0.2, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
|
|
@export var KICK_SPEED_TABLE = [0, 0.2, 0.4, 0.6, 1, 1.6, 2.4, 3]
|
|
|
|
# Nombre d'incrément à rajouter lorsque la touche de saut est maintenue
|
|
@export var JUMPING_COUNTER_REFILL = 2
|
|
# Tous les combien d'incréments rajouter un refill sur le compteur
|
|
@export var JUMPING_KEY_COUNTER_THRESHOLD = 3
|
|
|
|
# Nombre de frames coyote durant lesquelle le joueur peut encore sauter
|
|
# sans encore être au sol
|
|
@export var COYOTE_LENGTH := 15
|
|
|
|
# Direction dans laquelle est positioné le personnage.
|
|
var direction : int = 1
|
|
|
|
# Variables détats relatives à la marche.
|
|
var walking : bool = false
|
|
var walking_step: int = -1
|
|
@export var WALK_INCR_GROUND : int = 1
|
|
@export var WALK_INCR_AIR : int = 3
|
|
var walk_incr_reserve : int = 0
|
|
var init_decel: bool = true
|
|
var init_direction_change = true
|
|
|
|
# variables d'état relatives au saut
|
|
var jumping : bool = false
|
|
var need_jump : bool = false
|
|
var jumping_step : int = -1
|
|
var jump_key_counter : int = 0
|
|
var coyote_ground = []
|
|
|
|
var falling_step : int = -1
|
|
|
|
var pressing_wall = false
|
|
var grab_wall = false
|
|
|
|
|
|
const PLATFORM_LAYER = 1 << (5 - 1) # collision layer 5
|
|
const PICS_BLOCK_LAYER = 1 << (6 - 1) # collision layer 6
|
|
var layer_of_collision = null
|
|
|
|
func walk(direction:int) -> float:
|
|
# Fait marcher le personnage.
|
|
|
|
# Si le personnage est dans l'air, il aura une friction plus faible lors de
|
|
# la décélération.
|
|
var threshold = WALK_INCR_AIR
|
|
if is_on_floor():
|
|
threshold = WALK_INCR_GROUND
|
|
|
|
if is_on_wall():
|
|
walking_step = min(walking_step, 1)
|
|
|
|
# Un changement de direction implique de perdre la vélocité dans la direction
|
|
# précédente avant de repartir dans la direction que l'on veut.
|
|
# ça ne change rien pour le nombre de frames nécéssaires pour accélérer dans
|
|
# tous les cas. Mais le feeling est meilleur.
|
|
var direction_change: bool = (direction > 0 and velocity.x < 0) or (direction < 0 and velocity.x > 0)
|
|
if direction_change:
|
|
if init_direction_change:
|
|
init_direction_change = false
|
|
walking_step = -1
|
|
else:
|
|
init_direction_change = true
|
|
|
|
# Si le joueur décide de marcher alors, le compteur de pas doit s'incrémenter
|
|
# Si le joueur ne veut plus marcher, alors, le compteur de pas décrémente
|
|
# La vitese choisie est le numéro d'étape dans le tableau correspondant
|
|
# X_SPEED_TABLE pour l'accélération
|
|
# X_SPEED_DECEL pour la décélération
|
|
var table = X_SPEED_TABLE
|
|
if walking:
|
|
walking_step = min(walking_step+1, X_SPEED_TABLE.size() -1)
|
|
init_decel = true
|
|
else:
|
|
# Lors de la première frame de la décélération, initialiser la valeur
|
|
# du compteur d'incrément en haut du tableau de décélération
|
|
table = X_SPEED_DECEL
|
|
if init_decel:
|
|
walking_step = min(walking_step, X_SPEED_DECEL.size() - 1)
|
|
init_decel = false
|
|
|
|
# dans le cas où le personnage est propulsé par une force extérieure et
|
|
# qu'il n'y a pas d'input du joueur pour permettre au personnage de ralentir
|
|
# il va bien falloir s'y coller, sinon, il va glisser indéfiniment.
|
|
var abs_v_x = abs(velocity.x)
|
|
if abs_v_x != 0 and walking_step == -1:
|
|
# trouver l'indice le plus proche de la vitesse courante
|
|
for index in range(0, X_SPEED_DECEL.size()-1):
|
|
var speed_i = table[walking_step] * WALKING_SPEED
|
|
var speed_i1 = table[walking_step+1] * WALKING_SPEED
|
|
# lorsque l'on a trouvé l'indice le bon endroit dans le tableau, alors
|
|
# on renvoie l'indice trouvé
|
|
if abs_v_x > speed_i and abs_v_x <= speed_i1:
|
|
walking_step = index+1
|
|
# si rien n'est trouvé, alors on initialise l'indice au maximum possible
|
|
if walking_step == -1:
|
|
walking_step = X_SPEED_DECEL.size() - 1
|
|
|
|
# Si le compteur d'incrément est supérieur ou égal à zéro, c'est qu'il
|
|
# faut bouger, donc il est nécéssaire en premier temps de récupérer la vitesse
|
|
# à l'indice courant. Puis si le joueur ne veut plus accélérer, alors, appliquer
|
|
# la décélération
|
|
if walking_step >= 0:
|
|
var speed = table[walking_step] * WALKING_SPEED
|
|
if not walking:
|
|
walk_incr_reserve += 1
|
|
# appliquer le nombre de frames nécéssaire pour décrémenter, dépend
|
|
# de où est le personnage (air vs sol)
|
|
if walk_incr_reserve >= threshold:
|
|
walk_incr_reserve = 0
|
|
walking_step-=1
|
|
if direction_change and walking:
|
|
# dans le cas du changement de direction,
|
|
return speed * direction + velocity.x
|
|
else:
|
|
return speed * direction
|
|
return velocity.x
|
|
|
|
|
|
func fall() -> float:
|
|
if jumping:
|
|
falling_step = -1
|
|
return velocity.y
|
|
if is_on_floor_only():
|
|
if get_floor_normal()[0] < 0: # pente à gauche
|
|
if direction >= 0:# on va à droite, désactive la gravité
|
|
falling_step = -1
|
|
return velocity.y
|
|
else: # on va à gauche, gravité à fond
|
|
falling_step = FALL_SPEED_TABLE.size()-1
|
|
else: # pente à droite
|
|
if direction > 0:# on va à droite, active la gravité à fond
|
|
falling_step = FALL_SPEED_TABLE.size()-1
|
|
else: # on va à gauche, désactive la gravité
|
|
falling_step = -1
|
|
return velocity.y
|
|
else:
|
|
if grab_wall:
|
|
falling_step = max(falling_step-1, 1)
|
|
else:
|
|
falling_step = min(falling_step+1, FALL_SPEED_TABLE.size()-1)
|
|
return FALL_SPEED_TABLE[falling_step] * FALLING_SPEED
|
|
|
|
|
|
func jump() -> float:
|
|
if not jumping:
|
|
return velocity.y
|
|
|
|
if not is_on_ceiling() and jump_key_counter > 0 and jump_key_counter % JUMPING_KEY_COUNTER_THRESHOLD == 0:
|
|
jumping_step = min(
|
|
jumping_step + JUMPING_COUNTER_REFILL,
|
|
JUMP_SPEED_TABLE.size() -1
|
|
)
|
|
|
|
if jumping_step > 0:
|
|
jumping_step -= 1
|
|
return JUMP_SPEED_TABLE[jumping_step] * JUMPING_SPEED * -1
|
|
else:
|
|
end_jump()
|
|
return velocity.y
|
|
|
|
func end_jump():
|
|
jumping = false
|
|
jumping_step = -1
|
|
jump_key_counter = 0
|
|
|
|
func _physics_process(delta: float) -> void:
|
|
|
|
coyote_ground.append(is_on_floor())
|
|
if coyote_ground.size() > COYOTE_LENGTH:
|
|
coyote_ground.remove_at(0)
|
|
|
|
pressing_wall = wall_detect_left.is_colliding() or wall_detect_right.is_colliding()
|
|
grab_wall = pressing_wall and Input.is_action_pressed("grab" + action_suffix)
|
|
|
|
if Input.is_action_just_pressed("jump" + action_suffix):
|
|
if ground_far_detect.is_colliding() or (is_on_floor() or coyote_ground[0]):
|
|
need_jump=true
|
|
|
|
if need_jump and (is_on_floor() or coyote_ground[0]):
|
|
need_jump = false
|
|
if not jumping:
|
|
jumping = true
|
|
jumping_step = JUMP_SPEED_TABLE.size()-1
|
|
jump_key_counter = 0
|
|
|
|
if Input.is_action_pressed("jump" + action_suffix):
|
|
if jumping:
|
|
jump_key_counter += 1
|
|
else:
|
|
jump_key_counter = 0
|
|
|
|
velocity.y = jump()
|
|
velocity.y = fall()
|
|
|
|
walking = (
|
|
Input.is_action_pressed("move_left" + action_suffix) or
|
|
Input.is_action_pressed("move_right" + action_suffix)
|
|
)
|
|
|
|
var axis = Input.get_axis(
|
|
"move_left" + action_suffix,
|
|
"move_right" + action_suffix
|
|
)
|
|
|
|
|
|
if not is_zero_approx(axis):
|
|
if axis < 0:
|
|
direction = -1
|
|
else:
|
|
direction = 1
|
|
|
|
|
|
velocity.x = walk(direction)
|
|
|
|
if not is_zero_approx(velocity.x):
|
|
if velocity.x > 0.0:
|
|
animation.scale.x = 1.0
|
|
else:
|
|
animation.scale.x = -1.0
|
|
|
|
if grab_wall:
|
|
if wall_detect_left.is_colliding():
|
|
animation.scale.x = 1
|
|
elif wall_detect_right.is_colliding():
|
|
animation.scale.x = -1
|
|
|
|
#floor_stop_on_slope = not platform_detector.is_colliding()
|
|
var collision = move_and_slide()
|
|
if collision:
|
|
var collider = get_last_slide_collision().get_collider()
|
|
|
|
if collider is TileMap:
|
|
var tile_rid = get_last_slide_collision().get_collider_rid()
|
|
layer_of_collision = PhysicsServer2D.body_get_collision_layer(tile_rid)
|
|
if layer_of_collision == PICS_BLOCK_LAYER:
|
|
get_tree(). reload_current_scene()
|
|
|
|
var anim := get_new_animation()
|
|
if anim != animation.animation:
|
|
animation.animation = anim
|
|
animation.play()
|
|
|
|
|
|
func get_new_animation() -> String:
|
|
var animation_new: String
|
|
|
|
if is_on_floor():
|
|
if walking_step > 0:
|
|
animation_new = "walk"
|
|
else:
|
|
animation_new = "idle"
|
|
else:
|
|
if velocity.y > 0.0:
|
|
if grab_wall:
|
|
animation_new = "wall_stick"
|
|
else:
|
|
if walking_step > 0:
|
|
animation_new = "falling_diagonals"
|
|
else:
|
|
animation_new = "falling_straight"
|
|
else:
|
|
animation_new = "jumping"
|
|
return animation_new
|