Différences

Ci-dessous, les différences entre deux révisions de la page.

--- dindomoteur_creation_du_joueur [2022/03/20 15:44] – Simon Deplat
+++ dindomoteur_creation_du_joueur [2026/02/25 23:55] (Version actuelle) – [Notes de fin] Labomedia
@@ Ligne 28: / Ligne 28: @@
 De manière intuitive, chacun d'entre eux aura **un nœud //Sprite// et une //Collision Shape 2D// de la bonne taille**.
+**Les calques et masques de collisions seront également réglés correctement** (le Joueur est sur le calque 1 et détecte le masque 4 (entre autres), et la plate-forme est sur le calque 4 et ne détecte rien).
 Ensuite, **je les ajoute au nœud Main en les instanciant**. Ils ne bougent pas, mais ils apparaissent à l'écran ! À noter : dans le futur, ceux-ci seront plutôt instanciés à l'intérieur d'un nœud "niveau".
@@ Ligne 53: / Ligne 55: @@
 ====Note à propos de la classe Joueur====
-Dans les versions précédentes de //Godot//, l'exemple //Platformer// n'utilisait pas de système d'héritage pour mutualiser l'attraction terrestre entre le joueur et les ennemis. C'est maintenant le cas, et le script //Player// hérite d'//Actor//, qui lui-même de //Kinematic Body 2D//. Nous comprenons l'intérêt de ce système, même si les scripts en deviennent moins intuitifs.
+Dans les versions précédentes de //Godot//, l'exemple //Platformer// n'utilisait pas de système d'héritage pour mutualiser l'attraction terrestre entre le joueur et les ennemis. C'est maintenant le cas, et le script //Player// hérite d'//Actor//, qui lui-même de //Kinematic Body 2D//.
-Nous allons mettre en place un système similaire, en créant **un répertoire //src/Personnage/// et un script //Personnage.gd//** .
+Les scripts en deviennent cependant moins intuitifs et cela peut conduire à des erreurs.
+Notamment, dans le script //Actor.gd// de l'exemple, la vélocité verticale est modifiée par le delta de la fonction. Or, le paramètre delta n'est pas sensé être utilisé lors de l'appel à //move_and_slide()//. Ce paramètre est donc redéfini dans //Player.gd//, ce qui est contre-intuitif.
+**De fait nous n'utiliserons pas d'héritage pour la classe //Joueur.gd//.**
 ====Implémentation de la gravité====
-Chaque personnage aura donc une masse et sera affecté par la gravité :
+**[ NOTE ] : Comme discuté [[https://regakakobigman.netlify.app/godot/2019/10/09/how-to-use-delta.html|ici]], la gestion actuelle des accélérations est mal implémentée car elle n'est pas multipliée par delta.**
+Le joueur aura donc une masse et sera affecté par la gravité :
-//personnage.gd//
 <code>
-class_name Personnage
 extends KinematicBody2D
-var masse = 1
+var _gravite = 50
-var gravite = Global.gravite
+var _masse = 1
 var _velocite = Vector2.ZERO
-# la fonction _physics_process héritée est appelée
+func _ready():
-# après la fonction _physics_process parente
+	if get_tree().root.has_node("Global"):
-func _physics_process( delta ):
+		_gravite = Global.gravite
-	_velocite.y += gravite * masse * delta
+func _physics_process( _delta ):
+	# Intégration de la gravité
+	_velocite.y += _gravite * _masse
+	_velocite = move_and_slide_with_snap(
+		_velocite,
+		Vector2.ZERO, # Accroche au sol
+		Vector2.UP, # Direction du sol ( Vector2.UP )
+		true, # Ne glisse pas sur le sol en cas d'inactivité ?
+, # Nombre de collisions traitées par cycle
+.9, # Angle maximum du sol ( en radians )
+		false # Inertie infinie ?
+	)
 </code>
-//joueur.gd//
+====Implémentation du saut====
+On ajoute au Joueur une capacité de saut. Plus les valeurs de //masse// et de //forceSaut// sont élevées, plus le saut est rapide et dynamique.
+//Personnage.gd//
 <code>
-class_name Joueur
+extends KinematicBody2D
-extends Personnage
+var _gravite = 50
+var _masse = 1
+var _forceSaut = 1000
+var _velocite = Vector2.ZERO
 func _ready():
-	masse = 50
+	if get_tree().root.has_node("Global"):
+		_gravite = Global.gravite
 func _physics_process( _delta ):
+	entreeSaut()
+	# Intégration de la gravité
+	_velocite.y += _gravite * _masse
 	_velocite = move_and_slide_with_snap(
@@ Ligne 96: / Ligne 133: @@
 		false # Inertie infinie ?
 	)
+# Appui sur le bouton de saut
+func entreeSaut():
+	# Mécanisme de saut
+	if is_on_floor():
+		if Input.is_action_just_pressed("espace"):
+			_velocite.y -= _forceSaut
 </code>
-====Implémentation du saut====
+====Ajout du déplacement latéral====
+Un simple algorithme qui permet de **déplacer le Joueur sur l'axe horizontal**. Ici, le plus intéressant est la méthode //bouge()//, qui ne peut fonctionner qu'au clavier : le //nesting// permet de mettre en place plusieurs comportement différents en fonction de l'ordre dans lequel les touches sont appuyées/relâchées.
-On ajoute au Personnage une capacité de saut. Plus les valeurs de masses et de forceSaut sont élevées, plus le saut est dynamique.
+Pas de phénomène d'accélération et d'inertie horizontale pour l'instant. Le déplacement pendant le saut est autorisé, et le restera probablement vu l'agréabilité de ce type de //gameplay//.
-//personnage.gd//
 <code>
-class_name Personnage
 extends KinematicBody2D
-var masse = 1
+var _gravite = 50
-var gravite = Global.gravite
-var forceSaut = 1
-var forceSautActuelle = 0
+var _masse = 1
-var surLeSol = false
+var _forceSaut = 1000
+var _vitesse = 300
+var _direction = 0
 var _velocite = Vector2.ZERO
-# la fonction _physics_process héritée est appelée
+func _ready():
-# après la fonction _physics_process parente
+	if get_tree().root.has_node("Global"):
-func _physics_process( delta ):
+		_gravite = Global.gravite
-	_velocite.y += gravite * masse * delta
+func _physics_process( _delta ):
+	bouge()
+	entreeSaut()
+	# Intégration du déplacement latéral
+	_velocite.x = _direction * _vitesse
+	# Intégration de la gravité
+	_velocite.y += _gravite * _masse
+	_velocite = move_and_slide_with_snap(
+		_velocite,
+		Vector2.ZERO, # Accroche au sol
+		Vector2.UP, # Direction du sol ( Vector2.UP )
+		true, # Ne glisse pas sur le sol en cas d'inactivité ?
+, # Nombre de collisions traitées par cycle
+.9, # Angle maximum du sol ( en radians )
+		false # Inertie infinie ?
+	)
+# Appui sur le bouton de saut
+func entreeSaut():
+	# Mécanisme de saut
+	if is_on_floor():
+		if Input.is_action_just_pressed("espace"):
+			_velocite.y -= _forceSaut
+# Appui sur les boutons clavier de déplacement
+func bouge():
+	if Input.is_action_just_pressed("gauche"):
+		_direction = -1
+	elif Input.is_action_just_pressed("droite"):
+		_direction = 1
+	if Input.is_action_just_released("gauche"):
+		if not Input.is_action_pressed("droite"):
+			_direction = 0
+		else:
+			_direction = 1
-	# On vérifie si le personnage est sur le sol
+	if Input.is_action_just_released("droite"):
-	surLeSol = is_on_floor()
+		if not Input.is_action_pressed("gauche"):
-	#Si oui, et s'il est en train de sauter,
+			_direction = 0
-	if surLeSol and forceSautActuelle > 0:
+		else:
-		# Remise à zéro de sa vélocité de saut
+			_direction = -1
-		forceSautActuelle = 0
-	if not surLeSol and forceSautActuelle > 0:
-		# Décroît de la vélocité de saut
-		forceSautActuelle = forceSautActuelle - ( gravite * masse * delta )
-		# Remise à zéro si la vélocité de saut devient négative
-		if forceSautActuelle < 0:
-			forceSautActuelle = 0
 </code>
-//joueur.gd//
+====Ajout d'une inertie latérale====
+Il y a maintenant nécessité pour le //Joueur// de **se mettre en mouvement et d'augmenter sa vitesse avant d'atteindre le maximum. Celui-ci met également un peu de temps à s'arrêter sur le sol. Cette décélération est absente lorsqu'il est en l'air.** Pour l'instant, être collé à un mur permet tout-de-même d'augmenter sa vitesse : cela sera réglé lors de l'appel à //is_on_wall()//.
 <code>
-class_name Joueur
+extends KinematicBody2D
-extends Personnage
+var _gravite = 50
+var _masse = 1
+var _forceSaut = 350
+var _vitesse = 300
+var _acceleration = 20
+var _deceleration = 10
+var _direction = 0
+var _vitesseActuelle = 0
+var _velocite = Vector2.ZERO
 func _ready():
-	masse = 100
+	if get_tree().root.has_node("Global"):
-	forceSaut = 14000
+		_gravite = Global.gravite
 func _physics_process( _delta ):
+	bouge()
+	entreeSaut()
+	traitementDuMouvement()
+	# Intégration du déplacement latéral
+	_velocite.x = _vitesseActuelle
+	# Intégration de la gravité
+	_velocite.y += _gravite * _masse
+	_velocite = move_and_slide_with_snap(
+		_velocite,
+		Vector2.ZERO, # Accroche au sol
+		Vector2.UP, # Direction du sol ( Vector2.UP )
+		true, # Ne glisse pas sur le sol en cas d'inactivité ?
+, # Nombre de collisions traitées par cycle
+.9, # Angle maximum du sol ( en radians )
+		false # Inertie infinie ?
+	)
+# Appui sur le bouton de saut
+func entreeSaut():
 	# Mécanisme de saut
-	if surLeSol:
+	if is_on_floor():
 		if Input.is_action_just_pressed("espace"):
-			forceSautActuelle = forceSaut
+			_velocite.y = _forceSaut
+# Appui sur les boutons clavier de déplacement
+func bouge():
+	if Input.is_action_just_pressed("gauche"):
+		_direction = -1
+	elif Input.is_action_just_pressed("droite"):
+		_direction = 1
-	# Si le personnage a encore une vélocité de saut
+	if Input.is_action_just_released("gauche"):
-	if forceSautActuelle > 0:
+		if not Input.is_action_pressed("droite"):
-		# Compensation de la gravité
+			_direction = 0
-		_velocite.y -= forceSautActuelle * _delta
+		else:
+			_direction = 1
+	if Input.is_action_just_released("droite"):
+		if not Input.is_action_pressed("gauche"):
+			_direction = 0
+		else:
+			_direction = -1
+# Gestion des accélérations/décélérations
+func traitementDuMouvement():
+# Vélocité horizontale
+	if _direction != 0:
+		_vitesseActuelle += _acceleration * _direction
+		# Restriction aux vitesses max
+		if _vitesseActuelle < 0:
+			if _vitesseActuelle < -_vitesse:
+				_vitesseActuelle = -_vitesse
+		else:
+			if _vitesseActuelle > _vitesse:
+				_vitesseActuelle = _vitesse
+	else:
+		# Décélération au sol
+		if is_on_floor():
+			if _vitesseActuelle < 0:
+				if _vitesseActuelle < -_deceleration:
+					_vitesseActuelle += _deceleration
+				else:
+					_vitesseActuelle = 0
+			elif _vitesseActuelle > 0:
+				if _vitesseActuelle > _deceleration:
+					_vitesseActuelle -= _deceleration
+				else:
+					_vitesseActuelle = 0
+</code>
+====Affinage de l'algorithme de saut====
+On ajoute deux mécanismes pour rendre les sauts plus agréables.
+Premièrement, **l'interruption d'un saut en relâchant la barre espace multiplie la vélocité par un ratio inférieur à 1 (ici 0.6) si celle-ci est négative, une fois par saut**. Le joueur peut donc sauter plus ou moins en haut en fonction du moment où il relâche le bouton. C'est notamment utilisé lors des passages de plate-formes où il y a des piques au-dessus du joueur.
+Deuxièmement, **la gravité contraire appliquée à la phase ascendante du saut est modifiée par un ratio qui peut nier tout ou partie de la gravité**. Au lieu d'un saut en cloche, la phase ascendant peut donc être plus rapide que la phase descendante.
+<code>
+extends KinematicBody2D
+var _gravite = 50
+var _masse = 2
+var _forceSaut = 2000
+var _vitesse = 300
+var _acceleration = 20
+var _deceleration = 10
+var _ratioDInterruptionDuSaut = 0.5
+var _ratioDGraviteSaut = 0.75
+var _direction = 0
+var _vitesseActuelle = 0
+var _forceSautActuelle = 0
+var _velocite = Vector2.ZERO
+var _saute = false
+func _ready():
+	if get_tree().root.has_node("Global"):
+		_gravite = Global.gravite
+func _physics_process( _delta ):
+	bouge()
+	entreeSaut()
+	if _saute:
+		if _velocite.y < 0:
+			interruptionDuSaut()
+	traitementDuMouvement()
+	# Intégration du déplacement latéral
+	_velocite.x = _vitesseActuelle
+	# Intégration de la gravité
+	if _velocite.y < 0:
+		_velocite.y += _gravite * _masse * _ratioDGraviteSaut
+	else:
+		_velocite.y += _gravite * _masse
 	_velocite = move_and_slide_with_snap(
@@ Ligne 166: / Ligne 368: @@
 	)
+# Appui sur le bouton de saut
+func entreeSaut():
+	# Mécanisme de saut
+	if is_on_floor():
+		if Input.is_action_just_pressed("espace"):
+			_velocite.y -= _forceSaut
+			_saute = true
+# Gestion de l'interruption du saut
+func interruptionDuSaut():
+	if Input.is_action_just_released("espace"):
+		_velocite.y *= _ratioDInterruptionDuSaut
+		_saute = false
+# Appui sur les boutons clavier de déplacement
+func bouge():
+	if Input.is_action_just_pressed("gauche"):
+		_direction = -1
+	elif Input.is_action_just_pressed("droite"):
+		_direction = 1
+	if Input.is_action_just_released("gauche"):
+		if not Input.is_action_pressed("droite"):
+			_direction = 0
+		else:
+			_direction = 1
+	if Input.is_action_just_released("droite"):
+		if not Input.is_action_pressed("gauche"):
+			_direction = 0
+		else:
+			_direction = -1
+# Gestion des accélérations/décélérations
+func traitementDuMouvement():
+# Vélocité horizontale
+	if _direction != 0:
+		_vitesseActuelle += _acceleration * _direction
+		# Restriction aux vitesses max
+		if _vitesseActuelle < 0:
+			if _vitesseActuelle < -_vitesse:
+				_vitesseActuelle = -_vitesse
+		else:
+			if _vitesseActuelle > _vitesse:
+				_vitesseActuelle = _vitesse
+	else:
+		# Décélération au sol
+		if is_on_floor():
+			if _vitesseActuelle < 0:
+				if _vitesseActuelle < -_deceleration:
+					_vitesseActuelle += _deceleration
+				else:
+					_vitesseActuelle = 0
+			elif _vitesseActuelle > 0:
+				if _vitesseActuelle > _deceleration:
+					_vitesseActuelle -= _deceleration
+				else:
+					_vitesseActuelle = 0
 </code>
-**[EN CONSTRUCTION]**
+====Ajout d'une Camera2D====
+**L'ajout d'un nœud //Camera2D// permet de suivre facilement les déplacement du personnage.**
+À l'aide de l'inspecteur, j'ai simplement réglé son //offset// à [ 0, - 150 ], et coché la propriété //Current//.
+C'est suffisant pour le prototypage.
+====Changement de direction du personnage====
+L'algorithme est tout bête, il suffit d'**inverser l'échelle du //Sprite// sur l'axe X lors de l'appel à la fonction //bouge()//** . Attention cependant, comme j'ai opté pour un déplacement spécifique lors de l'utilisation du clavier, à savoir de pouvoir reculer sans changer de sens en appuyant sur //Gauche// et //Droite// en même temps, le retournement ne se fait pas dans ce cas-ci.
+<code>
+# Appui sur les boutons clavier de déplacement
+func bouge():
+	if Input.is_action_just_pressed("gauche"):
+		_direction = -1
+		if not Input.is_action_pressed("droite"):
+			$Sprite.set_scale( Vector2( -1, 1 ) )
+	elif Input.is_action_just_pressed("droite"):
+		_direction = 1
+		if not Input.is_action_pressed("gauche"):
+			$Sprite.set_scale( Vector2( 1, 1 ) )
+	if Input.is_action_just_released("gauche"):
+		if not Input.is_action_pressed("droite"):
+			_direction = 0
+		else:
+			_direction = 1
+			$Sprite.set_scale( Vector2( 1, 1 ) )
+	if Input.is_action_just_released("droite"):
+		if not Input.is_action_pressed("gauche"):
+			_direction = 0
+		else:
+			_direction = -1
+			$Sprite.set_scale( Vector2( -1, 1 ) )
+</code>
+====Animation du personnage====
+Il ne manque à ce stade plus que d'**animer le personnage**. J'ai pour ce faire créé quatre //sprites// très simple. Le résultat n'est pas fabuleux mais permet de comprendre comment faire. Voici les texture utilisées :
+{{ ::dm_quatrelutins.png?357 |}}
+J'ai commencé par **ajouter un nœud //AnimationPlayer//** à la scène, auquel j'ai rajouté **3 pistes, nommées //repos//, // saut//, et //marche//**. Pour chacune d'elles, j'ai simplement **modifié la texture** du //Sprite//. //repos// et //saut// ne consistent qu'en une seule clef, //marche// boucle sur 4 textures.
+J'ai activé **la //lecture automatique au chargement// de l'animation //repos//**, et activé **la //lecture en boucle// de l'animation //marche//**.
+**J'ai dû rajouter un nœud //RayCast2D// pour que l'animation du saut se fasse correctement.**
+Ma première idée était d'utiliser //is_on_floor()// pour détecter si le personnage était en train de sauter. Cependant, **lorsque le //KinematicBody2D// glisse le long d'une pente, il lui arrive de se décoller légèrement lorsque que la pente ascendante passe sur un plan horizontal**. Dans ce cas, //is_on_floor()// passe à //false// et déclenche l'animation, ce qui n'est pas joli à voir.
+À la place, j'ai mis un //RayCast2D// sous les pieds du //Joueur//, dont la propriété //Cast To// a été réglée à Vector2( 0, 20 ). J'ai coché le paramètre //enabled// pour l'activer, et changer le //masque de collision//.
+Cependant, cela pose le problème inverse lorsque que le personnage passe une plate-forme à sens unique en sautant. Alors qu'il est sensé être en saut, le //RayCast2D// détecte la plate-forme et lance l'animation. Il faut donc, pendant le saut, désactiver le //RayCast2D//.
+Le tout est ensuite appelé au sein d'une fonction dédiée :
+<code>
+func _physics_process( _delta ):
+	[...]
+	animer()
+[...]
+# Appui sur le bouton de saut
+func entreeSaut():
+	# Mécanisme de saut
+	if is_on_floor():
+		if not $RayCast2D.enabled:
+			$RayCast2D.set_enabled( true )
+		if Input.is_action_just_pressed("espace"):
+			_velocite.y -= _forceSaut
+			_saute = true
+			$RayCast2D.set_enabled( false )
+[...]
+# Animation du personnage :
+func animer():
+	# Vérifier si le personnage est au sol :
+	if $RayCast2D.enabled:
+		if $RayCast2D.is_colliding():
+			# S'il bouge
+			if _velocite.x != 0:
+				$AnimationPlayer.play("marche")
+			# Sinon
+			else:
+				$AnimationPlayer.play("repos")
+	else:
+		$AnimationPlayer.play("saut")
+</code>
+====Contrôle du personnage à la manette====
+Avant de terminer, je souhaite simplement que l'on puisse également **contrôler le personnage à l'aide d'une manette**.
+Dans cette optique, je décide de changer la fonction //bouge()// affin qu'elle se comporte différemment en fonction d'un contrôle au clavier ou à la manette. Trois types de contrôles sont possibles, à la manette, au clavier, et au clavier et à la souris. Cependant, le déplacement du personnage étant restreint à la main gauche au clavier, il sera le même pour les deux derniers modes.
+Je rajoute donc **un paramètre d'entrée et de zone morte pour le **joystick**, et change l'algorithme de déplacement** :
+<code>
+extends KinematicBody2D
+var _typeEntree = "clavier"
+var _zoneMorte = 0.3
+var _gravite = 50
+var _masse = 2
+var _forceSaut = 2000
+var _vitesse = 400
+var _acceleration = 20
+var _deceleration = 10
+var _ratioDInterruptionDuSaut = 0.5
+var _ratioDGraviteSaut = 0.75
+var _direction = 0
+var _vitesseActuelle = 0
+var _forceSautActuelle = 0
+var _velocite = Vector2.ZERO
+var _saute = false
+func _ready():
+	if get_tree().root.has_node("Global"):
+		_typeEntree = Global.typeEntree
+		_zoneMorte = Global.zoneMorte
+		_gravite = Global.gravite
+func _physics_process( _delta ):
+	bouge()
+	entreeSaut()
+	if _saute:
+		if _velocite.y < 0:
+			interruptionDuSaut()
+	traitementDuMouvement()
+	# Intégration du déplacement latéral
+	_velocite.x = _vitesseActuelle
+	# Intégration de la gravité
+	if _velocite.y < 0:
+		_velocite.y += _gravite * _masse * _ratioDGraviteSaut
+	else:
+		_velocite.y += _gravite * _masse
+	_velocite = move_and_slide_with_snap(
+		_velocite,
+		Vector2.ZERO, # Accroche au sol
+		Vector2.UP, # Direction du sol ( Vector2.UP )
+		true, # Ne glisse pas sur le sol en cas d'inactivité ?
+, # Nombre de collisions traitées par cycle
+.9, # Angle maximum du sol ( en radians )
+		false # Inertie infinie ?
+	)
+	animer()
+# Appui sur le bouton de saut
+func entreeSaut():
+	# Mécanisme de saut
+	if is_on_floor():
+		if not $RayCast2D.enabled:
+			$RayCast2D.set_enabled( true )
+		if Input.is_action_just_pressed("espace"):
+			_velocite.y -= _forceSaut
+			_saute = true
+			$RayCast2D.set_enabled( false )
+# Gestion de l'interruption du saut
+func interruptionDuSaut():
+	if Input.is_action_just_released("espace"):
+		_velocite.y *= _ratioDInterruptionDuSaut
+		_saute = false
+# Appui sur les boutons clavier de déplacement
+func bouge():
+	if _typeEntree == "manette":
+		var entree = Input.get_axis("gauche", "droite")
+		if entree < -_zoneMorte:
+			_direction = -1
+			$Sprite.set_scale( Vector2( -1, 1 ) )
+		elif entree > _zoneMorte:
+			_direction = 1
+			$Sprite.set_scale( Vector2( 1, 1 ) )
+		else:
+			_direction = 0
+	else:
+		if Input.is_action_just_pressed("gauche"):
+			_direction = -1
+			if not Input.is_action_pressed("droite"):
+				$Sprite.set_scale( Vector2( -1, 1 ) )
+		elif Input.is_action_just_pressed("droite"):
+			_direction = 1
+			if not Input.is_action_pressed("gauche"):
+				$Sprite.set_scale( Vector2( 1, 1 ) )
+		if Input.is_action_just_released("gauche"):
+			if not Input.is_action_pressed("droite"):
+				_direction = 0
+			else:
+				_direction = 1
+				$Sprite.set_scale( Vector2( 1, 1 ) )
+		if Input.is_action_just_released("droite"):
+			if not Input.is_action_pressed("gauche"):
+				_direction = 0
+			else:
+				_direction = -1
+				$Sprite.set_scale( Vector2( -1, 1 ) )
+# Gestion des accélérations/décélérations
+func traitementDuMouvement():
+# Vélocité horizontale
+	if _direction != 0:
+		_vitesseActuelle += _acceleration * _direction
+		# Restriction aux vitesses max
+		if _vitesseActuelle < 0:
+			if _vitesseActuelle < -_vitesse:
+				_vitesseActuelle = -_vitesse
+		else:
+			if _vitesseActuelle > _vitesse:
+				_vitesseActuelle = _vitesse
+	else:
+		# Décélération au sol
+		if is_on_floor():
+			if _vitesseActuelle < 0:
+				if _vitesseActuelle < -_deceleration:
+					_vitesseActuelle += _deceleration
+				else:
+					_vitesseActuelle = 0
+			elif _vitesseActuelle > 0:
+				if _vitesseActuelle > _deceleration:
+					_vitesseActuelle -= _deceleration
+				else:
+					_vitesseActuelle = 0
+# Animation du personnage :
+func animer():
+	# Vérifier si le personnage est au sol :
+	if $RayCast2D.enabled:
+		if $RayCast2D.is_colliding():
+			# S'il bouge
+			if _velocite.x != 0:
+				$AnimationPlayer.play("marche")
+			# Sinon
+			else:
+				$AnimationPlayer.play("repos")
+	else:
+		$AnimationPlayer.play("saut")
+</code>
+====Notes de fin====
+Et voilà pour cette première étape de personnage. Je décide de m'arrêter ici car **nous avons un personnage jouable pour un jeu simple**. En fait nous avons quasiment le personnage de //Super Mario Bros 3// : celui-ci se déplace latéralement, saute, est affecté par l'inertie, et rentre en collision avec l'environnement.
+Il pourra servir de base pour des jeux n'ayant pas besoin de contrôles supplémentaires.
+Notez que je n'ai pas renommé les noeuds (sauf le parent) pour que vous les identifiiez plus facilement ici, mais qu'il est tout-de-même conseillé de les renommer lors de ses projets propres.
+Je créé par ailleurs **une copie autonome de ce //Joueur// dans le dossier //src/JoueurSimple/// **, en stockant l'ensemble des ressources à l'intérieur même du dossier afin de faciliter l'importation de la scène dans d'autres projets. La dépendance à //Global// n'étant pas forte, le seul paramétrage à faire est d'associer les bonnes entrées utilisateurs dans les //Paramètres du projet//.
 {{tag>godot dindomoteur jeu vidéo}}