Labomedia Ressources

Outils pour utilisateurs

Outils du site

Piste :
dindomoteur_portail_du_moteur_de_metroidvania_orleanais

Différences

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

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
dindomoteur_portail_du_moteur_de_metroidvania_orleanais [2022/03/20 11:21] – Simon Deplatdindomoteur_portail_du_moteur_de_metroidvania_orleanais [2022/03/27 13:42] (Version actuelle) – Simon Deplat
Ligne 67: Ligne 67:
 Cette section discute des réglages généraux du moteur, qui sont de fait partagés par l'ensemble des sous-modules qui constituent du projet. Cette section discute des réglages généraux du moteur, qui sont de fait partagés par l'ensemble des sous-modules qui constituent du projet.
 Pour des raisons de clarté, ces sous-modules sont ensuite discutés dans des pages dédiées du wiki. Pour des raisons de clarté, ces sous-modules sont ensuite discutés dans des pages dédiées du wiki.
 +
 +La version de Godot avec laquelle est développée le moteur est la 3.4.3 .
  
 ====Organisation du répertoire==== ====Organisation du répertoire====
Ligne 90: Ligne 92:
 Le moteur étant particulièrement chauvin, je commence par **utiliser l'interface d'association des entrées utilisateurs ( //Projet > Paramètres du projet... > Contrôles// ) pour associer les touches du clavier aux mots-clefs suivants** : Le moteur étant particulièrement chauvin, je commence par **utiliser l'interface d'association des entrées utilisateurs ( //Projet > Paramètres du projet... > Contrôles// ) pour associer les touches du clavier aux mots-clefs suivants** :
  
-  * q : "gauche" +  * "gauche" 
-  * d : "droite" +    * q 
-  * s : "bas" +    * Left Stick Left 
-  * z : "haut" +  * "droite" 
-  * espace : "espace"+    * d 
 +    * Left Stick Right 
 +  * "bas" 
 +    * s 
 +    * Left Stick Down 
 +  * "haut" 
 +    * z 
 +    * Left Stick Up 
 +  * "espace" 
 +    * espace 
 +    * Xbox A 
 +  * "interagir" 
 +    * E 
 +    * Xbox X
  
 Même s'il est **conseillé d'associer des mot-clefs par action plutôt que par touche**, les différentes utilisations de la touche //espace// possibles m'amènent à garder une balise généraliste pour ce cas particulier. Même s'il est **conseillé d'associer des mot-clefs par action plutôt que par touche**, les différentes utilisations de la touche //espace// possibles m'amènent à garder une balise généraliste pour ce cas particulier.
Ligne 130: Ligne 145:
   * si la ressource externe est chargée également, celle-ci a la priorité sur les méthodes décrite ci-dessus.   * si la ressource externe est chargée également, celle-ci a la priorité sur les méthodes décrite ci-dessus.
  
-Pour mettre en place le nœud global, je créé un script global.gd situé dans le répertoire //src/Main/// puis utilise le menu //Projet > Paramètres du projet... > AutoLoad// pour lui assigner le nom //Global//.+Pour mettre en place le nœud global, je créé une nouvelle scène de type //Node// nommée //Global.tscn// et lui assigne un script //global.gd//, enregistrés dans le répertoire //src/Main/// . Puis j'utilise le menu //Projet > Paramètres du projet... > AutoLoad// pour assigner le nom //Global// à la scène.
  
 **Le mot //Global// permet maintenant d'y accéder depuis n'importe quelle scène** ( exemple : //print( Global.attribut )// ). **Le mot //Global// permet maintenant d'y accéder depuis n'importe quelle scène** ( exemple : //print( Global.attribut )// ).
  
 +Cette scène permettra notamment de **mettre en place un //Affichage Tête Haute// (//ATH//)** à l'aide d'un noeud //CanvasLayer// .
  
-====Définition d'une unité de référence==== +Pour éviter de rendre les nœuds qui utilisent cette scène dépendants de celle-ci, on pourra **vérifier au préalable qu'elle est bien chargée avant d'y accéder**, par exemple pour le //Joueur// qui accède à une variable de gravité stockée dans //global.gd// :
-**Certaines classes de Godot ont besoin d'une unité spatiale de référence** pour fonctionner, notamment les //tilemaps//. Cette unité aura un impact sur d'autres nœuds, par exemple le joueur dont la capacité de saut devra faire sens en fonction du //tilemap//. +
- +
-De manière presque arbitraire, **cette unité de référence sera la puissance de deux** ( 32 / 64 / 128 / 256 / 512 ). +
- +
-Veuillez noter que **la possibilité de zoomer sur des éléments du jeu via l'utilisation du nœud //Camera2D// change la manière dont on devra penser le système de résolution par rapport à la taille effective des éléments graphiques en terme de collision**. Le système de //mipmaps// se chargera de gérer ces mises-à-l'échelles. +
- +
-=====Sous-articles du moteur===== +
-Cette section présente les différents sous-articles du projet, qui documentent indépendamment les différents sous-modules du moteur : +
- +
- +
-=====Mise-en-place des collisions===== +
-On commence par modifier les masques de collision pour faciliter le travail : +
-  * 1 : joueur +
-  * 2 : ennemis +
-  * 3 : objets +
-  * 4 : terrain +
-  * 5 : terrain2 +
- +
-**On modifie les nœuds de collision afin qu'ils correspondent.** Pour l'instant, //terrain2// est laissé de côté. +
- +
-Dans les versions précédente de //Godot//, le //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. +
- +
-Nous commençons par mettre en place un système similaire, en créant un répertoire //src/Personnage/// et un script //Personnage.gd// . +
- +
-Après quelques recherches, voici [[https://docs.godotengine.org/fr/stable/tutorials/physics/using_kinematic_body_2d.html|la documentation du système de collision que nous utilisons]]. +
- +
- +
-=====C'est grave docteur ?===== +
-À ce stade, nous avons donc le script //Personnage.gd// , auquel nous avons simplement **implémenté la gravité** :+
  
 <code> <code>
-class_name Personnage +_gravite = 50
-extends KinematicBody2D+
  
-export var masse = 60 +[...]
-onready var gravite = ProjectSettings.get( "physics/2d/default_gravity" )+
  
-const NORMAL_SOL = Vector2.UP +func _ready(): 
- + if get_tree().root.has_node("Global"): 
-var _velocite = Vector2.ZERO + _gravite = Global.gravite
- +
-# la fonction _physics_process héritée est appelée +
-# après la fonction _physics_process parente +
-func _physics_process( delta ): +
- _velocite.y += gravite * masse * delta+
 </code> </code>
  
-Ainsi que le script //Joueur.gd// :+Ci-dessus, vous pouvez voir qu'il y a déjà une valeur assignée par défaut à //_gravite// : il est important d'avoir des valeurs de sécurité pour ne pas casser le nœud si la dépendance est manquante. Cette méthodologie favorise [[https://fr.wikipedia.org/wiki/Couplage_(informatique)|le couplage faible]].
  
-<code> +===Ajout du paramètre de gravité===
-class_name Joueur +
-extends Personnage+
  
-const DETECTION_DISTANCE_SOL = 20.0 +Au lieu d'utiliser l'API de Godot, nous centralisons la gravité via le nœud //Global// :
- +
-func _physics_process( _delta ): +
- var accrocheVectorielle = Vector2.DOWN * DETECTION_DISTANCE_SOL +
-  +
- _velocite = move_and_slide_with_snap( +
- _velocite, +
- accrocheVectorielle, # Accroche au sol +
- NORMAL_SOL, # Direction du sol ( Vector2.UP ) +
- true, # Ne glisse pas sur le sol en cas d'inactivité ? +
- 4, # Nombre de collisions traitées par cycle +
- 0.9, # Angle maximum du sol ( en radians ) +
- false # Inertie infinie ? +
- ) +
-</code> +
- +
-Le personnage, emporté par son propre poids, est attiré vers le sol et s'y accroche à son contact. +
- +
-=====Mouvements latéraux===== +
-Après cela, **nous pouvons déplacer le personnage latéralement** grâce au clavier : +
- +
-//Personnage.gd//+
 <code> <code>
-class_name Personnage +... 
-extends KinematicBody2D +var gravite = 50 
- +... 
-var direction = Vector2.ZERO +func _ready(): 
- + ... 
-export var masse = 60 + ProjectSettings.set_setting( "physics/2d/default_gravity", gravite ) 
-export var vitesse = 300 +...
- +
-onready var gravite = ProjectSettings.get( "physics/2d/default_gravity" ) +
- +
-const NORMAL_SOL = Vector2.UP +
- +
-var _velocite = Vector2.ZERO +
- +
-# la fonction _physics_process héritée est appelée +
-# après la fonction _physics_process parente +
-func _physics_process( delta ): +
- _velocite.y += gravite * masse * delta+
 </code> </code>
  
-//Joueur.gd// 
-<code> 
-class_name Joueur 
-extends Personnage 
  
-# Distance d'accrochage aux formes de collisions : +====Script actuel du nœud global ( global.gd )====
-const DETECTION_DISTANCE_SOL = 20.0+
  
-func _physics_process( _delta ): 
- var accrocheVectorielle = Vector2.DOWN * DETECTION_DISTANCE_SOL 
-  
- bouge() 
-  
- _velocite.x = direction.x * vitesse 
-  
- _velocite = move_and_slide_with_snap( 
- _velocite, 
- accrocheVectorielle, # Accroche au sol 
- NORMAL_SOL, # Direction du sol ( Vector2.UP ) 
- true, # Ne glisse pas sur le sol en cas d'inactivité ? 
- 4, # Nombre de collisions traitées par cycle 
- 0.9, # Angle maximum du sol ( en radians ) 
- false # Inertie infinie ? 
- ) 
- 
-func bouge(): 
- if Input.is_action_just_pressed("gauche"): 
- direction.x = -1 
- elif Input.is_action_just_pressed("droite"): 
- direction.x = 1 
-  
- if Input.is_action_just_released("gauche"): 
- if not Input.is_action_pressed("droite"): 
- direction.x = 0 
- else: 
- direction.x = 1 
-  
- if Input.is_action_just_released("droite"): 
- if not Input.is_action_pressed("gauche"): 
- direction.x = 0 
- else: 
- direction.x = -1 
-</code> 
- 
-**Il n'y a pas d'inertie pour l'instant**, le personnage commence à se mouvoir à sa vitesse maximale et s'arrête d'un coup. 
- 
-=====Système de saut===== 
-On peut maintenant **le faire sauter** de plate-forme en plate-forme grâce à la touche //espace// : 
- 
-//Personnage.gd// 
 <code> <code>
-class_name Personnage +extends Node
-extends KinematicBody2D+
  
-var direction = Vector2.ZERO+var typeEntree = "clavier" 
 +var zoneMorte = 0.3
  
-export var masse = 350 +var gravite = 50
-export var vitesse = 300 +
-export var forceSaut = 200+
  
-var forceSautActuelle = 0+func _ready(): 
 + ProjectSettings.set_setting( "physics/2d/default_gravity", gravite )
  
-onready var gravite = ProjectSettings.get( "physics/2d/default_gravity" ) 
- 
-const NORMAL_SOL = Vector2.UP 
- 
-var _velocite = Vector2.ZERO 
- 
-# la fonction _physics_process héritée est appelée 
-# après la fonction _physics_process parente 
-func _physics_process( delta ): 
- _velocite.y += gravite * masse * delta 
 </code> </code>
  
-//Joueur.gd// +====Définition d'une unité de référence==== 
-<code> +**Certaines classes de Godot ont besoin d'une unité spatiale de référence** pour fonctionner, notamment les //tilemaps//. Cette unité aura un impact sur d'autres nœuds, par exemple le joueur dont la capacité de saut devra faire sens en fonction du //tilemap//.
-class_name Joueur +
-extends Personnage+
  
-# Distance d'accrochage aux formes de collisions : +De manière presque arbitraire, **cette unité de référence sera la puissance de deux** ( 32 / 64 / 128 / 256 / 512 ).
-const DETECTION_DISTANCE_SOL = 20.0+
  
-onready var detectionSol = $detectionSol+Veuillez noter que **la possibilité de zoomer sur des éléments du jeu via l'utilisation du nœud //Camera2D// change la manière dont on devra penser le système de résolution par rapport à la taille effective des éléments graphiques en terme de collision**. Le système de //mipmaps// se chargera de gérer ces mises-à-l'échelles.
  
-func _ready(): +====Mise-en-place des collisions==== 
- pass+**Les masques de collision sont redéfinis** pour faciliter le travail, dans les //Paramètres du projet//, via le menu //Layer Names > 2d Physics// : 
 +  * 1 : joueur 
 +  * 2 : ennemis 
 +  * 3 : objets 
 +  * 4 : terrain 
 +  * 5 : terrain2
  
-func _physics_process( _delta ): +À ce moment de la rédaction de la documentation, il est fort probable que ces calques soient temporaires. Il y a par exemple de grandes chances qu'un calque dédié à la //Camera2D// soit nécessaire (notamment pour bloquer le déplacement de la caméra lors d'une chute du fatale du //Joueur//).
- var accrocheVectorielle = Vector2.DOWN * DETECTION_DISTANCE_SOL +
- var surLeSol = detectionSol.is_colliding() +
-  +
- bouge() +
-  +
- if surLeSol: +
- if Input.is_action_just_pressed("espace"): +
- forceSautActuelle = forceSaut +
-  +
- _velocite.y -= forceSautActuelle +
- if forceSautActuelle > 0: +
- forceSautActuelle = forceSautActuelle - gravite +
- if forceSautActuelle < 0: +
- forceSautActuelle = 0 +
-  +
- _velocite.x = direction.x * vitesse +
-  +
- _velocite = move_and_slide_with_snap( +
- _velocite, +
- Vector2.ZERO, # Accroche au sol +
- NORMAL_SOL, # Direction du sol ( Vector2.UP ) +
- true, # Ne glisse pas sur le sol en cas d'inactivité ? +
- 4, # Nombre de collisions traitées par cycle +
- 0.9, # Angle maximum du sol ( en radians ) +
- false # Inertie infinie ? +
- )+
  
-func bouge(): +=====Sous-articles du moteur===== 
- if Input.is_action_just_pressed("gauche"): +Cette section présente les sous-articles du projet, qui documentent indépendamment les différents sous-modules du moteur :
- direction.x = -1 +
- elif Input.is_action_just_pressed("droite"): +
- direction.x = 1 +
-  +
- if Input.is_action_just_released("gauche"): +
- if not Input.is_action_pressed("droite"): +
- direction.x = 0 +
- else: +
- direction.x = 1 +
-  +
- if Input.is_action_just_released("droite"): +
- if not Input.is_action_pressed("gauche"): +
- direction.x = 0 +
- else: +
- direction.x = -1 +
-</code>+
  
-Avec cette version, il est possible de modifier sa direction pendant le saut, ce qui n'est pas réaliste mais plutôt agréable à jouer ! Pour changer le dynamisme des sauts, il faut modifier intelligemment la masse du Joueur et sa force de saut.+[[https://ressources.labomedia.org/dindomoteur_creation_du_joueur|Création du Joueur]] : explication de l'implémentation du personnage principal.
  
 {{tag>godot dindomoteur jeu vidéo}} {{tag>godot dindomoteur jeu vidéo}}
dindomoteur_portail_du_moteur_de_metroidvania_orleanais.1647775268.txt.gz · Dernière modification : 2022/03/20 11:21 de Simon Deplat