Hi!
I use move_and_slide for my game, but my character is supposed to stick to a platform when it collide with it for 2 seconds, and then fall.
For that I coded a very simple script where it detect if there's a collision with the get_last_slide_collision( ) function, and if the player is not on_the_floor() then a timer attached to it starts, its velocity becomes Vector.ZERO and when the timer is done, the player stops sticking and fall.
It works 99% of the time, but for some reasons I can't understand, sometimes the game does detect collision but the player does not stick, it just "bump" and fall.
What's weird is that the collision IS detected, and the player is NOT on_the_floor(), but still it fall.
I have a video if you want to picture what I'm talking about : the player hits the corner of the platform and falls immediately instead of sticking. Later in the video you can see what's happening when it works and the player sticks for 2 seconds:
Do you guys know what's happening? I know it's easier if you have the script, but the game is fully programmed so there are lots of stuff going on in the player script, but here is the script if you want to take a look at it (commentaries in French sorry):
extends KinematicBody2D

# Position à laquelle tombe également le dev ghost actuel
var spawn_position = Vector2(0, -1000)
var end_teleport_position = Vector2(1170, -58250)
var before_options_position = Vector2.ZERO
export(NodePath) var player_spawn_platform = null
const GRAVITY = 900
var current_gravity = GRAVITY
var velocity = Vector2.ZERO
var start_rotation_degrees = rotation_degrees
const JUMP_FORCE_X = 300*1.5
const JUMP_FORCE_Y = 600*1.5
const JUMP_MIN_X = (JUMP_FORCE_X/4)
const JUMP_MIN_Y = (JUMP_FORCE_Y/8)
const FALL_SPEED_MAX = 2500
var is_sticking = false
var infinite_sticking = false
var collision = null
var jump_angle = 0
var jump_remember = 0
var jump_remember_time = 0.1
var fall_time = 0
var fall_high_altitude = 110
var collide_platform = null
var was_colliding = false
const UP_DIRECTION = Vector2.UP
var vanish_platform_list = []
var is_insect = false
var show_arrow_to_light = false
var mouse_position = Vector2.ZERO

# Ghost
onready var devghost_frames = load_dev_ghost_data()
var playerghost_frames = load_player_ghost_data()
#var devghost_frames = null
var play_ghost = false
onready var ghost = get_node("/root/World/Ghost")
onready var ghost_animation_player = get_node("/root/World/Ghost/AnimationPlayer")
onready var camera = $Camera2D

#var collision_system = "move_and_collide"
var collision_system = "move_and_slide"

onready var platform_timer = $PlatformTimer
onready var sprite = $Sprite
onready var aim = $Aim
onready var animation_player = $AnimationPlayer
onready var reset_position = global_position
onready var new_record_message_animation_player = get_node("/root/World/CanvasLayer/NewRecordMessage/AnimationPlayer")
onready var arrow_to_light = get_node("/root/World/ArrowToLight")
onready var secret_end_area = get_node("/root/World/Level/Areas/ZoneFinal/EndTriggerArea/SecretEndTriggerArea")
onready var end_target = get_node("/root/World/Level/EndTarget")
onready var snd_end_target = get_node("/root/World/Level/EndTarget/SndEndTarget")
onready var snd_teleport_flag = $SndTeleportFlag
onready var snd_failed_flag = $SndFailedFlag

func _ready():
	modulate = Color("fffeea")
	# Gère la position de départ du player
	if Global.save.is_new_game() and !Global.debug_version:
		global_position = spawn_position
	# Gère le ghost
	if !Global.debug_version:
		if Global.new_game_plus:
			play_ghost = true
		else:
			play_ghost = false
	else:
		play_ghost = true

# Called when the node is created
func _enter_tree():
	Global.player = self

# Called when the node is destructed
func _exit_tree():
	Global.player = null

func reload_data():
	playerghost_frames = load_player_ghost_data()
	global_position = spawn_position
	animation_player.play("jump")
	velocity = Vector2.ZERO
	is_insect = false
	Global.music_manager.snd_fly.stop()
	show_arrow_to_light = false
	# Gère le ghost
	if !Global.debug_version:
		if Global.new_game_plus:
			play_ghost = true
		else:
			play_ghost = false
	else:
		play_ghost = true

func _process(delta):
	# Enregistre la position du joueur à chaque frame et l'ajoute au tableau ghost_frames
	if !Global.player_ghost_too_long or !Global.game_is_completed:
		save_player_ghost()
	play_ghost()
	arrow_to_light.global_position = Vector2(global_position.x, global_position.y - 150)
	if !Global.controller_is_connected:
		mouse_position = get_global_mouse_position()
	update_altitude()

# Update physic du joueur
func _physics_process(delta):
	# Empêche le joueur de jouer s'il a atteint la secret ending
	if Global.secret_ending_is_running:
		Global.music_manager.snd_fly.stop()
		return
		
	Global.altitude = floor(-global_position.y)
	# Téléporte le player au flag s'il existe
	if Input.is_action_just_pressed("teleport_to_flag"):
		teleport_to_flag()
	# Gère les variables utiles
	var jumping = Input.is_action_just_pressed("jump")
	
	# Gère jump buffering
	jump_remember -= delta
	if jumping:
		jump_remember = jump_remember_time
	
	# Applique la gravité
	current_gravity = GRAVITY
	
	# Calcule la vélocité Y
	velocity.y += (current_gravity * delta)
	
	# Aim
	if Global.controller_is_connected: # Gameplay avec joystick
		aim_to_joystick()
	else: # Gameplay avec souris
		aim_to_mouse()
	
	# Le joueur colle aux plateformes (et l'empêche de slide trop)
	if !is_on_air():
		if is_sticking:
			velocity = Vector2.ZERO
	else:
		fall_time += 1
			
	# Gère le jump
	if !is_on_air() and !is_insect:
		# Gère forme insecte
		# Jump normal
		if Input.is_action_just_pressed("jump") and is_sticking:
			process_jump()
			# Animation jump
			animation_player.play("prepare_jump")
			# Joue son
			Global.music_manager.snd_jump.play()
		# Jump buffering
		elif jump_remember > 0:
			jump_remember = 0
			process_jump()
			# Animation prepare_jump
			animation_player.play("prepare_jump")
			# Joue son
			Global.music_manager.snd_jump_buffering.play()
	else:
		if Input.is_action_just_released("jump") and !is_insect: 
			if velocity.y < -JUMP_MIN_Y:
				velocity.y = -JUMP_MIN_Y

	# Gère vol avec la forme insecte
	if is_insect and !Global.cinematic_is_running:
		if Input.is_action_pressed("fly"):
			process_fly()
			# Animation insect fly
			animation_player.play("insect_fly")
			# Joue son
			if !Global.music_manager.snd_fly.playing:
				Global.music_manager.snd_fly.play()
		else:
			# Animation insect idle
			animation_player.play("insect_idle")
			# Stoppe son
			if Global.music_manager.snd_fly.playing:
				Global.music_manager.snd_fly.stop()
		
#	# Système move_and_collide()
#	collision = move_and_collide(velocity * delta)
	# Système move_and_slide()
	velocity = move_and_slide(velocity, UP_DIRECTION)
	
	# Gère is_sticking
	if is_colliding():
		set_collide_platform()
		if !was_colliding:
			var platform = get_last_slide_collision().get_collider()
			# Reset vanishing plateformes
			if !platform.disable_vanish:
				for curr_platform in Global.vanish_platform_list:
					curr_platform.vanish_appear()
			if !is_insect:
				Global.achievement.check_fall_time(fall_time)
				if fall_time > 20:
					# Animation hit_ground
					if Global.end_is_triggered and Global.splash_anim:
						play_ghost = false
						animation_player.play("end_splash")
						Global.disable_stick = false
						is_insect = true
						snd_end_target.playing = true
						Global.game_is_completed = true
						Global.music_manager.play_end_music()
						Global.achievement.check_insect()
						Global.achievement.set_leaderboard_speedrun()
						# Utile seulement lorsque j'enregistre le premier devghost
#						var devghost_file = File.new()
#						if not devghost_file.file_exists("res://Files/devghost.save"):
#							save_dev_ghost_data()
#							return
						if Global.new_game_plus:
							if !Global.player_ghost_too_long:
								if Global.dev_ghost_is_beaten and playerghost_frames: # Dev ghost déjà battu
									if Global.game_timer < playerghost_frames.size():
										Global.dev_ghost_is_beaten = true
										Global.achievement.check_player_ghost()
										new_record_message_animation_player.play("anim")
										Global.music_manager.snd_victory.play()
										save_player_ghost_data()
								else: # Dev ghost pas encore battu
									if Global.game_timer < devghost_frames.size():
										Global.dev_ghost_is_beaten = true
										Global.achievement.check_dev_ghost()
										new_record_message_animation_player.play("anim")
										Global.music_manager.snd_victory.play()
										save_player_ghost_data()
						else:
							Global.new_game_plus = true
					else:
						if fall_time > (fall_high_altitude * 2):
							# Anim très grosse chute
							animation_player.play("mega_hit_ground")
							camera.add_trauma(1)
						else:
							# Anim petite chute
							animation_player.play("hit_ground")
					if fall_time > fall_high_altitude:
						# Joue son grosse chute
						Global.music_manager.snd_jump_buffering.play()
					else:
						# Joue son petite chute
						Global.music_manager.snd_impact_small.play()
		fall_time = 0
	else:
		# Reset collide_platform
		collide_platform = null
		# Reset le platform_timer
		platform_timer.stop()
#		is_sticking = true # A ÉTÉ MIS EN COMMENTAIRE CAR PAS CERTAIN QUE CE SOIT UTILE ??
	was_colliding = is_colliding()
	
	# Gère les collisions avec les vanishing plateformes
	if is_colliding_with_vanishing():
		if collision_system == "move_and_collide":
			collision.vanish_disappear()
		elif collision_system == "move_and_slide":
			var platform = get_last_slide_collision().get_collider()
			if !platform.disable_vanish:
				platform.vanish_disappear()
				
	# Applique une limite max à la vélocité Y
	velocity.y = clamp(velocity.y, -FALL_SPEED_MAX, FALL_SPEED_MAX)
	
	# DEBUG
	if get_last_slide_collision() and !is_on_floor():
#		velocity = Vector2.ZERO
		print("bubu") # OUI
#		if is_sticking: # OUI
#			print("byby")
#		if is_on_air(): # NON
#			print("bobo")
#		if is_on_wall(): # ÇA DÉPEND
#			print("bzbz")
#		if is_on_ceiling(): # ÇA DÉPEND
#			print("bcbc")
		print(platform_timer.is_stopped())
		print()
	
	# Empêche le player de se coller à la fin du jeu
	if Global.disable_stick:
		is_sticking = false
		
	# Empêche la rotation du player à la fin du jeu
	if Global.reset_player_rotation:
		rotation_degrees = start_rotation_degrees
		
	# Gère angle du player en mode insecte s'il vole
	if is_insect and is_on_air():
		update_insect_angle()
		
	# Gère l'arrow_to_light une fois en forme insecte
	if show_arrow_to_light:
		rotate_arrow_to_light()
		
	# DEBUG: Permet de gérer des controls de debug (téléport, save, etc)
	if Global.debug_version:
		check_debug_controls()
	
func update_altitude():
	Global.altitude = global_position.y
	Global.achievement.check_altitude()

# Vérifie si le joueur est en train de collisionner
func is_colliding():
	if collision_system == "move_and_collide":
		if collision != null:
			return true
		else:
			return false
	elif collision_system == "move_and_slide":
		return get_slide_count() > 0
		
func set_collide_platform():
	if collision_system == "move_and_collide":
		if collide_platform != collision:
			if !is_on_top():
				platform_timer.start()
				collide_platform = collision
			else:
				is_sticking = true
	elif collision_system == "move_and_slide":
		if collide_platform != get_last_slide_collision().get_collider():
			is_sticking = true
			if !is_on_floor():
				platform_timer.start()
				collide_platform = get_last_slide_collision().get_collider()
#	# DEBUG
#	if collision_system == "move_and_slide":
#		if collide_platform != get_last_slide_collision().get_collider():
#			if !is_on_floor():
#				platform_timer.start()
#				collide_platform = get_last_slide_collision().get_collider()
#			else:
#				is_sticking = true
				
func is_on_top():
	var width_to_add = 0
	if global_position.y < (collision.position.y + width_to_add):
		return true
	else:
		return false
	
# Vérifie si le joueur collisionne avec un objet en particulier
func is_colliding_with(pObject):
	if collision_system == "move_and_collide":
		if pObject and collision:
			return collision.collider == pObject
	elif collision_system == "move_and_slide":
		if get_slide_count() > 0:
			return get_last_slide_collision().get_collider() == pObject
	return false
	
# Vérifie si le joueur collisionne avec un objet is_vanishing
func is_colliding_with_vanishing():
	if collision_system == "move_and_collide":
		if collision != null:
			if collision.collider.is_vanishing:
				return true
	elif collision_system == "move_and_slide":
		if get_slide_count() > 0:
			if get_last_slide_collision().get_collider().is_vanishing:
				return true
	return false
	
# Vérifie si le joueur est dans les airs
func is_on_air():
	return !is_colliding()
	
# Permet de viser dans une direction avec le joystick
func aim_to_joystick():
	# Rotationne le viseur (aim)
	var joystick_vector = Vector2(Input.get_action_strength("move_right") - Input.get_action_strength("move_left"), Input.get_action_strength("move_down") - Input.get_action_strength("move_up"))
	var controller_deadzone = 0.32
	if Vector2.ZERO.distance_to(joystick_vector) > controller_deadzone*sqrt(2.0):
		joystick_vector = joystick_vector.normalized()
		aim.visible = true
	else:
		joystick_vector = Vector2(0, -JUMP_FORCE_Y)
		aim.visible = false
	aim.global_rotation = atan2(joystick_vector.y, joystick_vector.x)

# Permet de viser dans une direction avec la souris
func aim_to_mouse():
	# Rotationne le viseur (aim)
	var mouse_vector = get_global_mouse_position() - aim.global_position
	aim.global_rotation = atan2(mouse_vector.y, mouse_vector.x)

func update_insect_angle():
	if Global.controller_is_connected:
		var joystick_vector = Vector2(Input.get_action_strength("move_right") - Input.get_action_strength("move_left"), Input.get_action_strength("move_down") - Input.get_action_strength("move_up"))
		var controller_deadzone = 0.32
		if Vector2.ZERO.distance_to(joystick_vector) > controller_deadzone*sqrt(2.0):
			global_rotation = atan2(joystick_vector.y, joystick_vector.x) - PI*3.5
		else:
			global_rotation = atan2(-JUMP_FORCE_Y, joystick_vector.x) - PI*3.5
	else:
		var mouse_vector = get_global_mouse_position() - global_position
		global_rotation = atan2(mouse_vector.y, mouse_vector.x) - PI*3.5
	
func show_arrow_to_light():
	arrow_to_light.visible = true
	show_arrow_to_light = true
	
func rotate_arrow_to_light():
	var max_gap = 1000
	var max_angle = 90
	var difference_x = (end_target.global_position.x - arrow_to_light.global_position.x)
	var angle = (difference_x / max_gap) * max_angle
	arrow_to_light.rotation_degrees = clamp(angle, -max_angle, max_angle)
	
# Calcule la vélocité du saut
func process_jump():
	if Global.disable_jump:
		return
	if Global.controller_is_connected:
		var joystick_vector = Vector2(Input.get_action_strength("move_right") - Input.get_action_strength("move_left"), Input.get_action_strength("move_down") - Input.get_action_strength("move_up"))
		var controller_deadzone = 0.32
		if Vector2.ZERO.distance_to(joystick_vector) > controller_deadzone*sqrt(2.0):
			joystick_vector = joystick_vector.normalized()
		else:
			joystick_vector = Vector2(0, -JUMP_FORCE_Y)
			joystick_vector = joystick_vector.normalized()
		velocity.x = joystick_vector.x * JUMP_FORCE_X
		velocity.y = joystick_vector.y * JUMP_FORCE_Y
		# Rotationne le player
		var old_aim_rotation = aim.global_rotation
		global_rotation = atan2(joystick_vector.y, joystick_vector.x) + 30
		# Empêche le aim d'être rotationné pedant une frame
		aim.global_rotation = old_aim_rotation
	else:
		var mouse_vector = get_global_mouse_position() - global_position
		mouse_vector = mouse_vector.normalized()
		velocity.x = mouse_vector.x * JUMP_FORCE_X
		velocity.y = mouse_vector.y * JUMP_FORCE_Y
		# Rotationne le player
		var old_aim_rotation = aim.global_rotation
		global_rotation = atan2(mouse_vector.y, mouse_vector.x) + 30
		# Empêche le aim d'être rotationné pedant une frame
		aim.global_rotation = old_aim_rotation
	# Increments the total of nb jump
	Global.nb_jump_total += 1
	Global.achievement.check_nb_jump()
	
# Calcule la vélocité du vol
func process_fly():
	if Global.controller_is_connected:
		var joystick_vector = Vector2(Input.get_action_strength("move_right") - Input.get_action_strength("move_left"), Input.get_action_strength("move_down") - Input.get_action_strength("move_up"))
		var controller_deadzone = 0.32
		var old_aim_rotation = aim.global_rotation
		if Vector2.ZERO.distance_to(joystick_vector) > controller_deadzone*sqrt(2.0):
			joystick_vector = joystick_vector.normalized()
			# Rotationne le player
			global_rotation = atan2(joystick_vector.y, joystick_vector.x) + 30
		else:
			joystick_vector = Vector2.ZERO
			joystick_vector = joystick_vector.normalized()
		velocity.x = joystick_vector.x * JUMP_FORCE_X
		velocity.y = joystick_vector.y * JUMP_FORCE_Y
		# Empêche le aim d'être rotationné pedant une frame
		aim.global_rotation = old_aim_rotation
	else:
		var mouse_vector = get_global_mouse_position() - global_position
		mouse_vector = mouse_vector.normalized()
		velocity.x = mouse_vector.x * JUMP_FORCE_X
		velocity.y = mouse_vector.y * JUMP_FORCE_Y
		# Rotationne le player
		var old_aim_rotation = aim.global_rotation
		# Empêche le aim d'être rotationné pedant une frame
		aim.global_rotation = old_aim_rotation
		global_rotation = aim.global_rotation
	
# Téléporte au flag (s'il y en a un)
func teleport_to_flag():
	# Empêche de se téléporter au flag si les flags sont disabled (pour al fin)
	if Global.flags_are_disabled:
		return
	if Global.active_flag:
		snd_teleport_flag.play()
		Global.active_flag.teleport()
	else:
		snd_failed_flag.play()
	
func anim_jump():
	if is_on_air():
		animation_player.play("jump")
	else:
		anim_idle()
	
func anim_idle():
	# Annule rotation du player
	global_rotation = 0
	animation_player.play("idle")
	
func anim_insect_idle():
	animation_player.play("insect_idle")
	
func anim_mega_hit_ground():
	animation_player.play("mega_hit_ground")
	
func disable_cinematic():
	Global.cinematic_is_running = false

func _on_PlatformTimer_timeout():
	# Le player se décolle (sauf si sticking infini appliqué)
	if !infinite_sticking:
		is_sticking = false
		# Joue son
		Global.music_manager.snd_unstick.play()
		
func check_debug_controls():
	if Global.debug_version:
		if Input.is_action_just_pressed("debug_reset_player_position"):
			if player_spawn_platform == null:
				global_position = reset_position
			else:
				global_position = Vector2(get_node(player_spawn_platform).global_position.x + 10, get_node(player_spawn_platform).global_position.y - 10)
		if Input.is_action_just_pressed("debug_teleport_end"):
			global_position = end_teleport_position
		if Input.is_action_just_pressed("debug_save_ghost"):
			save_dev_ghost_data()

# Enregistre la position du joueur à chaque frame et l'ajoute au tableau ghost_frames
func save_player_ghost():
	if Global.game_is_completed or Global.player_ghost_too_long:
		return
	if devghost_frames == null:
		# Enregistre la position du joueur et l'ajoute au tableau ghost_frames
		var ghost_pos = [position.x, position.y]
		Global.ghost_frames.append(ghost_pos)
		return
	if Global.dev_ghost_is_beaten and playerghost_frames: # Dev ghost déjà battu
		if Global.ghost_frames.size() < playerghost_frames.size():
			# Enregistre la position du joueur et l'ajoute au tableau ghost_frames
			var ghost_pos = [position.x, position.y]
			Global.ghost_frames.append(ghost_pos)
		else:
			Global.player_ghost_too_long = true
	else:
		if Global.ghost_frames.size() < devghost_frames.size():
			# Enregistre la position du joueur et l'ajoute au tableau ghost_frames
			var ghost_pos = [position.x, position.y]
			Global.ghost_frames.append(ghost_pos)
		else:
			Global.player_ghost_too_long = true
	
func play_ghost():
	if !play_ghost :
		ghost.visible = false
		return
	if Global.dev_ghost_is_beaten and playerghost_frames: # Player ghost
		if Global.game_timer >= playerghost_frames.size():
			play_ghost = false
			return
		else:
			ghost.visible = true
			ghost_animation_player.play("idle")
			ghost.global_position = Vector2(playerghost_frames[Global.game_timer][0], playerghost_frames[Global.game_timer][1])
	else: # Dev ghost
		if devghost_frames == null:
			play_ghost = false
			return
		if Global.game_timer >= devghost_frames.size():
			ghost.visible = false
			play_ghost = false
			return
		else:
			ghost.visible = true
			ghost_animation_player.play("idle")
			ghost.global_position = Vector2(devghost_frames[Global.game_timer][0], devghost_frames[Global.game_timer][1])
		
func save_dev_ghost_data():
	# Méthode 1 : file dans le dossier de save
#	var save_file = File.new()
#	save_file.open("user://devghost.save", File.WRITE)
#	save_file.store_line(to_json(ghost_frames))
#	save_file.close()
	# Méthode 2 : file dans le dossier files
	var save_file = File.new()
	save_file.open("res://Files/devghost.save", File.WRITE)
	save_file.store_line(to_json(Global.ghost_frames))
	save_file.close()
	# Save backup
	var save_backup_file = File.new()
	var backup_path = "res://Files/Backups/devghost_" + str(Global.ghost_frames.size()) + ".save"
	save_backup_file.open(backup_path, File.WRITE)
	save_backup_file.store_line(to_json(Global.ghost_frames))
	save_backup_file.close()
	return
	
func save_player_ghost_data():
	var save_file = File.new()
	save_file.open("user://playerghost.save", File.WRITE)
	save_file.store_line(to_json(Global.ghost_frames))
	save_file.close()
	# Save backup
	var save_backup_file = File.new()
	var backup_path = "res://Files/Backups/playerghost_" + str(Global.ghost_frames.size()) + ".save"
	save_backup_file.open(backup_path, File.WRITE)
	save_backup_file.store_line(to_json(Global.ghost_frames))
	save_backup_file.close()
	
func load_dev_ghost_data():
	# Variables directement intégrée dans le code
	var devghost_frames = Global.ghost.devghost_data
	return devghost_frames
	
func load_player_ghost_data():
	var save_file = File.new()
	if not save_file.file_exists("user://playerghost.save"):
		play_ghost = false
		return
	save_file.open("user://playerghost.save", File.READ)
	var playerghost_frames_tab = []
	while save_file.get_position() < save_file.get_len():
		# Get the saved dictionary from the next line in the save file
		playerghost_frames_tab.append(parse_json(save_file.get_line()))
	save_file.close()
	var playerghost_frames = playerghost_frames_tab[0]
	return playerghost_frames
Thanks for your help!