Créer un jeu de plateforme complet en pixels dans Godot 4 ! | Thomas Yanuziello | Skillshare

Vitesse de lecture


1.0x


  • 0.5x
  • 0.75x
  • 1 x (normale)
  • 1.25x
  • 1.5x
  • 1.75x
  • 2x

Créer un jeu de plateforme complet en pixels dans Godot 4 !

teacher avatar Thomas Yanuziello, Indie Game Developer

Regardez ce cours et des milliers d'autres

Bénéficiez d'un accès illimité à tous les cours
Suivez des cours enseignés par des leaders de l'industrie et des professionnels
Explorez divers sujets comme l'illustration, le graphisme, la photographie et bien d'autres

Regardez ce cours et des milliers d'autres

Bénéficiez d'un accès illimité à tous les cours
Suivez des cours enseignés par des leaders de l'industrie et des professionnels
Explorez divers sujets comme l'illustration, le graphisme, la photographie et bien d'autres

Leçons de ce cours

    • 1.

      Intro

      1:23

    • 2.

      0-1 Introduction à la programmation

      8:03

    • 3.

      0-2 constantes et variables

      9:11

    • 4.

      0-3 Si Déclarations et conditions

      9:46

    • 5.

      0-4 Pendant Loops et opérateurs

      9:23

    • 6.

      0-5 tableaux et pour boucles

      10:32

    • 7.

      0-6 piles et fonctions

      10:53

    • 8.

      0-7 Match et retour

      9:34

    • 9.

      0-8 Arbre de scène et héritage

      10:21

    • 10.

      0-9 Abstraction et encapsulation

      10:41

    • 11.

      Polymorphisme 0-10

      8:01

    • 12.

      Dictionnaire 0-11

      8:54

    • 13.

      0-12 déboguer

      9:08

    • 14.

      Préparation 1-0

      10:21

    • 15.

      1-1 personnage

      6:44

    • 16.

      1-2 entrées

      8:58

    • 17.

      1-3 Locomotion

      8:32

    • 18.

      1-4 saut

      6:45

    • 19.

      1-5 animation

      5:53

    • 20.

      Machine à 1-6 états

      6:05

    • 21.

      1-7 effets

      10:21

    • 22.

      2-1 plan

      6:07

    • 23.

      2-2 décorations

      6:17

    • 24.

      2-3 caméras

      9:04

    • 25.

      2-4 enfants

      7:07

    • 26.

      2-5 arrière-plan

      9:55

    • 27.

      2-6 personnes d'eau

      11:16

    • 28.

      2-7 limites

      9:09

    • 29.

      3-1 Données

      8:07

    • 30.

      3-2 pièces

      8:57

    • 31.

      3-3 Interface utilisateur

      9:01

    • 32.

      3-4 vies

      10:24

    • 33.

      3-5 coffre

      10:20

    • 34.

      3-6 serrures et clés

      10:02

    • 35.

      3-7 cartes

      10:10

    • 36.

      4-1 Dommage

      9:55

    • 37.

      Réaction 4-2

      9:59

    • 38.

      4-3 récupération

      9:51

    • 39.

      4-4 points de contrôle

      9:30

    • 40.

      4-5 décès

      10:05

    • 41.

      4-6 ennemis

      10:27

    • 42.

      4-7 parties

      13:17

    • 43.

      5-1 épée

      11:24

    • 44.

      Attaque 5-2

      12:03

    • 45.

      5-3 attaques aériennes

      9:43

    • 46.

      5-4 patrouille

      9:28

    • 47.

      5-5 Agressivité

      9:45

    • 48.

      5-6 projectiles

      14:01

    • 49.

      5-7 patron

      13:52

    • 50.

      6-1 pause

      8:59

    • 51.

      6-2 titres

      9:49

    • 52.

      6-3 niveaux

      9:19

    • 53.

      6-4 Enregistrer

      8:40

    • 54.

      6-5 déblocage

      10:35

    • 55.

      6-6 Musique

      9:43

    • 56.

      6-7 Exportation

      7:33

  • --
  • Niveau débutant
  • Niveau intermédiaire
  • Niveau avancé
  • Tous niveaux

Généré par la communauté

Le niveau est déterminé par l'opinion majoritaire des apprenants qui ont évalué ce cours. La recommandation de l'enseignant est affichée jusqu'à ce qu'au moins 5 réponses d'apprenants soient collectées.

519

apprenants

1

projets

À propos de ce cours

Apprenez à créer un jeu de plateforme complet dans Godot 4 en suivant ce cours !  Que vous soyez novice dans le développement de jeux, que vous débutiez dans le moteur Godot ou que vous souhaitiez vous perfectionner dans certains principes de design de haut niveau, vous apprendrez beaucoup ici !  Le début du cours se concentre sur la rédaction de scripts et le langage GDScript.  Si vous maîtrisez déjà Godot et GDScript, vous pouvez sauter ces leçons et passer directement à la leçon de configuration.

Cliquez sur le lien de mon site Web dans mon profil pour rejoindre notre serveur discord !

Chaque section du cours se concentre généralement sur un aspect du jeu : personnage, niveaux, trésor, ennemis, etc.  Les sections sont ensuite divisées en 7 leçons vidéo, chacune axée sur l'enseignement d'une fonctionnalité du moteur Godot, d'un script ou d'une partie spécifique du développement de jeux.  À la fin de chaque section, vous disposerez d'un modèle pour créer les différents aspects de votre jeu.

Vous devrez accomplir un devoir avant de poursuivre le reste du cours, en répétant bon nombre des leçons apprises tout au long de la section pour mettre en œuvre davantage d'éléments de jeu, tout en proposant des défis supplémentaires à ceux qui souhaitent les essayer.  Les défis sont facultatifs et ne sont pas nécessaires pour suivre les leçons.

Ce cours comprend la rédaction de scripts dans le langage de script Godot.  Si c'est la première fois que vous utilisez un script, vous pouvez suivre le cours et je vous expliquerai les différents éléments au fur et à mesure.  Pour éviter de submerger les nouveaux apprenants, je vais essayer de ne pas tout expliquer en une seule fois, mais de me concentrer sur les éléments individuels qui sont pertinents pour chaque leçon.  Si vous avez de l'expérience en écriture de scripts dans d'autres langues, le script Godot est extrêmement facile à apprendre et vous serez en mesure d'apprécier à quel point il est optimisé pour le moteur et le développement de jeux en général.

Les ressources utilisées dans ce cours sont disponibles gratuitement sur itch.io et FreeSound.org.

Rencontrez votre enseignant·e

Teacher Profile Image

Thomas Yanuziello

Indie Game Developer

Enseignant·e
Level: Intermediate

Notes attribuées au cours

Les attentes sont-elles satisfaites ?
    Dépassées !
  • 0%
  • Oui
  • 0%
  • En partie
  • 0%
  • Pas vraiment
  • 0%

Pourquoi s'inscrire à Skillshare ?

Suivez des cours Skillshare Original primés

Chaque cours comprend de courtes leçons et des travaux pratiques

Votre abonnement soutient les enseignants Skillshare

Apprenez, où que vous soyez

Suivez des cours où que vous soyez avec l'application Skillshare. Suivez-les en streaming ou téléchargez-les pour les regarder dans l'avion, dans le métro ou tout autre endroit où vous aimez apprendre.

Transcription

1. Promo V2: Tu as commencé à apprendre Dieu. Vous avez suivi des tutoriels et réalisé de petits projets, mais vous êtes prêt à passer au niveau supérieur et à créer un jeu complet avec un niveau, un code, une structure et un design professionnels . Ce cours vous apprendra à créer une plateforme de pixels complète à partir de zéro et à créer un jeu évolutif avec un code réutilisable qui peut être appliqué à des jeux d'autres genres. Vous apprendrez à créer un personnage que le joueur peut contrôler et à créer des niveaux, suivre la progression du joueur votre jeu et à réagir aux points de contrôle, à créer un système de combat avec des ennemis et un combat de boss, et à apprendre les principes de conception évolutifs Gadot que vous pouvez appliquer à n'importe quel projet Gadot Lorsque vous aurez terminé, vous aurez un modèle de jeu complet que vous pourrez remplir avec plus de niveaux, plus de mécanismes, plus d' objets et plus d'ennemis Si vous avez besoin d'aide, notre serveur Discord regorge d' autres étudiants et développeurs de jeux qui peuvent répondre à toutes vos questions Cliquez sur le lien du site Web et sur mon profil pour vous inscrire. Nous allons commencer par un projet vierge dans la version 4.2 de Godot et utiliser les ressources gratuites de son point IO Mais vous pouvez suivre votre propre projet en utilisant différents actifs. Des notes et des vidéos supplémentaires ont également été ajoutées pour mettre à jour les nouvelles fonctionnalités de la version 4.3 de Godot Commençons à créer votre premier jeu complet. 2. 0-1 Introduction à la programmation: Bonjour les amis. vous devez télécharger le GDOGameEngine sur gdongine.org Si ce n'est pas déjà fait, vous devez télécharger le GDOGameEngine sur gdongine.org . Le moteur est gratuit, mais vous pouvez faire un don pour soutenir le projet si vous le souhaitez. Il n'y a aucun processus d'installation. Vous pouvez simplement extraire le fichier compressé et l'ouvrir. Veillez à déplacer le fichier exécutable vers un meilleur emplacement. La fenêtre de lancement initiale est une liste de vos projets en cours. Mais si vous n' avez pas encore de projet, vous serez invité à explorer des projets de démonstration. Nous pouvons ignorer cela et simplement créer notre propre nouveau projet soit en cliquant sur ce bouton dans la liste des projets soit sur le bouton Créer en haut de la fenêtre. Ici, nous pouvons donner un nom à notre projet, qui serait généralement le nom de votre jeu. Je vais juste passer à l'introduction à la programmation. Le projet doit être stocké sur le disque dur de notre ordinateur, et nous allons créer un nouveau dossier portant le même nom que le projet. Par défaut, il souhaite tout stocker dans le dossier des documents, mais il serait préférable de créer un nouveau sous-dossier pour les projets Godot Le moteur de rendu modifie la façon dont certains objets en deux et trois D sont rendus, mais nous ne dessinerons rien Nous pouvons donc ignorer ces options Le moteur de rendu peut également être modifié ultérieurement. Et la compatibilité du contrôle de version avec Github est incluse par défaut si vous souhaitez l'utiliser pour sauvegarder votre projet ou le partager avec d'autres Lorsque vous êtes prêt à commencer, cliquez sur Créer et modifier. La fenêtre GDOEditor ouvrira notre projet vide nouvellement créé. L'éditeur est divisé en cinq docks principaux. Un aperçu de notre jeu se trouve au centre. Le dock inférieur gauche contient un navigateur de fichiers affichant le contenu du dossier de projet que nous venons de créer. Il ne contient actuellement que l'icône Gadot. Le dock supérieur gauche contient l'arbre des scènes, une liste de tout ce qui se trouve dans notre scène actuelle, qui est actuellement vide Il nous demande donc de créer une racine pour l'arbre de scène. Nous ne dessinerons rien, nous n'avons donc pas besoin de préciser si cette scène est deux ou trois D ou s'il s'agit d' une interface utilisateur. Nous pouvons donc simplement sélectionner un autre nœud. Il existe de nombreux nœuds différents que nous pouvons créer, mais nous voulons uniquement apprendre à écrire des scripts Nous utiliserons donc simplement un nœud par défaut. Nous pouvons renommer notre nouveau nœud en cliquant dessus une fois qu'il a été sélectionné ou en cliquant avec le bouton droit de la souris pour ouvrir son menu contextuel et en sélectionnant renommer Appelons ce nœud Lesson 1. sélection d'un nœud dans l'arbre de scène révélera ses propriétés dans l'inspecteur, qui est ancré sur le côté droit de la fenêtre Nous pouvons voir le nom du nœud sélectionné et ses propriétés organisées en catégories extensibles, mais aucune de ces propriétés n'est ses propriétés organisées en catégories extensibles, mais aucune de ces propriétés applicable à ce que nous faisons Avant de faire quoi que ce soit d'autre, nous devons enregistrer notre nouvelle scène, soit en sélectionnant Enregistrer la scène dans le menu de la scène, soit en utilisant le raccourci Control S ou Command S. Cela ouvre une boîte de dialogue dans laquelle nous pouvons spécifier un nom pour notre scène avec le TSCNetExtension, ainsi qu'un Créons un nouveau dossier pour la leçon 1, puis enregistrons la scène dans ce dossier. Nous pouvons maintenant voir dans l'onglet du système de fichiers que notre nouveau dossier a été créé pour la première leçon et qu'il contient la scène de la leçon 1, marquée par l'icône Clapperboard Ensuite, nous allons attacher un script au nœud racine de notre scène, soit en sélectionnant le nœud racine et en cliquant sur le bouton du script joint, soit en cliquant dessus avec le bouton droit de la souris et en sélectionnant le script attaché. Le langage est GD Script, qui est le langage de programmation que nous allons apprendre Chaque script héritera du type de nœud auquel il est attaché par défaut Le nœud racine étant un type de nœud par défaut, notre script hérite de node Nous n'utilisons ni modèle ni script intégré, et nous pouvons spécifier où ce script sera stocké dans le projet. Mettons-le dans le même dossier. Leçon 1. Lorsque vous nommez des scripts, il est important de ne pas être arbitraire, mais de décrire le type d' objet ou de comportement que nous créons par le biais du script. Alors appelons-le bonjour. Les scripts ont l' extension de fichier DotGD. Cliquez ensuite sur Créer pour créer le script. Cela fera passer notre aperçu en mode script, affichant notre script hello nouvellement créé. Nous pouvons également voir notre script dans l'onglet du système de fichiers indiqué par une icône en forme de roue dentée, et le nœud racine de la leçon 1 possède une icône de script qui nous indique qu'un script y est attaché et qui, lorsque nous le survolons, nous indiquera le nom du cliquer sur cette icône ouvre également le script s'il n'est pas déjà ouvert. Notre script ne comporte qu'une seule ligne, qui décrit son héritage du type de nœud de base à l'aide du mot clé extends. Cela signifie simplement que notre script peut faire tout ce un nœud peut faire, plus tout ce que nous écrivons ici. Cela nous permet également de remplacer les comportements du nœud qui existent déjà par de nouveaux comportements qui nous sont propres. Par exemple, les nœuds ont une fonction nommée ready, mais elle ne fait rien. Donc, si nous voulons que notre script remplace ce comportement consistant à ne rien faire, nous pouvons déclarer notre propre fonction du même nom en utilisant le mot clé funk Funk est ensuite suivi du nom de la fonction, généralement écrit en minuscules, généralement écrit en c'est-à-dire toutes les lettres minuscules séparant les mots De nombreuses fonctions définies par les nœuds sont précédées d'un trait de soulignement, et le nom doit correspondre exactement pour annuler le comportement Le nom de la fonction doit être suivi de parenthèses et de deux Nous verrons pourquoi plus tard. En appuyant sur Entrée après cette ligne, la ligne suivante est automatiquement indentée d'un niveau C'est ainsi que GD Script sait quelles lignes sont contenues dans la fonction et où elle se termine La ligne est surlignée en rouge car les fonctions ne sont pas autorisées à être vides. C'est donc une bonne idée d' écrire le mot « pass » pour donner de nouvelles fonctions à un corps qui ne fait rien. Maintenant que l'erreur a disparu, nous pouvons voir cette icône en forme de flèche bleue apparaître devant la déclaration de fonction, qui est le symbole de dérogation, indiquant que ce script remplace désormais le comportement normal de notre nœud Au lieu de ne rien faire, nous voulons que notre nœud dise bonjour, ce que nous pouvons faire avec une instruction print, en remplacement de la ligne qui disait « pass » précédemment. L'instruction print ressemble à une déclaration de fonction dont nom est suivi de parenthèses car elle appelle une fonction intégrée Cette fonction nécessite un argument, qui est placé entre parenthèses Et c'est cet argument qui sera imprimé. En utilisant des guillemets, nous pouvons écrire ce que nous voulons, et cela sera imprimé par notre script lorsque le nœud sera prêt. Comme le script s'appelle hello, le comportement que nous voulons créer est que le nœud dise bonjour. Notre script étant prêt, nous pouvons lancer notre jeu en utilisant le bouton Exécuter la scène en cours en haut à droite ou en utilisant le raccourci F six. Cela affichera une fenêtre vide, puisque notre jeu ne dessine rien, mais cela ouvre également le cinquième dock, affichant le panneau de sortie. Et dans notre sortie, nous pouvons voir que notre nœud a imprimé les mots « Bonjour tout le monde » lorsqu'il était prêt. Nous pouvons terminer cette simulation en fermant la fenêtre, en cliquant sur le bouton d'arrêt ou en utilisant le raccourci F huit. Nous pouvons modifier le texte imprimé pour qu'il dise ce que nous voulons et le réexécuter pour que notre nœud puisse imprimer tout ce que nous lui demandons. Nous savons maintenant comment associer des scripts aux nœuds et les exécuter. Dans la leçon suivante, nous allons en apprendre davantage sur les constantes et les variables. Je te verrai dans la prochaine leçon. 3. 0-2 constantes et variables: Bonjour, mes amis. Nous allons commencer chaque leçon en créant d'abord un nouveau dossier pour la leçon. Créez ensuite une nouvelle scène dans le dossier du même nom. Double-cliquez sur une scène dans l'onglet du système de fichiers pour l'ouvrir. Lorsque plusieurs scènes sont ouvertes, nous pouvons passer de l'une à l'autre en cliquant sur leurs onglets dans le document d'aperçu. Aujourd'hui, nous allons discuter des différences entre les constantes et les variables en utilisant les jours comme cadre de référence. Attachons donc un nouveau script au nœud racine de la scène et nommons-le jours. Commençons par les constantes et déclarons-en une en haut du script en utilisant le mot clé const, suivi du nom de notre nouvelle constante, qui est généralement écrit en majuscules et minuscules. Une constante est comme un conteneur dans lequel nous pouvons stocker des informations, mais ces informations ne sont jamais autorisées à changer. Quelque chose que nous considérerions comme une constante pourrait être le nombre de jours dans la semaine. Comme il ne peut pas être modifié, il faut lui donner une valeur immédiatement, c'est pourquoi nous avons une erreur. Nous devons suivre le nom d'un signe égal, l'opérateur d'assignation pour donner une valeur à la constante. Le nombre de jours par semaine est de sept. Il est raisonnable de supposer qu'il y en aura toujours sept et qu'il en sera de même pour tout le monde. Par conséquent, il ne devrait jamais avoir besoin de modifier sa valeur. À l'inverse, nous avons des variables, qui sont également des conteneurs pour stocker des informations, mais qui sont conçues pour être modifiées. Nous pouvons déclarer une variable la même manière en utilisant le mot-clé VR, puis en lui donnant un nom écrit classiquement en minuscules Cela permet de voir facilement la différence entre les constantes et les variables dans nos scripts. Quelque chose qui change fréquemment est peut-être la valeur d'aujourd'hui. Contrairement aux constantes, les variables peuvent être vides. Remplaçons la fonction Ready de notre nœud de base et imprimons les valeurs du nombre de jours de la semaine et du jour Nous pouvons voir que le nombre de jours de la semaine est de sept, mais que la valeur du jour est imprimée sous la forme nulle, ce qui signifie que la valeur est vide ou nulle. Corrigeons cela en initialisant aujourd'hui à jeudi. Et nous pouvons rendre notre sortie plus lisible en ajoutant du contexte, commençant par quelque chose comme « aujourd'hui », puis en laissant un espace après le signe plus, puis notre variable. Dans ce cas, le signe plus est utilisé pour joindre deux phrases si nous essayons de faire la même chose Cependant, si nous essayons de faire la même chose avec notre constante, cela provoquera une erreur car notre constante est un nombre et non un mot. Lorsque nous avons déclaré notre constante, nous lui avons attribué une valeur de sept, qui est un nombre sans décimal, appelé entier en mathématiques Notre constante a donc un type entier. Aujourd'hui, en revanche, a attribué une valeur de certains caractères entre guillemets. En programmation, on appelle cela une chaîne de caractères. Notre variable a donc un type de chaîne. L'opérateur plus ne peut être utilisé lorsque les types des deux opérandes sont compatibles Nous pouvons contourner ce problème en utilisant une fonction intégrée pour changer le type tel qu'il est utilisé ici en chaîne, en passant la constante comme argument à la fonction. Cela ne changera pas le type de la constante d'origine, mais uniquement la façon dont elle est utilisée ici dans le contexte de l'opération d'ajout Et nous pouvons continuer à ajouter contexte par la suite avec une autre chaîne ajoutée, en n' oubliant pas d'ajouter un espace supplémentaire au début. Nous pouvons donc maintenant imprimer notre constante et notre variable en les utilisant dans des phrases faciles à comprendre. Après ces lignes, faisons comme si un jour passait. Nous pouvons ajouter à nos scripts un contexte supplémentaire qui ne sera jamais vu par les joueurs, mais qui n'existe que pour nous aider, en tant que développeurs, à comprendre notre propre code ou le code écrit par d'autres. Ils sont appelés commentaires et sont créés l'aide du signe ou du hashtag OctathorpPound Tout texte écrit après ce symbole sera coloré en gris et n'affectera en rien le fonctionnement du script. Ils peuvent être sur leurs propres lignes ou à la fin d'une ligne de code. Utilisons donc un commentaire pour expliquer que nous prétendons qu' un jour s'est écoulé entre le code au-dessus de cette ligne et le code ci-dessous. Nous allons changer la valeur d'aujourd'hui pour qu'elle soit vendredi et imprimer une autre phrase. Aujourd'hui, c'est plus Today, qui a désormais une valeur différente. Nous pouvons voir que la valeur du jour a d'abord été imprimée en tant que jeudi, puis modifiée et imprimée en tant que vendredi sur la ligne suivante. Le commentaire n'a eu aucun effet sur le script en cours d'exécution. Si nous essayons de modifier la valeur de notre constante, cela provoquera évidemment une erreur car les constantes ne sont pas autorisées à être modifiées. Si nous ne voulons plus utiliser certaines lignes de code dans notre script, nous pouvons facilement les transformer en commentaires en les surlignant et en appuyant sur Ctrl K ou Command K, en ajoutant le symbole de commentaire au début de chaque ligne surlignée. Appuyez à nouveau dessus pour supprimer les commentaires. Nous pouvons spécifier le type de variable ou de constante en ajoutant deux points après le nom. Suivi du nom du type, nous voulons également restreindre cette constante ou variable. Restreignons notre constante à être de type int et aujourd'hui de type chaîne. Outre les chaînes et les entiers, il existe deux autres types primitifs que nous pouvons utiliser pour stocker des informations de base Si un nombre contient des décimales, il ne s'agit plus d'un entier mais d' un autre type appelé nombre à virgule flottante, qui utilise le nom de type float Ajoutons une autre variable pour la date d'aujourd'hui et donnons-lui un type de nombre à virgule flottante avec une valeur de 12,05, qui correspond à la date du 5 décembre Et le dernier type est appelé Boolean en utilisant le nom abrégé Boole, qui peut être vrai ou Nous allons donc ajouter une autre variable pour savoir si aujourd'hui est un jour férié ou non. Je vais limiter cela à un booléen, mais je ne lui donnerai pas de valeur initiale Ajoutons deux instructions d'impression supplémentaires pour imprimer les valeurs de ces variables avec le contexte. La date d'aujourd'hui est une date plus, et aujourd'hui est un jour férié. Colon Plus est un jour férié. Lorsque nous l'exécutons maintenant, nous pouvons voir notre date imprimée, mais est-ce qu' un jour férié dit faux, même s'il ne lui a pas donné de valeur. Cela est dû au fait que tous les types primitifs ont une valeur par défaut, mais la valeur par défaut ne peut être attribuée que si nous spécifiez le type de variable. Comme nous avons précisé qu' un jour férié est un booléen, valeur par défaut d' un booléen lui a été attribuée , La valeur par défaut d'un entier et d'un nombre à virgule flottante est égale à zéro, et la valeur par défaut d' une chaîne est simplement une chaîne vide, qui n'est pas identique à null, mais une chaîne ne contenant aucun caractère. Si nous ne spécifiez pas le type d'une variable, sa valeur par défaut sera nulle, mais il est possible de lui attribuer une valeur de n'importe quel type, et son type peut changer à tout moment. Supprimons le type de date. Donnez-lui ensuite la nouvelle valeur du 13 décembre et imprimez-le une deuxième fois. La variable commence par se voir attribuer une valeur de nombre à virgule flottante, est utilisée par l'instruction print, puis une valeur de chaîne lui est attribuée avant d'être à nouveau imprimée. Cela est autorisé car GD Script est un langage mal typé Cela offre une plus grande flexibilité lors de l'écriture de nos scripts, mais également une plus grande responsabilité pour éviter les erreurs de compatibilité de type, comme nous l'avons vu avec l'opérateur plus. Il est recommandé de toujours attribuer un type à vos variables, non seulement pour éviter les erreurs, mais également pour améliorer l' efficacité de l'exécution de vos scripts. Si le moteur connaît le type de vos variables, il sait également exactement quelle quantité de mémoire il doit occuper. Cela vaut également pour l'utilisation constantes à la place de variables. Si le moteur sait que la valeur ne peut pas changer, il peut être utilisé plus efficacement. Dans la leçon suivante, nous allons apprendre comment contrôler le flux de nos scripts. Je te verrai dans la prochaine leçon. 4. 0-3 Si Déclarations et conditions: Bonjour, mes amis. J'ai déjà créé une nouvelle scène dans un nouveau dossier pour cette leçon. Aujourd'hui, nous allons apprendre à contrôler le flux de nos scripts pour exécuter différentes lignes de code, en décidant si nous pouvons voir ou non. Attachons donc un nouveau script au nœud racine de notre scène et nommons-le vision. Nous allons commencer notre script en remplaçant la définition des nœuds de base de la fonction ready méthode la plus élémentaire pour contrôler le flux de nos scripts est l'instruction I, qui commence par le mot clé I. I est suivie d'une instruction conditionnelle qui doit être vraie ou fausse. Pour l'instant, disons vrai, qui est ensuite suivi de deux points. Comme les deux points à la fin de notre déclaration de fonction, cela marque la fin de l'instruction, et en passant à la ligne suivante, elle est automatiquement indentée à un autre niveau Les lignes de code indentées qui suivent cette instruction if ne seront exécutées si la condition de l'instruction if est vraie Imprimons donc quelque chose comme si la condition était vraie, puis exécutons la scène en cours pour voir notre déclaration d'impression fonctionner. Si nous changeons vrai en faux, nous pouvons constater que la déclaration d'impression est ignorée cette fois Nous pouvons ajouter une autre ligne après le corps indenté de l'instruction if au même niveau d'indentation que l'instruction I en utilisant simplement le mot clé se suivi Cela crée un autre corps conditionnel qui ne sera exécuté que si la condition de l' instruction I d'origine n'est pas remplie. Dupliquons la déclaration d'impression et modifions-la pour qu'elle dise quelque chose de différent. La condition étant fausse, le bloc se a été exécuté à la place du bloc I. Et si nous changeons la condition en vrai, c'est l'inverse qui se produira. Cela n'est pas très utile si nous savons toujours que le résultat de l' énoncé conditionnel est vrai ou faux, mais nous pouvons le remplacer par une variable. Déclarons une variable booléenne, qui indique si la lumière est allumée ou non dans la pièce booléens sont classiquement nommés de telle manière qu'ils impliquent leur utilisation comme condition Dans ce cas, on suppose que la lumière est allumée est vraie ou fausse en fonction de son nom. Maintenant, notre instruction if peut définir sa condition comme étant de savoir si la valeur de notre variable est égale ou non à true. Lorsque nous comparons deux valeurs pour voir si elles sont égales, nous utilisons un double signe égal, appelé opérateur égal, qui est différent d'un signe égal simple tel nous l'avons utilisé auparavant comme opérateur d'affectation. Nous imprimerons ensuite soit je peux voir, soit je ne peux pas voir, selon que la lumière est allumée ou non, étant égale à vraie. Comme la valeur par défaut d'un booléen est false, nous pouvons voir le résultat comme je ne peux pas Mais si nous définissons la variable sur true, elle devient I can see. Puisque la variable elle-même est un booléen, vrai ou faux, nous pouvons supprimer complètement l' opération de comparaison et simplement utiliser le booléen comme condition et obtenir exactement le même condition et obtenir exactement le Nous pouvons inverser la valeur de n'importe quel booléen, ce qui signifie que s'il est vrai, il devient faux ou s'il est faux, il devient vrai en utilisant le mot-clé not Comme la fonction STR que nous avons utilisée dans la leçon précédente, cela ne change que la façon dont elle est utilisée dans le contexte local et ne modifie pas réellement la valeur stockée dans la variable. Donc, si ce n'est pas le cas, la lumière est allumée alors nous ne pouvons pas voir, sinon nous pouvons voir. Rien peut également être représenté par un point d'exclamation. Modifions la valeur des voyants allumés et exécutons-le à nouveau. Je rétablirai ensuite ces modifications comme elles étaient auparavant Nous pouvons rendre nos conditions beaucoup plus complexes en combinant plusieurs conditions l'aide d'opérateurs logiques. Créons une autre variable nommée Has dark vision. Cette variable implique que nous devrions être capables de voir même si le voyant n'est pas allumé. Nous pouvons donc ajouter à nos instructions if la condition que la lumière soit allumée ou que nous ayons une vision dans le noir. Et si l'une ou l'autre de ces conditions est vraie, alors nous pouvons voir. Ce n'est que si les deux conditions sont fausses que cela nous empêchera de voir ? Et si, au lieu d'avoir une vision sombre, nous portions des lunettes de vision nocturne, car elles ne nous permettent de voir que dans le noir mais pas dans la lumière En changeant le nom de la variable, la condition de notre instruction I doit changer. Puisque si les deux conditions sont vraies, nous ne devrions pas être en mesure de voir. Ce n'est que si les valeurs de ces deux conditions sont différentes on doit considérer que la condition à voir est remplie ? Nous pouvons utiliser l'opérateur non égal pour vérifier si les deux valeurs ne sont pas égales. Si vous êtes familiarisé avec les opérations logiques, cela est connu dans d'autres langages sous le nom de « or exclusif ». Maintenant, ce n'est que si la lumière est allumée ou si nous portons lunettes de vision nocturne, mais pas les deux, que nous pourrons voir Ensuite, considérons que notre personne hypothétique n'est peut-être pas humaine et ajoutons une variable pour le nombre de I qu'elle possède, qui doit être représentée par un entier Pour l'instant, nous allons lui donner une valeur de deux Is. En ignorant les autres variables, quelle serait la condition que nous définirions pour pouvoir voir en fonction de cette variable ? Si le nombre d'yeux que nous avons est supérieur à zéro, nous devrions être capables de voir. Nous pouvons également l'exprimer en utilisant un autre opérateur, supérieur ou égal à, et remplacer le côté droit par un. Ils doivent donc avoir des yeux supérieurs ou égaux à un. Il s'agit d' opérateurs de comparaison qui renvoient un résultat booléen en comparant la valeur des nombres situés à gauche et à droite Nous pouvons logiquement conclure qu'il devrait être impossible pour toute créature humaine ou autre d'avoir un nombre négatif d'yeux La valeur de notre variable ne doit être que nulle ou supérieure à zéro. Et la condition pour pouvoir voir se résume vraiment à ces deux options Avons-nous des yeux nuls ou non nuls ? Tout comme la variable booléenne peut être utilisée implicitement comme condition, un entier peut également être utilisé de cette manière, zéro étant considéré comme une fausse condition et tout élément autre que zéro étant La même logique est également appliquée aux nombres à virgule flottante. Nous pouvons déclarer une variable flottante , la nommer plage de vision et lui donner une valeur arbitraire de 7,8 mètres. Nous pouvons utiliser nos opérateurs de comparaison pour déterminer si ce nombre est supérieur ou égal à une certaine valeur, ou nous pouvons l'utiliser implicitement dans sa propre condition zéro étant considéré comme faux et tout le reste considéré comme vrai Qu'en est-il des cordes ? Changeons légèrement les choses et déclarons une variable de chaîne correspondant à ce que nous avons entendu et donnons-lui une valeur de bumps in the night Ensuite, nous pourrions logiquement l'utiliser comme une déclaration « if car si ce que j'ai entendu n'était pas une chaîne vide, nous pouvons alors dire « j'ai entendu quelque chose Sinon, je n'ai rien entendu. Et comme pour les autres types de variables, nous pouvons supprimer la comparaison et utiliser la variable elle-même comme condition. toutes les variables, Pour toutes les variables, leurs valeurs par défaut sont considérées comme fausses, et tout le reste est toujours considéré comme vrai lorsqu'il est utilisé comme condition. Si nous déclarons une variable sans type, appelons-la comme je veux, mais ne lui donnons pas de valeur, alors nous savons déjà que sa valeur par défaut sera nulle. Même sans type ni valeur, n'importe quelle variable peut être utilisée comme condition d'intimidation. Toute variable vide, c' est-à-dire que sa valeur est nulle, est considérée comme fausse. Si nous devions renseigner cette variable avec un objet, sa valeur en tant que condition serait considérée comme vraie Nous n'avons actuellement aucun autre objet avec lequel jouer, mais nous pouvons toujours nous en servir nous-mêmes. Définissons donc la valeur de ce que je recherche comme étant le mot clé self. Et cela se traduit par le fait de pouvoir voir. Dans la leçon suivante, nous utiliserons des boucles pour répéter plusieurs fois des lignes de code. Je te verrai dans la prochaine leçon. 5. 0-4 Pendant Loops et opérateurs: Bonjour, mes amis. Aujourd'hui, nous allons apprendre à répéter plusieurs fois des lignes de code avec des boucles en imaginant une femme tombée amoureuse pour la première fois tenant une fleur Écrivons donc un nouveau script et nommons-le fleur. Remplacez ensuite la définition des nœuds de base de la fonction prête. Notre dame imaginaire tient une fleur qui a un certain nombre de pétales, nous allons stocker dans une variable et restreindre son type à un entier. Donnez-lui ensuite la valeur d' un nombre arbitraire, disons cinq. Nous déclarerons également une autre variable nommée He Loves Me, sous forme de booléen, dont nous pensons qu'elle a pour valeur par défaut false Nous pouvons commencer notre script en imprimant une histoire sur la femme amoureuse tenant sa fleur Elle retire chaque pétale de la fleur un par un, disant soit il m'aime, soit il ne m'aime pas abord, nous devons réduire d'un le nombre de pétales sur la fleur. Nous allons donc commencer par la variable du nombre de pétales, puis utiliser l'opérateur d'assignation pour attribuer une nouvelle valeur à la variable. La valeur que nous voulons lui attribuer est le nombre qu'il possède déjà moins un. Nous voulons ensuite modifier la valeur de la variable booléenne. Il aime que je sois le contraire. Il m'aime donc, il n'est assigné à rien. Il m'aime, inversant la valeur du faux vrai ou vice versa Ensuite, nous pouvons imprimer les résultats. Il m'aime. Nous souhaiterons peut-être encapsuler cette partie entre guillemets, mais si nous essayons de mettre un guillemet dans notre chaîne, il marquera plutôt la fin de la chaîne Certains caractères spéciaux, tels que les guillemets, peuvent être créés à l'intérieur d'une chaîne à l'aide d'une barre oblique inverse Si nous écrivons un guillemet inversé, cela représente désormais un guillemet, non la fin de la chaîne Et nous pouvons en inclure une autre après la déclaration des Dames. Dupliquons cette ligne et changeons la déclaration comme suit  : « Il ne m'aime pas ». Un autre exemple de caractère spécial que nous pouvons écrire à l'aide de la barre oblique inverse est la barre oblique inverse Nous pouvons également combiner les deux lignes ci-dessus et les séparer par une barre oblique inverse N, qui représente une nouvelle Ils sont donc imprimés sur deux lignes de sortie à partir d'une seule instruction d'impression. Nous avons maintenant deux possibilités que nous voulons afficher en fonction de la valeur de notre variable booléenne Il semblerait donc que nous devrions les envelopper dans une déclaration if. S'il m'aime, alors imprime-le. S'il ne m'aime pas, alors imprime-le. Mais dans les cas où les instructions dépendent d'une seule variable booléenne pour apporter une modification mineure, il existe une méthode plus efficace Revenons donc au format d'origine. Notre déclaration sera qu'il m'aime, s'il m'aime, sinon il ne m'aime pas. Ce n'est pas la même chose qu' une instruction if malgré l'utilisation des mêmes mots clés, mais c'est ce qu'on appelle une opération ternaire Comme il ne crée pas nouveau bloc de code avec une indentation, il est en fait exécuté plus efficacement et il est recommandé utiliser dans des cas simples comme celui-ci Nous pouvons en fait réduire encore plus la taille de la variation en la remplaçant uniquement par point d' exclamation ou un espace suivi du mot « non », puis du point d'exclamation Cela fonctionne dans le cas s'il m'aime, mais si nous changeons la valeur en true par défaut, alors nous ne verrons rien dans l'autre cas. Tout comme les mathématiques, il existe un ordre spécifique d'opérations dans lequel nos scripts exécutent plusieurs opérations sur la même ligne. Étant donné que la chaîne append et le ternaire I sont tous deux des opérateurs, l'un doit être exécuté avant l'autre, et dans ce cas, il s' agira de la chaîne Et comme en mathématiques, les crochets sont toujours les premiers à être exécutés. Nous pouvons donc placer n'importe quelle opération entre crochets pour assurer qu'elle sera exécutée en premier dans l'ordre des opérations. Encadrant notre instruction ternaire entre crochets, elle s'exécutera désormais avant l'ajout de la chaîne et nous donnera le résultat attendu Nous avons donc maintenant notre bloc de code qui doit être répété tant que la fleur a encore des pétales. En utilisant le mot clé WW, un peu comme une instruction if, nous pouvons répéter un bloc de code indenté tant que la condition reste vraie La condition dans ce cas étant que le nombre de pétales sur la fleur ne soit pas nul. Quel que soit le nombre de pétales sur la fleur, il sera réduit d'un à chaque fois. Ensuite, après l'instruction print, le flux logique de ce script reviendra au début du WWLoop pour vérifier à nouveau la condition. Lorsque le nombre de pétales atteint zéro, la condition n'est plus remplie et la boucle interrompue et le script continue, s'il y en a un. Rédigons donc une courte conclusion à notre histoire en fonction des résultats. Elle se lève, les larmes aux yeux. Mais selon la valeur finale de He Loves Me, elle est heureuse ou triste, et nous imprimerons la phrase finale différente. cours de cette scène, nous pouvons voir notre histoire imprimée dans le panneau de sortie, et avec cinq pétales, la dame est heureuse. Si nous changeons le nombre de pétales à six, nous obtenons un résultat différent puisque la boucle s'est répétée six fois au lieu de cinq. Mais que se passera-t-il si nous réduisons le nombre de pétales de la fleur à zéro ? La boucle ne tourne pas du tout, et l'amour était voué à l'échec dès le début Je ne recommande pas de suivre cet exemple, mais regardez simplement ce qui se passe si nous donnons la fleur un nombre négatif de pétales. Bien que cela soit raisonnablement impossible, dans notre code, c'est très problématique Comme la condition de notre boucle murale ne sera jamais remplie, elle ne se brisera jamais et le script est piégé à l'intérieur de celle-ci, sans jamais se terminer. Il s'agit d'une boucle infinie doit être évitée à tout prix. Dans ce cas, nous pouvons empêcher la boucle infinie en modifiant notre condition pour qu'elle soit si le nombre de pétales est supérieur à zéro, car un nombre négatif interrompra tout de même la boucle. Nous pouvons utiliser un autre opérateur réduire le nombre de pétales comme raccourci. En éliminant le besoin d'écrire deux fois le nom de notre variable, nous pouvons effectuer des opérations mathématiques simples sur notre nombre de variables l'aide d'un opérateur d' affectation spécial. Dans ce cas, l'opérateur moins égal peut remplacer cette ligne de code nombre de pétales moins égal à un. Ces raccourcis existent pour toutes les opérations arithmétiques de base, plus égal, multiplie égal ou divise égal, et peuvent être utilisés avec n'importe quel nombre ou variable comme autre opérande Il existe également un autre opérateur pour l' arithmétique de base, l'opérateur de module, représenté par le signe du pourcentage Modulus effectue une opération de division, mais ne renvoie pas le quotient comme résultat comme le fait l'opérateur de division Il renvoie plutôt le reste de la division. Tout ce script, mis à part l'histoire racontée, ne fait que déterminer si le nombre de pétales sur la fleur est pair ou impair, mais il le fait de la manière la plus inefficace possible, en comptant à rebours chaque pétale Commentons donc l'ensemble de la boucle murale et utilisons plutôt le module pour accélérer le processus Sachant que tous les nombres pairs sont divisibles par deux, nous pouvons utiliser le module du nombre de pétales Le seul résultat possible le reste de cette division sera soit zéro si le nombre de pétales est pair, soit un si le nombre de pétales est impair. Notre script pourrait être simplifié comme si le nombre de pétales modulus deux est égal à un, alors la dame est heureuse Sinon, elle est triste. Puisque nous comprenons comment les entiers sont interprétés comme des conditions, nous n'avons même pas besoin d'effectuer l'opération de comparaison ici et nous pouvons simplement la raccourcir à I nombre de pétales module deux Le résultat de l'opération du module peut être affecté directement à la variable booléenne pour obtenir le même résultat sans avoir besoin d'une instruction if, et le zéro ou le un sera automatiquement converti en faux ou en vrai en Nous pourrions aller plus loin en supprimant la variable et en utilisant simplement l'opération du module directement dans l'instruction turny Dans la leçon suivante, nous allons découvrir les ensembles de variables associées. Je te verrai dans la prochaine leçon. 6. 0-5 tableaux et pour boucles: Bonjour, mes amis. Aujourd'hui, nous verrons comment organiser de grandes quantités de variables, en particulier lorsqu'elles contiennent des informations connexes. J'ai déjà créé un script nommé census et j'ai remplacé la définition des nœuds de base de la fonction ready Pour le scénario hypothétique présenté dans cette leçon, nous imaginons un agent de recensement qui doit enregistrer nombre de personnes vivant dans chaque maison située sur une seule route Nous pouvons déclarer une seule variable pour contenir toutes ces informations, nommons-la Main Street. Et le type de cette variable sera un tableau. Un tableau peut contenir une liste de variables de n'importe quel autre type. Dans ce cas, les variables que nous recherchons sont des nombres entiers, représentant le nombre de personnes vivant dans chaque maison Nous pouvons spécifier le type de contenu d' un tableau en utilisant des crochets après le tableau de noms de type et en plaçant le type du contenu entre crochets. Désormais, ce tableau ne peut contenir que des entiers comme contenu. Avant de pouvoir accéder au contenu d'un tableau, il doit avoir une taille, le nombre de variables qu'il contient. Contrairement aux autres variables, les tableaux sont plus complexes et ont leurs propres fonctions Nous pouvons accéder à ces fonctions en suivant le nom de la variable par un point, puis le nom de la fonction. Dans ce cas, la fonction de redimensionnement, qui définit le nombre d' adresses à l'intérieur de ce tableau, représente le nombre de maisons sur Main Street, soit six Notre ville imaginaire est un peu inhabituelle dans la mesure où les numéros des maisons sur Main Street commencent à zéro. Notre agent de recensement commence donc par la maison située au zéro de la rue Main et frappe à la porte pour demander au résident combien de personnes y vivent Nous pouvons stocker une valeur dans un tableau en commençant par son nom, puis en utilisant des crochets pour marquer l'adresse de l'entier spécifique, dans ce cas, l'adresse zéro, puis en utilisant l'opérateur d'affectation. Nous pouvons attribuer un entier à cette adresse. Supposons donc que cinq personnes vivent dans la maison numéro zéro de Main Street. Passant à la maison suivante sur rue principale, adresse numéro un, quelqu'un répond lorsque l'on frappe à la porte et dit au recenseur que deux personnes vivent dans cette maison. À la maison suivante, à l' adresse numéro deux, la maison est en construction et porte un panneau « à vendre », ce qui signifie qu'elle est clairement inoccupée, et notre agent de recensement enregistre le nombre de résidents comme zéro Au numéro 3 de la rue principale, personne n'ouvre la porte, malgré la présence d'une voiture dans l'allée et de signes d'occupation Quel est, selon nous le recenseur devant enregistrer le nombre de résidents ? On pourrait penser qu' il pourrait être nul. Mais comment faire la différence entre un nombre inconnu d'occupants et une maison inoccupée ? Si nous considérons que le nombre d'occupants d' une maison ne doit jamais être considéré comme un nombre négatif, nous pourrions utiliser le nombre négatif un pour indiquer que le nombre d'occupants de la maison est une valeur inconnue. Et au numéro 4 de Main Street, il n'y a, encore une fois, aucune réponse à la porte. Mais la maison semble également avoir été négligée, et personne n' y habite probablement depuis un certain temps. Nous pouvons supposer que le nombre d'occupants est égal à zéro , utiliser la même valeur négative pour un nombre inconnu d' occupants ou créer d'autres codes de valeur négatifs pour différentes situations, par exemple utiliser moins deux pour signifier probablement inoccupé mais non confirmé L'adresse numéro 5 sur Main Street n'a même pas de maison, mais c'est juste un terrain vacant. Encore une fois, cela peut être représenté par un zéro ou une autre valeur négative pour coder une sorte de réunion Imprimons les résultats du recensement et voyons à quoi ils ressemblent. Nous pouvons voir notre tableau représenté sous la forme d'une liste de nombres séparés par des virgules et encapsulés entre crochets Cela représente bien le nombre de personnes vivant dans chaque maison de Main Street. Mais que se passerait-il si nous voulions utiliser ces données pour connaître le nombre total d' occupants de toutes les maisons de Main Street ou en moyenne ? Si nous calculions la somme de tous ces nombres, les nombres inconnus représentés par des négatifs fausseraient les L'un des meilleurs avantages de l'utilisation de tableaux pour stocker informations connexes de cette manière est la facilité avec laquelle il est possible de les parcourir en boucle À l'aide du mot-clé quatre, nous écrivons ensuite le nom d' une nouvelle variable, qui représentera chaque élément individuel du tableau, suivie du mot-clé in, puis du nom du tableau. Comme pour les fonctions, si les instructions sont des boucles wa, sont suivies de deux points et d'un bloc de code en retrait qui seront répétés Ces lignes de code seront répétées une fois pour chacune de nos six maisons de Main Street, et nous pouvons nommer la variable house, car elle sera utilisée pour accéder à chaque maison individuelle à l'intérieur de la boucle. Supposons que nous voulions d'abord connaître le nombre moyen d'occupants qui vivent dans une maison occupée. Cela signifierait qu'il faudrait additionner tous les nombres positifs , puis les diviser par le nombre de maisons occupées. Nous aurons donc besoin de trois nouvelles variables, une pour le nombre total d'occupants, une autre pour le nombre de maisons occupées, toutes deux sous forme de nombres entiers, et un nombre à virgule flottante pour la moyenne Pour chaque maison de Main Street, nous pouvons vérifier si la maison est occupée, si le nombre enregistré dans le tableau à cette adresse maintenant enregistrée dans la variable house est supérieur à zéro. Si tel est le cas, le nombre total d' occupants des maisons occupées peut être augmenté par maison, et le nombre de maisons occupées peut être augmenté d'une unité Une fois que les six maisons de Main Street ont été inspectées, la boucle s'interrompt et nous avons nos deux nombres entiers. Nous pouvons donc calculer la moyenne en divisant le nombre total d'occupants par le nombre de maisons occupées. Imprimez ensuite les résultats. Il y a plus de maisons occupées et plus de maisons occupées sur Main Street, avec une moyenne d'occupants et d' occupants majorés. Mais si nous exécutons ce code, la moyenne est représentée par un entier, trois, ce qui, nous le savons, n'est pas correct, puisqu'il y a un total de sept occupants dans deux maisons occupées, la moyenne devrait être de 3,5. Cela s'est produit parce que nous avons effectué une opération de division avec deux entiers, et le résultat de l'opération sera également un entier, même si nous l'attribuons à une variable numérique à virgule flottante Godot fournit également un avertissement contre l'utilisation d'entiers dans les opérations de division Pour résoudre ce problème, nous pouvons changer nos variables entières en nombres à virgule flottante dans leurs déclarations, ou nous pouvons changer leur type localement avant d' effectuer la division. De la même manière que nous avons transformé entiers en chaînes avant de les ajouter, nous pouvons transformer un entier en nombre flottante avant d'effectuer une division Changer également le résultat de la division en un nombre à virgule flottante. La modification du type d'une variable cette manière s'appelle le casting. Nous transformons un entier en valeur flottante. Nous pouvons maintenant voir les résultats que nous attendions avec une moyenne de 3,5 occupants par maison occupée. un des avantages de GD Script, étant un langage à typage souple, est que nous n'avons pas besoin de spécifier les types de nos variables, y compris les types contenus dans un tableau Si nous autorisons notre tableau à contenir n'importe quel type de variable, nous pouvons modifier la façon dont notre agent du recensement enregistre les informations. Supposons que l'adresse zéro reste la même avec cinq occupants. Mais la première adresse a également fourni les noms des deux résidents qui y vivent. Au lieu d'enregistrer les occupants sous la forme d'un chiffre deux, nous pourrions enregistrer leurs noms dans une chaîne. adresse numéro un de Main Street est donc occupée par Jordan et Ashley Smith. La maison numéro deux était inoccupée, ce que nous pourrions représenter par un zéro Mais nous pouvons également envisager l'enregistrer sous forme de booléen et de lui attribuer la valeur false pour indiquer que la maison est en construction et ne peut pas avoir d' occupants Au numéro trois, personne n'était à la maison, mais il y a certainement des gens qui y vivent. Nous ne savons tout simplement pas combien. Nous pourrions également stocker cette valeur sous forme de booléen et lui attribuer la valeur true Au numéro quatre, il semble vraiment que personne n'y habite. Il se peut que nous voulions le marquer comme zéro occupant. À l'adresse numéro cinq, puisqu'il n'y a même pas de maison, nous pourrions envisager d'utiliser null comme valeur puisque null représente l'absence de toute valeur. Nous pouvons utiliser le mot clé null pour attribuer au tableau à l'adresse 5. Notre tableau imprimé a maintenant un aspect très différent, contenant des variables de tous types au lieu de simples entiers Et nous pouvons en tirer plus d'informations. Les tableaux peuvent même contenir d'autres tableaux comme contenu. Nous allons donc changer notre liste de noms d' une seule chaîne à un tableau de chaînes. Nous pouvons créer ce tableau en même temps qu'il est attribué à l'aide de crochets, puis le remplir d' une liste de chaînes séparées par des virgules comme contenu Donc, si nous voulions savoir combien de personnes vivent à la première adresse sur Main Street, nous pourrions l'imprimer sous la forme Mainstreet one point SIE Dans la leçon suivante, nous allons découvrir d'autres utilisations des tableaux pour créer des collections de données plus dynamiques Je te verrai dans la prochaine leçon. 7. 0-6 piles et fonctions: Bonjour, mes amis. Aujourd'hui, nous allons continuer à travailler avec les tableaux de différentes manières en mettant en place un jeu Old Made J'ai déjà créé un script nommé Old Made et j'ai remplacé la définition des nœuds de base de la fonction ready Pour jouer à l'ancienne, nous avons besoin d'un jeu de cartes, qui est un ensemble de variables que nous pouvons contenir dans un tableau. Comme le jeu Old Made ne se soucie pas vraiment de la couleur des cartes, nous pouvons ignorer cette information, et chaque élément du tableau doit uniquement contenir le rang des cartes de l'as au roi sous forme d'entier. Pour générer notre deck, nous pouvons utiliser une boucle à quatre boucles. Mais au lieu d' utiliser la boucle à quatre pour parcourir un tableau, elle peut simplement être utilisée pour compter le rang de nos cartes En commençant par quatre, nous pouvons déclarer une variable représentant le rang d'une carte, suivie du mot clé in, puis spécifier un nombre. Si nous considérions King comme un chiffre, ce serait le 13e rang. Pour l'instant, imprimons simplement le classement afin de voir ce qui se passe. Les quatre boucles commencent avec une valeur de rang nulle et comptent jusqu'à 12, répétant cette boucle et en imprimant l'instruction 13 fois. Pour des raisons de santé mentale, il peut être judicieux de considérer carte numéro deux est représentée par le rang deux, et donc As serait un et roi 13 Bien que démarrer une boucle à quatre à zéro soit très utile pour itérer dans des tableaux puisque leur premier numéro d'index est zéro, cela n'est pas très utile dans ce cas Nous pouvons changer la façon dont une boucle à quatre boucles compte en remplaçant le 13 par un appel de fonction, range. Les appels de fonction sont suivis de parenthèses contenant des arguments Les arguments de cette fonction sont les limites inférieure et supérieure de la plage. La limite inférieure sera incluse dans la fourchette, mais pas la limite supérieure. La plage 114 contiendra tous les nombres de 1 à 13, nous pouvons voir qu'ils sont imprimés dans la sortie Une autre façon d' ajouter des informations à un tableau au lieu d'utiliser les crochets et numéro d' index consiste à utiliser une fonction nommée append Cette fonction d'ajout accepte un argument de la valeur ajoutée au tableau Cela positionnera la valeur ajoutée à la fin du tableau, où qu'elle se trouve. Et comme il y a quatre cartes de chaque rang dans un jeu de cartes, une pour chaque couleur, nous devons répéter cette ligne de code quatre fois pour chaque rang. Nous pouvons le faire avec quatre autres boucles, commençant cette fois à zéro et en comptant jusqu'à quatre, mais sans inclure quatre. En imprimant le jeu, nous pouvons voir que notre tableau contient quatre cartes de chaque numéro de 1 à 13 pour un total de 52 cartes Mais pour jouer à l'ancienne, nous voulons supprimer trois des reines, ou dans ce cas, 12. Donc, dans notre boucle à quatre étapes qui consiste à parcourir les combinaisons de cartes, vérifions si le rang est 12 Et dans ce cas précis, nous voulons uniquement autoriser l'ajout du 112, en utilisant le mot clé break pour sortir instantanément de cette boucle. Break ne mettra fin qu'à la boucle la plus indentée dans laquelle il se trouve actuellement Nous allons donc mettre fin à la combinaison pour boucle, mais pas au rang pour boucle. Cela augmentera ensuite le rang à 13 et ajoutera quatre treizaines au deck Et en le testant, nous pouvons voir qu'il n'y en a que 112. La première chose qui se passe dans notre jeu est de mélanger le jeu de cartes, ce qui, dans le script GD, est une simple fonction intégrée de rayse Il suffit d'appeler cette fonction et nous pouvons voir que les cartes sont mélangées dans notre deck Nous aurons également besoin d' une autre variable, un tableau de mains de cartes pour représenter nos joueurs. Chaque main du tableau doit contenir plusieurs cartes Ce sont donc également des tableaux, que nous devrons initialiser avant de pouvoir les utiliser Ainsi, en comptant de zéro à quatre, mais sans compter quatre, nous pouvons ajouter une nouvelle main au tableau Notre aiguille commence par un tableau vide représenté par des crochets. Si nous imaginons notre jeu de cartes, le recto des cartes étant le côté marqué de la couleur et le verso vierge, nous pouvons également imaginer le jeu de cartes face cachée. L'avant du tableau est le bas du pont et l'arrière du tableau est le haut du pont. Le processus de distribution des cartes peut être effectué en parcourant notre jeu de cartes, mais il n'est pas du tout nécessaire de faire référence à des cartes spécifiques, car peu importe leur nature, il suffit que la carte soit prise du haut du jeu et remise à un joueur Donc, pour retirer une carte du haut du jeu, on peut appeler une autre fonction. Celui-ci s'appelle pop back. Il renvoie non seulement le dernier élément du tableau, mais le supprime également du tableau. Nous voulons ensuite ajouter cette carte à la main du joueur et nous allons commencer par le joueur 1, en supposant que le joueur zéro est le croupier. Tout comme nous pouvons utiliser la fonction pop back pour retirer une carte, nous pouvons également ajouter une carte avec pushback La carte que nous plaçons sur le dos de la main du joueur est la même que celle que nous lançons à l'arrière du jeu. Nous pouvons simplement mettre cet appel de fonction entre crochets et utiliser sa valeur de retour comme argument de la fonction push. L'utilisation du pushback est exactement la même que celle de l'ajout. La fonction d'ajout est un héritage de chaînes de caractères, car elles sont généralement stockées sous forme de tableaux de caractères, tandis que les commandes push et pop proviennent de l'utilisation de piles ou d'indices, comme nous le faisons Pour distribuer notre prochaine carte, nous devrons augmenter la main qui est distribuée Stockons cela dans une variable sous forme d'entier et donnons-lui une valeur initiale de un. En remplaçant celle de notre index par notre variable, nous devrons l'incrémenter d' une après chaque carte distribuée Mais cela ne comptera évidemment que jusqu'à 51, et il n'y a pas tellement de mains. Nous aurons donc besoin que ce nombre revienne à zéro chaque fois qu'il atteindra quatre. Cela peut être accompli à l'aide notre opérateur de module fiduciaire, en assignant à hand un module égal à quatre Mais si nous voulons que notre code fonctionne avec n'importe quel nombre de joueurs, il serait préférable de remplacer quatre par la taille de notre tableau de mains. Pour voir où nous en sommes jusqu'ici, imprimons nos mains en parcourant le tableau des mains et en imprimant chacune Imprimez ensuite le deck. Nous pouvons voir nos quatre tableaux et le deck est vide. Nous pouvons même modifier le nombre de joueurs et les cartes seront distribuées au bon nombre de mains. Notre fonction prête à l'emploi devient assez importante. Nous pouvons mieux organiser notre code en déclarant nos propres fonctions. En séparant notre logique en petits morceaux, nous avons une section qui crée notre jeu de cartes initial, une qui crée les mains du joueur et une autre qui distribue les cartes En utilisant le mot clé funk, nous pouvons donner à chacun de ces blocs de code un nom suivi de parenthèses et Initialisez le deck, initialisez les mains et distribuez. La fonction prête peut alors appeler chacune de ces fonctions en séquence. Nos fonctions peuvent également accepter des arguments, tels que le nombre de mains que nous voulons avoir. Passons quatre comme argument. Pour écrire notre fonction de manière à accepter l'argument, nous devons ajouter un paramètre correspondant entre parenthèses dans la déclaration de la fonction Tout comme la déclaration d'une variable, elle a un nom et éventuellement un type. Puisque nous l'utilisons pour redimensionner un tableau, il est conseillé de le limiter à un entier Nous pouvons alors utiliser le paramètre à l'intérieur la fonction de la même manière que nous utiliserions n'importe quelle autre variable. La dernière chose à faire pour commencer à jouer serait de retirer toutes les paires de la main de chaque joueur. Ainsi, en parcourant chaque main du tableau de mains, nous pouvons appeler une autre fonction pour retirer les paires de cette main, en passant la main en argument donnant une définition à cette fonction, nous pouvons alors accepter une main comme paramètre de tableau. Nous devrons itérer dans la main avec une variable. Appelons ça la carte 1. Mais nous pouvons nous arrêter avant de passer à la dernière carte. Nous ne passerons donc que de zéro à la taille de la main moins un. Nous pouvons ensuite itérer une deuxième fois la même manière, mais cette fois, en par la carte une après autre et en allant jusqu'à la fin de la taille de la main À l'intérieur de ces 24 boucles, cartes 1 et 2 contiennent désormais chaque paire de cartes unique de notre main Nous pouvons donc facilement comparer les deux cartes pour voir si elles correspondent. S'ils le sont, ils peuvent être retirés de la main, en commençant par la deuxième carte. Si nous retirions d'abord la première carte, l'index de la deuxième carte changerait en fait, puisque toutes les cartes se déplaceraient d'une position. Si nous trouvons une correspondance, nous ne voulons pas continuer cette boucle ni l'une ni l'autre, mais nous voulons recommencer tout le processus. Une façon simple de le faire serait d'utiliser une boucle while, une variable booléenne indiquant si nous avons trouvé ou non une paire avec une valeur par défaut vraie Lorsqu'une paire a été trouvée, nous pouvons immédiatement la définir sur false. Cela nous permet d' entrer dans la boucle mais ne pas rester ici à moins qu' une paire ne soit trouvée. Dans d'autres langues, vous pouvez le faire avec une boucle do Wile à la place Si nous trouvons une paire, nous pouvons définir la variable sur true, puis également sortir des deux boucles en réinitialisant la boucle while Si les quatre boucles terminent sans trouver de paire correspondante, paire trouvée sera fausse et la boucle while sera interrompue. Nous pouvons exécuter notre simulation à plusieurs reprises et voir qu' aucune des mains de nos joueurs contiendra jamais de paires identiques, et les joueurs sont prêts à commencer à jouer à Old Maid Dans la leçon suivante, nous utiliserons une autre forme de contrôle de flux. Je te verrai dans la prochaine leçon. 8. 0-7 Match et retour: Bonjour, mes amis. Aujourd'hui, nous allons utiliser une autre forme de contrôle de flux pour simplifier les conditions complexes. J'ai déjà créé un script nommé months et j'ai remplacé la définition des nœuds de base de la fonction Ready Commençons par déclarer une variable contiendra le mois en cours et définissons-la janvier et une deuxième variable pour contenir le nombre de jours du mois, comme janvier et une deuxième variable pour contenir le nombre de jours du mois, qui sera laissé à zéro par défaut. Nous pouvons imprimer une phrase simple indiquant que le nombre de jours en janvier est de 31. Mais d'abord, nous voulons renseigner notre variable avec le nombre de jours en fonction de la valeur du mois Écrivons donc une fonction capable de faire exactement cela. Attribuez le nombre de jours du mois à renvoyer à partir d'une fonction que nous allons écrire, qui acceptera le mois comme argument. Pour donner une définition à cette fonction, acceptant le mois comme paramètre de type chaîne, elle a également besoin d'une information supplémentaire, un type de retour. Le type de valeur renvoyé par une fonction est défini après les parenthèses avec un tiret et un trait d'union plus grand dans une flèche, suivi du nom du Dans ce cas, il s'agit d'un entier représentant le nombre de jours du mois. Si nous ne spécifiez aucun type de retour, le type de retour de toute fonction que nous écrivons est nul par défaut. Dans notre fonction, nous devons renvoyer un entier, ce qui signifie que nous devons déclarer un entier en haut de celui-ci, et il devra contenir le nombre de jours du mois. Ensuite, au bas de la fonction, nous retournerons la valeur contenue dans cette variable. Entre ces deux lignes, nous devons renseigner notre variable avec le nombre de jours correct en fonction du mois Si le mois est janvier, le nombre de jours est de 31. Nous avons appris précédemment que nous pouvons proposer une alternative avec le mot clé se, mais cela ne nous fournit deux options sur les 12 dont nous avons besoin. Nous pouvons utiliser un autre mot clé, if, abrégé de se if pour fournir une autre condition qui sera vérifiée si la condition d'origine était fausse. Sinon, si le mois est février, le nombre de jours est de 28. Et nous pouvons le répéter autant de fois que nécessaire, en argumentant toutes les possibilités. Mais bon nombre de ces options ont le même résultat, soit 30 jours, soit 31 jours. Nous pourrions améliorer considérablement l'efficacité de cette instruction if en combinant le résultat le plus courant, 31 jours par défaut, et en les remplaçant tous un seul mot clé else à la fin Donc, si le mois n'est pas février ou un mois de 30 jours, le nombre de jours doit être de 31. Tous les cas aboutissant à un délai de 30 jours peuvent également être combinés en une seule déclaration à l'aide de l'opérateur or. Si le mois est septembre ou si le mois est avril ou si le mois est juin, ou si le mois est novembre, le nombre de jours est de 30. Mais la déclaration est assez longue, avec plus de cas, elle risque de disparaître de l'écran. Pour des déclarations simples au cas par cas comme celle-ci, il existe un mot clé plus propre et plus facile à utiliser que l' instruction I appelé match. La correspondance est suivie du nom d'une variable, deux points puis d'un bloc de code indenté. À l'intérieur d'un bloc de correspondance, nous pouvons spécifier un nombre quelconque de cas spécifiques pour la valeur de la variable. Commençons par le mois de février. Le cas est également suivi deux points et d'un autre bloc de code en retrait. Ce code ne sera exécuté si la valeur du mois est février. Nous pouvons regrouper les cas dans une liste séparée par des virgules. Notre condition relative aux déclarations I peut donc être réduite à une liste de quatre mois seulement. Si la valeur du mois est septembre, avril, juin ou novembre, le nombre de jours sera défini sur 30, et notre bloc peut être remplacé par un caractère générique représenté par un trait de soulignement, en fixant le nombre de jours à 31 si la valeur du mois est une fixant le nombre de jours à 31 si autre valeur non spécifiée ci-dessus Cela revient à utiliser la valeur par défaut dans d'autres langues. Chacun de ces blocs de code est appelé branche. Et dans le script GD, une instruction match n'exécutera que la branche supérieure dont la condition est remplie Dans d'autres langages, cela ressemble à une instruction switch, mais diffère en ce sens que les instructions switch peuvent exécuter plusieurs branches si plusieurs conditions sont remplies. En raison de cette restriction, il n'est pas nécessaire d'inclure des pauses dans les branches de match. Si nous voulions imprimer le nombre de jours de chaque mois, nous voudrions probablement utiliser une boucle, mais nous ne pouvons pas simplement compter ou incrémenter une chaîne comme janvier pour devenir février d'une manière Il est donc courant dans le code, lors représentation d'éléments qui existent dans un ordre séquentiel, de les placer dans une liste numérotée appelée énumération Une énumération dans un script GD n' est qu'un groupe de constantes connexes Nous pouvons avoir une constante pour janvier avec une valeur de un, une autre pour février avec une valeur de deux, etc. Mais en utilisant le mot clé Enum, nous pouvons nommer le groupe de constantes, nommons-le mois suivi d'accolades À l'intérieur des accolades, nous pouvons regrouper les constantes et un numéro leur sera attribué automatiquement en fonction de leur position dans cette liste Tout ce qui se trouve entre accolades n'a pas besoin de rester sur une seule ligne et peut être décomposé dans format que vous préférez pour le rendre plus lisible L'indentation n'a pas d'importance ici, mais généralement, lorsque vous écrivez quelque chose entre accolades, la plupart des codeurs mettent en retrait le contenu, ce qui ressemble à ce qui ressemble Bien que je préfère que les bretelles soient alignées verticalement, nombreux codeurs préfèrent placer l'orthèse d'ouverture sur la ligne de déclaration Tout comme Constance, les entrées d'énumération sont classiquement nommées en majuscules en forme de serpent Maintenant que nous avons une énumération, le mois peut être limité au type de cette énumération Nous pouvons également lui attribuer une valeur issue de l'énumération, commençant par son nom, suivi d'un point, puis de l'entrée dans la liste Le mois ajouté à la chaîne de sortie n'est plus une chaîne en soi et doit être converti en chaîne avant de pouvoir être ajouté L'argument transmis au nombre de jours n'est plus une chaîne et est désormais un mois, et nous pouvons modifier notre fonction pour accepter également un mois en tant que paramètre. Comme le mois est désormais un mois, et non une chaîne, nous devons modifier nos conditions pour qu'elles correspondent en utilisant le nom de l'énumération suivi d'un point, puis les entrées de la liste Mais lorsque nous imprimons les résultats, nous constatons qu'au lieu de janvier, notre mois est écrit sous la forme du chiffre zéro. Bien que le type de notre variable soit un mois, qui est une énumération, la valeur réelle est traitée comme un entier, sa position dans l'énumération Comme janvier est la première entrée, sa valeur sous forme d'entier est zéro. Il y en aurait un en février, et cetera. Cela nous permet de modifier la valeur du mois à l'aide d'une simple arithmétique, sorte que janvier plus un devient février Si nous enroulons ce code dans une boucle qui se répète 12 fois, nous pouvons facilement itérer pendant les 12 mois Mais qu'en est-il de l'écriture du nom du mois sous forme de chaîne ? Nous pourrions le faire de différentes manières. Notre type d'énumération possède une propriété nommée keys, qui correspond à toutes nos entrées sous forme de tableau de chaînes Si nous indexons ce tableau à l'aide de notre variable entière, il nous donne le nom de l'entrée sous forme de chaîne correspondant à ce nombre. Mais conformément à la convention de dénomination Upper Snake Case, il se peut que nous ne souhaitions pas imprimer le nom de cette façon. Nous pourrions plutôt renommer toutes nos clés d' énumération en cas de Pascal, ou nous pourrions déclarer une constante contenant le tableau de chaînes, contenant tous les noms de nos mois dans un format plus présentable Utilisez ensuite le mois comme index dans ce tableau. Une autre chose que nous pouvons faire avec les énumérations est définir manuellement les valeurs des entrées à l'aide de l'opérateur d' affectation Disons que nous voulons que le mois de janvier soit un au lieu de zéro. Les autres entrées mettront automatiquement à jour leurs valeurs pour passer d'une valeur à une. Le mois de février est donc désormais de deux Mais cela ne correspond plus aux indices constants du tableau. Donc, si nous voulions l'utiliser pour écrire le nom des mois, nous devrions soit ajouter une entrée vide pour l'index zéro, soit en soustraire une du mois tel qu'elle est utilisée pour indexer le tableau Dans la leçon suivante, nous en apprendrons davantage sur la façon dont le moteur utilise et exécute nos scripts Je te verrai dans la prochaine leçon. 9. 0-8 Arbre de scène et héritage: Bonjour, mes amis. Aujourd'hui, nous allons découvrir comment le moteur utilise l' arborescence des scènes pour exécuter nos scripts. Je n'ai pas encore attaché de script au nœud racine de l'arbre des scènes, mais nous allons plutôt commencer cette leçon en ajoutant d'autres nœuds. En cliquant avec le bouton droit sur le nœud racine, puis en sélectionnant Ajouter un nœud enfant, toujours un nœud normal, nous pouvons le renommer en président et prétendre que notre arbre de scènes est la structure d'une entreprise Le nœud président est indenté car il est un enfant du nœud racine de la scène Lorsqu'un nœud est sélectionné, nous pouvons également utiliser le raccourci Control A ou Command A pour ajouter un autre nœud enfant. Appelons celui-ci directeur des opérations, et il est mis en retrait un autre niveau parce qu'il s'agit d'un enfant du président Attachons maintenant un nouveau script au nœud président et nommons-le employé. remplaçant la définition des nœuds de base de la fonction ready, nous pouvons simplement imprimer le nom de ce nœud et ajouter est prêt Ce script peut être attaché à plusieurs nœuds. Attachons donc le même script au nœud du gestionnaire des opérations en le faisant glisser de l'onglet du système de fichiers vers l'arborescence de la scène Exécutez ensuite la scène pour voir ce qui se passe. Nous pouvons voir que le directeur des opérations est prêt, puis que le président est prêt. Les deux nœuds auxquels le script est attaché exécutent le script, et comme ils ont des noms différents, le résultat était différent. Nous pouvons également constater que le directeur des opérations était prêt avant que le président ne soit prêt. Pour comprendre pourquoi nous devrons ajouter des employés. Le directeur des opérations supervisera un certain nombre d'opérateurs. Je vais ajouter un autre nœud enfant au gestionnaire des opérations et le nommer opérateur un. Joignez ensuite le script de l'employé. Nous pouvons cliquer avec le bouton droit sur n'importe quel nœud sauf le nœud racine et sélectionner Dupliquer pour en créer une copie. Le nom des doublons inclura automatiquement un nombre croissant, sorte que nous pouvons avoir les opérateurs deux, trois et quatre, Étant donné qu'un script était attaché au nœud que nous avons dupliqué, le même script est également attaché aux copies créées Comme les opérateurs ont le même niveau d'indentation et sont tous des enfants du directeur des opérations, ils sont appelés frères et sœurs, et les frères et sœurs ne sont pas autorisés à porter le même nom Notre entreprise doit avoir plus d'un département, dupliquons donc l' ensemble du département des opérations en dupliquant le responsable des opérations Tous les nœuds enfants sont également dupliqués. Comme les opérateurs ne sont pas des frères et sœurs directs, ils sont autorisés à conserver leur nom d'origine. Renommons le responsable en directeur du marketing, et il n'y aura que deux spécialistes du marketing dans leur équipe Les nœuds parents peuvent également être réduits pour masquer leurs enfants ou étendus pour les afficher. Tous les employés de cette entreprise ont le même script d'employé attaché à eux. Exécutons donc la scène pour avoir une meilleure idée de l'ordre dans lequel les scripts seront exécutés. Nous pouvons voir que le premier opérateur est le premier à être prêt, suivi de chaque opérateur dans l'ordre, et enfin, du responsable des opérations. Il en va de même pour le service marketing. Enfin, le président de l'entreprise est le dernier à être prêt. Comment Gadot décide-t-il de cet ordre d'exécution ? Le moteur démarre en haut de l'arborescence des scènes et descend, mais il considère qu'aucun nœud n'est prêt tant que tous ses enfants ne sont pas prêts. Le président n'est donc pas prêt parce que le directeur des opérations n'est pas prêt. Le directeur des opérations n'est pas prêt car les opérateurs ne le sont pas. Les opérateurs sont prêts dans l'ordre, puisqu'ils n'ont pas d'enfants. Une fois que tous les opérateurs sont prêts, le responsable des opérations est prêt. Mais le président n'est toujours pas prêt parce qu'il a un autre enfant qui n'est pas prêt. Le directeur du marketing n'était pas prêt avant que tous les spécialistes du marketing ne soient prêts, et finalement, le président est le dernier à être prêt Comme aucun script n'est attaché au nœud racine, sa fonction prête est celle d' un nœud par défaut, qui est vide. Outre le mode prêt, il existe d'autres fonctions du nœud que nous pouvons remplacer pour être exécutées ultérieurement une fois qu'un nœud est prêt Le plus courant est le processus, également précédé d' un trait de soulignement Le moteur fera de son mieux pour exécuter la fonction de traitement de chaque nœud de l'arborescence des scènes 60 fois par seconde en utilisant la fréquence d'images par défaut du projet. Le processus utilise donc un paramètre nommé Delta, qui est un nombre à virgule flottante représentant le nombre de secondes écoulées depuis la trame précédente. Donc, la plupart du temps, ce sera un soixantième, mais pas toujours. Nous n'avons pas besoin d'utiliser ce paramètre pour quoi que ce soit aujourd'hui Nous pouvons donc commencer le nom de ce paramètre par un trait de soulignement Gudo sait donc que nous n'avons pas besoin de l'utiliser et que nous ne devrions pas nous en soucier Mais pour annuler la fonction de processus, elle doit avoir le même nombre et le même type de paramètres Demandons à nos employés de travailler sur chaque image en imprimant une déclaration indiquant que leur nom en annexe fonctionne Dans cette scène, nous constatons que tous nos employés travaillent d'arrache-pied rédigent leurs relevés imprimés 60 fois par seconde. Ce n'est pas la même chose qu'une boucle infinie, car le travail est réellement effectué comme prévu et rien n'est cassé. Faisons en sorte que cela soit un peu plus facile à comprendre en n' autorisant chaque employé à effectuer qu'une seule unité de travail en utilisant une variable Bolan ayant effectué un travail avec une valeur par défaut fausse Dans la fonction de processus, si l'employé n'a effectué aucun travail, il le fera et remplacera la valeur par true. Un soixantième de seconde plus tard, comme la variable est vraie, ils ne fonctionneront plus. Mais si nous déclarons cette variable dans la fonction de processus, elle n'existera que dans la fonction de processus et uniquement pour une seule itération de celle-ci image suivante, lorsque la fonction de processus est exécutée pour la deuxième fois, la variable est déclarée à nouveau et sa valeur par défaut est toujours false Cela n'aura donc aucun effet. Pour que notre variable persiste, elle doit exister en dehors du contexte de la fonction de processus. Nous allons donc le déclarer en dehors de la fonction sans aucune indentation Les variables déclarées ici sont accessibles n'importe où dans l'ensemble du script. Ce concept, appelé scope, est l'une des principales raisons pour lesquelles nous utilisons l' indentation dans nos scripts Nous pouvons donc voir quelles variables existent dans quelle portée. Maintenant, nous pouvons voir chacun de nos employés déclarer qu'il est prêt à travailler. Ensuite, une fois que tout le monde est prêt, chacun effectue une unité de travail, mais maintenant dans un ordre différent. L'ordre dans lequel les nœuds et l'arbre de scène exécutent leurs fonctions de processus suit l'ordre exact de l' arbre de scène de haut en bas. Les parents n'ont pas besoin d'attendre leurs enfants grâce à la fonction Ready. Il se peut que nous souhaitions que tous les employés de notre entreprise soient similaires, mais pas exactement identiques. Le travail d'un manager n'est pas vraiment le même que celui d'un travailleur. Nous pouvons utiliser l'héritage pour créer différents comportements pour des objets similaires. De la même manière, nous écrivons des scripts qui étendent les nœuds, mais en modifiant la façon dont ils sont préparés et traités. abord, nous devons donner à ce script un nom que nous pouvons utiliser comme référence, en utilisant le nom de classe du mot-clé, suivi d'un nom décrivant le comportement du script, généralement le même que le nom du script, mais écrit en majuscules en Pascal. Maintenant que le moteur sait qu'il s' agit d'un employé, créons un nouveau script et nommons celui-ci manager. Mais au lieu d' hériter du nœud, nous pouvons cette fois hériter de Étant donné que notre script de responsable étend le nombre d'employés, tout ce qui est écrit dans le script d'employé s'applique toujours à celui-ci, mais nous pouvons en ajouter d'autres ou apporter des modifications. Un manager est toujours un employé, mais sa façon de travailler est différente. Nous devons remplacer le script attaché à nos nœuds de gestionnaire par le nouveau script de gestionnaire. Oublions la définition de la fonction prête donnée par l'employé définition de la fonction prête donnée par l' Ainsi, lorsqu'un responsable est prêt, ne se contente pas de dire qu'il est prêt, mais qu'il dit que l'ensemble de son département est prêt. Pour que nos deux responsables puissent afficher le nom de leur département, ils auront besoin d'une variable contenant le nom de leur département sous forme de chaîne. Mais comment pouvons-nous renseigner cette variable pour qu'elle contienne des valeurs différentes pour les différents départements ? Si nous procédons à notre déclaration de variable avec la balise lors de l'exportation, cette variable deviendra accessible par d'autres parties du moteur Gadot, à savoir le panneau d'inspection Pour qu'une variable soit exportée, elle doit être déclarée au niveau de la portée du script. En sélectionnant le responsable des opérations et le scénario, il y a maintenant un champ dans le panneau de l'inspecteur où nous pouvons attribuer une valeur de chaîne à la variable du département Ainsi, le responsable des opérations et le responsable marketing peuvent chacun avoir leur propre valeur pour cette variable que nous pouvons facilement contrôler. cours de la scène, nous pouvons constater que les nœuds auxquels attaché le script du responsable déclarent désormais que leur service est prêt, tandis que les autres employés utilisent tous la définition précédente dans le script de l'employé. La fonction de processus dans le script d' employé est également héritée par les responsables et est exécutée de la même manière qu'auparavant. Nous allons donc modifier la fonction de processus de notre responsable. Les managers diront quelque chose de différent. Name plus permet aux employés de faire leur travail. La variable has done work du script de l'employé a également été héritée et n' pas besoin d'être déclarée ici pour être utilisée. En fait, nous ne pouvons pas déclarer une variable portant ce nom car cela provoquerait un conflit avec la variable héritée du même nom. Reprenons les choses en main et voyons comment nos managers font désormais leur travail différemment des autres employés. Dans la leçon suivante, nous en apprendrons davantage sur l'utilisation des nœuds dans l'arbre des scènes et sur les principes de conception orientée objet. Je te verrai dans la prochaine leçon. 10. 0-9 Abstraction et encapsulation: Bonjour, mes amis. Aujourd'hui, nous allons découvrir comment écrire des classes plus faciles à utiliser et à comprendre. Imaginer une voiture comme cadre de référence. Créons deux nœuds dans notre scène, un conducteur et une voiture en tant qu'enfant du conducteur. Attachez ensuite un nouveau script à chaque script portant le même nom. Les voitures sont des machines très complexes, et la plupart des personnes qui les conduisent n' ont aucune idée de leur fonctionnement réel. Ils ne savent que conduire leur voiture. Commençons par le script car et donnons-lui un nom de classe de voiture, puis ajoutons une variable pour l'année de la voiture sous forme d'entier. Un autre pour la marque de la voiture sous forme ficelle et un autre pour le modèle également sous forme de ficelle. exportant tout cela, je vais configurer ma voiture pour qu'elle soit une Honda Civic 2007. Lorsque vous créez une nouvelle classe, veillez à enregistrer le script avant d'essayer de l'utiliser. Dans le script du conducteur, le conducteur aura besoin d'une référence à la voiture, que nous pouvons enregistrer dans une variable de type voiture. Les nœuds peuvent accéder à d'autres nœuds de l'arborescence des scènes, le plus souvent à leurs enfants en utilisant une autre balise similaire à export appelée « ready ». En utilisant le tag on ready, nous pouvons attribuer la valeur de la variable une fois que le nœud est prêt, ce qui signifie que tous ses enfants sont également prêts, mais avant d'appeler la fonction ready de ce nœud. Nous pouvons l'attribuer à la valeur de retour d' un nœud G intégré à la fonction, qui accepte le chemin d'un nœud en tant que paramètre. Si nous indiquons le nom du nœud enfant entre guillemets, nous avons désormais une référence au nœud enfant stockée dans une variable, et nous pouvons accéder à ses propriétés et fonctions, y compris celles du script joint. Outre la définition de la fonction prête, nous pouvons accéder au nœud de la voiture et en imprimer l'année, la marque et le modèle La fonction ready est exécutée après les balises on ready. Un raccourci existe pour la fonction get node afin de faciliter cette opération, le signe dollar, suivi du même chemin de nœud. Revenons au script car et ajoutons une autre variable. Celui-ci spécifie si le moteur fonctionne ou non en tant que booléen En tant que conducteur, nous savons si le moteur tourne et nous pouvons décider si le moteur tourne ou non, car nous pouvons choisir de démarrer ou d' arrêter le moteur à l'aide de la clé. Nous considérerions donc cette variable comme publique. Une autre propriété de notre voiture pourrait être le nombre de cylindres dans le moteur sous forme d'entier, et je vais lui attribuer une valeur de quatre. C'est quelque chose que le conducteur n'a pas besoin de savoir, qu' ne peut pas facilement accéder et il ne devrait jamais être autorisé à modifier. Ainsi, contrairement à la variable publique, celle-ci serait considérée comme privée, et nous pouvons la marquer comme privée en faisant suivre son nom d'un trait de soulignement Dans le script du pilote, nous pouvons régler la valeur du moteur sur true en mettant la clé sur le contact d'allumage et en la tournant. Mais d'abord, il faut appuyer sur la pédale de frein. Utilisons une fonction pour régler la pression appliquée sur la pédale de frein, dont nous supposerons qu'elle peut atteindre un maximum de 20 kilogrammes. Donc, pour démarrer notre voiture, nous devrions probablement régler la pression de freinage à environ 10 kilogrammes. De retour dans le script de la voiture, nous devrons définir cette fonction qui permet de régler la pression de freinage. Comme le moteur fonctionne sur une variable, cela s'appellerait une fonction publique, puisqu'elle est utilisée par un autre script. Cette fonction accepte un nombre à virgule flottante comme paramètre représentant la pression appliquée à la pédale. Mais que fait réellement la voiture lorsque nous exerçons une pression sur la pédale de frein ? Du point de vue du conducteur, celui-ci choisit d' appliquer une certaine pression sur la pédale sans jamais connaître la position exacte. Du point de vue de la voiture, la position de la pédale qui est mesurée et utilisée pour arrêter la voiture. La voiture utilise la position de la pédale de frein pour ajuster la pression appliquée aux étriers qui maintiennent les plaquettes de frein contre les roues de la voiture, sans parler de la complexité des freins antiblocage ou d'autres systèmes Donc, si nous programmions réellement une vraie voiture, nous devrions écrire ici plusieurs fonctions complexes qui convertissent la simple action du conducteur qui applique une pression sur la pédale de frein à la mécanique complexe de compression des étriers Cela fait partie des fonctions internes de la voiture et non de tout ce qui est contrôlé ou accessible au conducteur par un autre moyen que l' autre moyen que application d'une pression sur la pédale de frein. Nous considérons donc qu'il s'agit de fonctions privées, puisqu'elles ne sont destinées qu'à être utilisées par la voiture elle-même. Et nous pouvons marquer nos réceptions privées en faisant suivre leur nom d'un trait de soulignement Notez que c'est la même chose que les fonctions de processus et de préparation. La façon dont GDScript utilise des variables et des fonctions privées ressemble davantage à la façon dont les autres langages utilisent des variables protégées, dans la mesure où elles sont accessibles aux héritiers GD Script n' applique pas réellement ces règles de confidentialité Cependant, GD Script n' applique pas réellement ces règles de confidentialité et les scripts peuvent toujours accéder à des membres privés Ces conventions existent uniquement pour faciliter une meilleure structure et une meilleure conception des classes. Une autre façon d'utiliser les commentaires dans GD Script consiste à créer des régions de nos scripts associées, en utilisant le mot clé region suivi du nom de la région Nous pouvons terminer une région à l'aide du mot clé et de la région. Créons donc une région publique et une région privée dans notre script automobile, séparant ce qui devrait être accessible au conducteur de ce qui ne le devrait pas. Pour simplifier les choses, supposons que le conducteur puisse uniquement démarrer ou arrêter le moteur, exercer une pression sur l'accélérateur, appliquer une pression sur la pédale de frein ou tourner le volant Ce qui se passe réellement dans le cadre de chacune de ces fonctions publiques, c'est la mécanique interne de la voiture elle-même. Le conducteur n'a pas besoin de savoir comment tout cela fonctionne pour faire fonctionner le véhicule. Par exemple, lorsque vous appuyez sur la manette des gaz, des la voiture ouvre une soupape d'admission d'air sur le moteur, laissant entrer plus d'air et d'oxygène dans le moteur La voiture doit donc utiliser un capteur pour mesurer le débit d' air et la quantité d' oxygène qui s'écoule actuellement dans le moteur Utilisez-le ensuite pour ajuster la quantité de carburant injectée dans les cylindres du moteur. Toutes ces fonctions sont privées, car nous n'avons pas besoin de savoir à quoi elles servent réellement pour conduire la voiture. façon dont notre voiture se déplace dépend de la fonction du processus, et nous aurons besoin d'une autre variable privée nommée phase pour représenter dans laquelle des quatre phases se trouve actuellement chaque cylindre. Dans la fonction de traitement de la voiture, si le moteur tourne, nous pouvons itérer dans chacun des cylindres du moteur En additionnant le cylindre et la phase, puis le module quatre, nous obtenons une phase différente pour chaque cylindre faisant correspondre ce nombre, nous pouvons indiquer à chaque cylindre d' effectuer une phase différente, la course d'admission, course de compression, la course de combustion ou la course d'échappement, chacun acceptant le cylindre comme argument. Augmentez ensuite la phase et revenez à zéro lorsqu'elle atteint quatre. Chacune de ces fonctions peut ensuite contrôler les soupapes d'admission, soupapes d'échappement, les injecteurs de carburant et les bougies d'allumage de chaque cylindre pour faire fonctionner le moteur La force produite par les coups de combustion de chaque cylindre ferait alors avancer la voiture pendant que les plaquettes de frein essayaient de l'arrêter et que la position du volant changeait de direction. La position de la voiture serait alors modifiée en fonction de la direction, la vitesse et du temps Delta. Ne vous inquiétez pas si rien de tout cela n'a de sens pour vous car c'est précisément le but de cette leçon. Tu n'as pas besoin de le comprendre. Comme tout cela se trouve dans la zone privée du script, le conducteur n'a pas besoin de savoir comment tout cela fonctionne pour conduire la voiture. leur suffit de savoir comment utiliser la zone publique du script. La séparation du public et du privé impose deux principes importants de la programmation orientée objet encapsulation est le domaine public, qui donne accès à des variables ou fonctions publiques faciles à utiliser et simples à comprendre, tandis que l'abstraction est le domaine privé, masquant les détails de systèmes ou de mécanismes complexes qui n'ont pas besoin d'être compris pour être utilisés efficacement Vous saurez si vos cours respectent ces principes si vous pouvez masquer tous les contenus privés tout en comprenant facilement comment ils sont censés être utilisés. Notre conducteur peut donc désormais simuler la conduite d'une voiture en accédant uniquement aux zones publiques du script de la voiture, agisse d'appuyer sur le frein et de démarrer le moteur, de relâcher le frein, appuyer sur la manette des gaz, de tourner le volant, etc. Ces principes sont non seulement importants pour nos propres scripts, mais ils nous permettent également d' utiliser des scripts écrits par d'autres développeurs sans bien comprendre leur fonctionnement interne. Ils rendent également les scripts R plus flexibles. Imaginez si nous remplacions notre voiture à essence par une voiture électrique Y a-t-il quelque chose à changer dans le script du pilote ? Seul le script de voiture devrait être modifié pour un script de voiture électrique, car toutes les variables et fonctions publiques existeraient toujours dans le script de voitures électriques. De même, nous pourrions également remplacer le script du pilote par un script de pilote automatique, qui n'a besoin que d'une destination et qui sera automatiquement capable de faire fonctionner la voiture Dans la prochaine leçon, nous en apprendrons encore plus sur les principes de conception orientée objet. Je te verrai dans la prochaine leçon. 11. Polymorphisme 0-10: Bonjour, mes amis. Aujourd'hui, nous aborderons le dernier des principes de programmation orientée objet, le polymorphisme étendant les concepts d' héritage et d'abstraction, nous pouvons écrire des classes qui représentent un concept plus abstrait, une collection de classes plus spécifiques liées. Prenons l'exemple des animaux en créant un script nommé animal qui étend le nœud, mais nous n'avons pas besoin d'attacher ce script à aucun nœud de l'arborescence des scènes. Ici, nous pouvons donner un nom de classe au script, puis définir des propriétés et des comportements communs à tous les animaux, comme une variable contenant le pluriel de l' animal sous forme de chaîne, et une autre pour le nom d'un groupe de cet animal Et définissons également une fonction permettant à l'animal de bouger, de manger ou de parler. Bien que nous puissions facilement définir le pluriel d'animal comme des animaux, il n'existe pas de mot pour désigner un groupe d'animaux Nous ne pouvons pas non plus définir la façon dont un animal se déplace ou mange sans savoir de quel type d'animal il s'agit. Les corps de ces fonctions peuvent donc rester vides. Mais nous pouvons considérer que certains comportements sont suffisamment courants pour qu'ils aient une valeur par défaut, comme le fait de parler. Bien que de nombreux mammifères produisent une grande variété de bruits, ce pas le cas de la majorité des animaux, y compris les poissons et les insectes La plupart des gens ne les décriraient pas comme parlant. Ainsi, lorsque nous demandons à un animal de parler au hasard, nous pouvons considérer que le comportement par défaut est le silence. Ajoutons donc différents animaux à notre arbre de scènes, en commençant par un chat. Nous pouvons maintenant utiliser l'héritage, comme nous l'avons fait auparavant, pour créer un certain nombre de scripts animaliers différents qui héritent d'un animal comme un chat Nous allons ensuite remplacer la fonction ready pour donner aux variables héritées de l'animal une valeur appropriée pour un chat Le pluriel serait chats, et un groupe de chats s' appelle un Clouder Les fonctions comportementales peuvent également être remplacées pour transformer le comportement de parole silencieuse Les chats marchent sur quatre pattes pour se déplacer, et je dirais qu'ils mangent du poisson. Le contenu réel de ces variables et fonctions n'est pas pertinent, mais l'accent est mis sur la façon dont elles sont héritées du concept abstrait d'un animal à une instance plus spécifique d'un chat. Nous pouvons répéter ce processus pour créer de nombreuses autres espèces d' animaux à ajouter à notre arbre de scènes, comme un oiseau ou un poisson. Et en dotant chacun un nouveau script hérité d'animal, chacun peut fournir ses propres valeurs uniques pour les variables et les implémentations des fonctions dont variables et les implémentations des il a Le pluriel de « oiseau » est « oiseaux ». Un groupe d'oiseaux s'appelle un troupeau. Ils volent pour se déplacer, ils mangent des vers et ils gazouillent pour parler Je vais prendre une longueur d'avance sur mon script fish en copiant le contenu du script cat. Et le pluriel de poisson est poisson Un groupe de poissons s' appelle un banc. Ils nagent pour se déplacer, ils mangent des algues, mais ils ne parlent pas. En omettant la fonction speak, poisson utilisera la définition héritée du script animal pour parler Jusqu'à présent, nous n'avons fait qu'utiliser les principes orientés objet nous connaissons déjà pour hériter, abstraire et encapsuler les propriétés et les comportements des animaux Mais tout cela nous permet d' utiliser le polymorphisme en traitant tous les animaux comme s'ils étaient égaux et interchangeables Ajoutons d'abord un script au nœud racine de notre scène et appelons-le Zoo, en héritant du nœud Notre zoo regorge d'animaux différents, mais peu importe ce que sont réellement ces animaux. Outre la définition de la fonction prête pour notre zoo, nous pouvons facilement parcourir notre liste d' animaux et les traiter tous comme s'ils n'étaient que des animaux Un moyen rapide et facile de stocker tous nos animaux dans une seule variable. Disons que les animaux utilisent une fonction de nœud appelée Get children. Cela renvoie un tableau de nœuds, tous les nœuds enfants de ce nœud étant organisés de manière pratique en un tableau dans le même ordre que l'arbre des scènes. Comme cela dépend des enfants, nous devons utiliser l'étiquette dès que possible. Comme nous savons que tous les animaux ont mêmes propriétés et comportements, nous pouvons parcourir chaque animal de notre gamme d'animaux et leur dire de parler Et bien qu' ils les traitent tous comme des animaux, chacun parlera à sa manière, selon ses propres scripts, ou utilisera la définition héritée de animal s'il n'a pas la sienne. Nous pouvons créer autant de niveaux d'héritage que nous le souhaitons. Créons donc un autre script abstrait pour les mammifères, héritant de l'animal Les mammifères constituent une sous-catégorie d'animaux, y compris tous les animaux qui possèdent des glandes mammaires et les utilisent pour allaiter leurs petits Il s'agit de propriétés et de comportements uniques des mammifères qui ne s'appliquent pas aux autres animaux. Nous pouvons donc ajouter une nouvelle variable au script du mammifère pour le nombre de glandes mammaires de cet animal et écrire une nouvelle fonction appelée infirmière Encore une fois, le contenu des fonctions n'est pas pertinent pour cette leçon. Ce script aura également besoin d'un nom de classe pour être hérité. Passons au script félin, puisque les chats sont des mammifères, nous pouvons donc donner au nombre de glandes mammaires une valeur pour les chats, qui devrait être de huit Et nous pouvons également ajouter de nouveaux mammifères à notre zoo, comme un singe. Les singes sont également des mammifères, mais ils ne possèdent que deux clans mammaires Je vais à nouveau copier le contenu d'un autre script pour accélérer les choses. Le pluriel de singe est singes. Un groupe de singes s'appelle une troupe. Ils se déplacent en grimpant aux arbres. Ils mangent des bananes, et je dirais qu'ils disent « oh ». Notre script Zoo peut désormais tirer parti de cette nouvelle structure d' héritage pour appliquer des conditions uniques spécifiques aux animaux qui sont des mammifères. Nous pouvons directement utiliser noms de classe dans les instructions conditionnelles pour dire que si l' animal actuel est un mammifère, nous exécuterons du code supplémentaire exclusivement pour les mammifères Je vais juste imprimer quelques lignes supplémentaires décrivant nos mammifères. Et nous pouvons constater que nos résultats sont à la fois cohérents pour tous les animaux, mais qu'ils ont également quelque chose d'unique spécifique pour les deux mammifères. Vous pouvez imaginer comment nous pourrions modifier la liste des animaux de notre zoo pour y inclure toutes sortes d'animaux, et comment nous pourrions modifier notre structure d'héritage pour les classer aussi précisément que nécessaire Dans la leçon suivante, nous allons découvrir une autre collecte de données que nous pouvons utiliser pour regrouper des informations connexes. Je te verrai dans la prochaine leçon. 12. Dictionnaire 0-11: Bonjour, mes amis. Aujourd'hui, nous allons utiliser une alternative au tableau qui est parfois utilisé comme une classe sans aucune fonction appelée dictionnaire. Imaginez une rangée de casiers comme dans un lycée ou un gymnase Si nous déclarons un tableau de variables, nous pouvons considérer que l'indice du tableau de chacune est le numéro du casier Supposons qu'il y ait dix casiers et que nous puissions accéder à chaque casier individuel mettre quelque chose, commençant par le casier zéro, un, etc. Ce que nous mettons dans chaque casier n'a pas d'importance. Il peut s'agir d'un entier, d'un nombre flottant, d'une chaîne, booléen, d'une valeur nulle ou d'une instance de classe Et nous pouvons imprimer le contenu des casiers pour les voir. Imaginez maintenant que lorsque nous mettons quelque chose dans l'un des casiers, nous ne nous contentons pas de fermer la porte du casier, mais aussi d'y mettre un cadenas Ce cadenas nécessite une combinaison de trois chiffres pour s'ouvrir Auparavant, si nous voulions récupérer le contenu du casier, nous suffisait de connaître le numéro du casier, y rendre et d'en sortir le contenu Maintenant, nous pouvons ignorer le numéro du casier, et nous devons plutôt connaître la combinaison pour ouvrir le cadenas Supposons que la combinaison soit 149. En tant que tableau, attribuer quelque chose au numéro 149 signifierait que le tableau devrait avoir 150 casiers Si nous devions changer le type de notre tableau en dictionnaire, cela fonctionnerait toujours, sauf que nous n'avons pas besoin de définir une taille pour le dictionnaire avant de pouvoir accéder à son contenu. Remarquez comment le résultat a changé. dictionnaires sont représentés par des accolades plutôt que par des crochets, et chaque entrée est un nombre représentant une clé suivie et chaque entrée est un nombre représentant une clé suivie de la valeur du contenu du casier verrouillé par cette y a également aucune entrée dans le dictionnaire pour une clé à laquelle aucune valeur n'a été assignée. En tant que dictionnaire, ce numéro n' est ni un index ni une adresse. C'est une clé que nous utilisons pour ouvrir une serrure. Et tout comme le contenu du casier peut être de n'importe quel type de données, les clés que nous utilisons pour le verrouiller peuvent également être n'importe quel type de données avec une seule restriction Chaque clé doit être unique. Sinon, nous ne trouverons pas le casier correspondant à la clé. Essayons donc de verrouiller un casier avec un autre type de serrure, qui utilise des lettres au lieu de chiffres. La clé de cette entrée de dictionnaire est donc une chaîne, mais sa valeur est un nombre. Tout le contraire de ce casier, dont la clé est un nombre et la valeur une chaîne. Verrouillons le casier suivant avec un verrou rotatif, qui nécessite trois numéros pour le déverrouiller, que nous pourrions stocker dans un tableau. La clé des entrées de notre dictionnaire est donc un tableau représenté par des crochets contenant une liste de trois entiers séparés par des virgules Peut-être que ce numéro de serrure inclut un point décimal, donc la clé est un flottant Et d'une manière ou d'une autre, ce casier est verrouillé par photosensibilité et ne peut être ouvert que si les lumières sont éteintes Sa clé est donc un booléen. Nous pouvons même utiliser des classes personnalisées comme clés ou valeurs dans les dictionnaires. Écrivons une nouvelle classe pour la clé, qui n'aura pas besoin d' hériter de quoi que ce soit puisqu'elle ne sera ni attachée à un nœud, ni héritée Notre classe clé a besoin d'un nom de classe et comportera une variable décrivant ses dents. L'implémentation de cette classe n'est pas pertinente, mais nous pouvons prétendre qu'il s'agit d'une clé. De retour dans le script locker, nous pouvons stocker une instance de notre clé dans une variable. Appelons-la clé 1 de type key en l' affectant au nom de classe de key Nunu crée une nouvelle clé, qui est assignée à notre variable Nous pouvons maintenant utiliser cette clé pour créer une entrée dans le dictionnaire. Nous pouvons également créer plus de clés pour créer plus d'entrées. Parce que chaque clé que nous créons est considérée comme unique. La sortie affiche désormais les clés sous la forme d'un nombre de récifs compté suivi d'un nombre long. Les noms que nous avons utilisés dans d'autres classes ont été hérités de node. Mais comme la clé n' hérite pas du nœud, elle n'a pas de nom Ref Counted est l'abréviation de Reference Counted Object, et c'est la classe de base du script GD Si nous écrivons une classe qui n'hérite de rien, elle héritera de Reef Counted et se verra attribuer un numéro long aléatoire Nous pouvons ignorer cela et simplement comprendre que nos clés sont des objets comptés par références, ce qui signifie que Gadot garde automatiquement une trace de chaque instance unique de chaque objet que nous créons Mais que voulons-nous entreposer dans les casiers ? Tout comme les tableaux peuvent contenir d'autres tableaux, les dictionnaires peuvent également contenir d'autres dictionnaires En fonction de la façon dont les dictionnaires sont imprimés, nous pouvons créer nos propres dictionnaires la volée à l'aide Chaque entrée commence par une clé suivie deux points, puis de la valeur correspondant à cette clé. L'utilisation courante des dictionnaires ne consiste pas à créer quelque chose comme ce scénario de casier, mais plutôt à créer quelque chose qui ressemble davantage à une classe, même si elle ne comporte aucune fonction, uniquement des variables Disons que ce casier contient une peluche, que nous allons représenter avec un dictionnaire Et cette peluche fait partie d'un ensemble de peluches à collectionner similaires mais variées à leur manière Chacun des jouets en peluche est un type d'animal différent avec une couleur et un nom Chacune de ces clés peut être une clé du dictionnaire. Disons que ce casier contient Bruno l'ours brun. Et le casier suivant contient Arthur le bouc blanc. Nous pouvons voir notre dictionnaire de jouets en peluche dans le dictionnaire des casiers Il se trouve que la couleur est également une classe déjà définie dans Gadot. Ainsi, au lieu de stocker nos couleurs sous forme de chaînes, elles peuvent être stockées sous forme de couleurs en utilisant le nom de classe color. Comme vous pouvez le constater, il existe de nombreuses couleurs prédéfinies que nous pouvons utiliser, et la façon dont elles sont nommées en majuscules en minuscules indique sont nommées en majuscules en minuscules indique qu'il s'agit de constantes de la classe de couleurs. Nous pourrions même faire fausse route et prétendre que les jouets en peluche contiennent une étiquette NFC ou une étiquette de communication en champ proche, ce qui en fait la clé pour accéder au casier Et nous pouvons mettre ce que nous voulons dans le casier comme avant, y compris une autre peluche. Faisons un autre jouet en peluche à ranger dans le casier, qui est déverrouillé en utilisant Arthur comme Cette fois, c'est mignon, l'éléphant gris. En imaginant ce scénario, il y a un lecteur NFC près des casiers, et nous tenons une peluche avec une étiquette NFC à l'intérieur, un peu comme ce que vous pourriez trouver dans une Si nous plaçons la peluche contre le lecteur, nous devons vérifier quel casier correspond à la peluche et le déverrouiller, si un casier correspond Mais si nous essayons d'accéder à une clé d'un dictionnaire à laquelle aucune valeur n'a été attribuée, nous provoquerons une erreur. De la même manière que nous le ferions si nous essayions d' accéder à un index de tableau hors de portée. Nous pouvons vérifier si un dictionnaire contient une entrée correspondant à une clé spécifique en utilisant la fonction has, puis en passant la clé en paramètre. Cela nous permet de vérifier si une entrée de dictionnaire existe avant d'essayer d' accéder à sa valeur, évitant ainsi l'erreur. Si le dictionnaire n'a pas la clé, j'imprimerai un autre message. Au lieu de définir deux fois le même dictionnaire, il serait préférable de le stocker dans une variable et de l'utiliser deux fois. Dans la leçon suivante, nous allons explorer différentes techniques que vous pouvez utiliser lorsque vous êtes bloqué ou que vous avez besoin de plus d'informations. Je te verrai dans la prochaine leçon. 13. 0-12 déboguer: Bonjour, mes amis. Aujourd'hui, nous allons passer en revue quelques stratégies différentes que vous pouvez utiliser pour vous aider lorsque vous êtes inévitablement bloqué. J'ai déjà joint un script au nœud racine de la scène nommé debug Vous avez probablement remarqué la fonctionnalité de saisie semi-automatique qui est disponible si vous spécifiez le type de vos variables Cela vous permet non seulement de voir toutes les propriétés et fonctions de la classe, mais après avoir sélectionné une fonction, vous pouvez également voir les types de tous les paramètres des fonctions afin de fournir des arguments correspondants. R, lorsque vous connaissez le type de toutes vos variables, erreurs de non-concordance sont clairement apparentes et vous serez averti de l'erreur sans avoir à l'exécuter Sans types stricts, le moteur ne sait pas ce qui ne correspond pas avant d'essayer d'exécuter la ligne Si vous souhaitez parcourir une classe intégrée comme la couleur, nous pouvons facilement accéder aux informations en cliquant sur l'un des boutons situés dans le coin supérieur droit du panneau. Online Docs ouvre un onglet dans votre navigateur Web par défaut vers l'API GADO correspondant à la version de l'éditeur que vous utilisez Vous trouverez ici des informations de base sur Gdo, des conseils pour démarrer, didacticiels détaillés sur les bases, des liens communautaires où vous pouvez trouver des ressources supplémentaires et une référence complète sur les cours Comme vous pouvez le constater, il y a beaucoup de cours. Et en sélectionnant l'une d'entre elles, nous pouvons voir de quoi elles héritent et de quelles autres classes elles héritent Chacun a une description de ce qu'il fait. Liens vers des didacticiels sur son utilisation, une liste de propriétés et de méthodes. Lorsque nous parlons de classes, nous avons tendance à désigner les variables comme des propriétés et les fonctions comme des méthodes. Il existe également des signaux, Gadot utilise pour communication automatique entre les nœuds, énumérations et les constantes, comme nous l'avons déjà Tous ont leurs propres sous-sections et descriptions de leur utilisation. De retour dans l'éditeur GDA, aide à la recherche ouvre une fenêtre dans GDA où vous pouvez voir une liste de chaque classe En sélectionnant une classe, nous pouvons voir toutes les informations disponibles sur le site Web de GDA dans notre éditeur, afin que nous puissions y accéder hors ligne Pour en revenir à notre script, nous pouvons même accéder à ces informations plus facilement en maintenant la touche Ctrl ou Commande enfoncée plutôt qu'en cliquant sur le nom d'une classe, nous amène directement aux informations de référence de cette classe. en va de même pour des fonctions et des variables spécifiques. cliquer dessus ouvre non seulement la page de référence de la classe, mais nous amène également à la fonction ou à la variable sur laquelle nous avons cliqué Il existe également des fonctions globales que nous pouvons utiliser principalement pour effectuer des opérations mathématiques comme clamp, par exemple. Si nous utilisons cette fonction, nous pouvons voir les paramètres attendus et nous pouvons l'utiliser pour fixer notre variable à 0-1 Maintenez la touche Ctrl ou Commande enfoncée et cliquez sur le nom de la fonction globale pour accéder à la référence de cette fonction, qu'à sa description et à son mode d'utilisation. Ils sont tous contenus dans la classe de portée globale. Je vais ajouter une autre variable et une autre ligne à mon script. Si nous exécutons notre scène, nous pouvons afficher l'arbre des scènes de la simulation en cours via le panneau de scène en cliquant sur le bouton de la télécommande. ne s'agit pas du même arbre de scènes dans l'onglet local que nous avons créé pour définir la scène comme un plan Cet arbre de scènes est celui qui a été créé par le moteur pour exécuter la scène. En sélectionnant un nœud, nous pouvons voir ses propriétés dans l'inspecteur et nous pouvons voir que la fonction Ready est déjà exécutée car les couleurs ont des valeurs différentes. Nous pouvons également modifier les valeurs de n'importe laquelle de ces propriétés. Nous pouvons également utiliser l'impression pour imprimer chaque fois que nous voulons voir ce que contiennent nos variables à tout moment. Et il est utile que vos relevés imprimés soient aussi descriptifs que possible , afin d'éviter toute confusion quant à leur provenance. Mais si nous changeons les choses et utilisons la fonction de traitement, je changerai simplement la couleur progressivement au fil du temps, puis j'ajouterai une déclaration d'impression ici. Comme cette fonction de processus s' exécute 60 fois par seconde, la valeur des instructions d'impression en tant qu' outil de débogage est considérablement réduite, car le journal de sortie va simplement répéter le même message plus rapidement que nous ne pouvons le lire ou y réagir Nous pouvons suspendre la simulation pendant qu'elle est en cours d'exécution, en utilisant le bouton pause ou en appuyant sur F sept. Cela nous permet de voir l'arbre des scènes distantes tel qu'il est actuellement et de revoir le contenu du panneau de sortie lorsque la simulation est suspendue. Mais cela n'est toujours pas très utile, car plusieurs images seront terminées entre le début de la simulation et le moment où nous pourrons la suspendre. Si nous cliquons à gauche d'une ligne de code, nous pouvons ajouter un point d'arrêt automatique indiqué par un cercle rouge Lorsque nous exécutons la scène en cours, la simulation s' arrête lorsqu'elle atteint cette ligne avant de l'exécuter. Cela est beaucoup plus utile si nous voulons que notre simulation s'exécute image par image. Nous pouvons maintenant voir comment la couleur de chaque image change progressivement d'une image à l'autre. Demandons à notre fonction de processus d'appeler une autre fonction pour effectuer une tâche simple. Je vais juste changer la couleur progressivement en réduisant sa valeur rouge. Nous devrions donc voir la couleur changer progressivement à chaque image, devenant moins rouge et plus bleue. Le point d'arrêt étant toujours sur la première ligne de la fonction de processus, je vais lancer la scène Cela s'arrête là, et nous pouvons voir que la prochaine ligne de code à exécuter est indiquée par un triangle jaune. Lorsque la simulation est interrompue de cette façon, nous pouvons lui demander de n'exécuter qu' une seule ligne de code à la fois, plutôt qu'une image entière en sélectionnant Step Over dans le menu Debug ou en utilisant le raccourci F ten Cela exécutera uniquement la ligne de code pointée par le triangle jaune, puis fera immédiatement une nouvelle pause. Nous pouvons donc voir les modifications apportées uniquement par cette seule ligne de code, et nous pouvons voir le triangle jaune pointer vers la ligne suivante en attente d'exécution. Nous pouvons continuer à exécuter notre script ligne par ligne si nous continuons jusqu'à ce que la fonction de processus se termine et que le cadre soit terminé, revenant en haut de la fonction de processus pour l'exécuter une deuxième fois. Nous pouvons maintenant voir chaque individu changer de couleur sa valeur bleue augmente indépendamment lorsque sa valeur bleue augmente indépendamment de la diminution de la valeur rouge, même si cela se produit au cours de la même image. Dans le cas d'appels de fonction, il existe une autre option pour accéder à la fonction. Si nous sélectionnons cette option ou utilisons le raccourci F 11, la flèche jaune entrera dans la fonction appelée et exécutera cette ligne à la fois jusqu'à ce qu'elle soit terminée. Lorsque la fonction est terminée, la flèche jaune revient à la fonction d'origine pour continuer à exécuter celle-ci. Grâce à ces outils, nous avons une vision très précise de ce que font nos classes, du moment où ils se comportent, et nous pouvons les observer aussi lentement nécessaire pour comprendre ce qui ne va pas à quel moment précis Si vous ne pouvez pas résoudre un problème vous-même, la communauté GDA est très utile et toujours prête à vous donner un coup de main Il existe des serveurs Discord pour les développeurs de GDA, y compris mon serveur où mes étudiants s'entraident Le lien pour m'inscrire se trouve dans mon profil. Il existe également des forums en ligne sur des sites Web comme Redit où vous pouvez également poser des questions. Vous avez maintenant une compréhension de base de la plupart de la syntaxe de GDScrip et des outils nécessaires pour approfondir ces concepts Lorsque vous serez prêt, demandez-moi un code de réduction pour de mes cours de projet de jeu, et bonne chance. 14. 1 3 Installation: Oh mes amis, bienvenue dans mon cours. Je suis en train de créer un jeu de plateforme complet à deux pixels 3D dans Godot. Pour commencer à utiliser le moteur Cado, vous devez d'abord le télécharger depuis leur site Web, rendre sur GodoEngine.org et télécharger la Pour ce cours, j' utiliserai la version 4.2 de God . Une fois le téléchargement terminé, il suffit de décompresser le dossier et de lancer le fichier EX Assurez-vous de déplacer ces fichiers décompressés vers un emplacement approprié sur votre J'aimerais que le moteur soit épinglé ma barre des tâches pour y accéder facilement n'y a pas d'installateurs, de hubs ou d'interfaces de magasin compliqués à comprendre. Si vous avez déjà travaillé avec d'autres moteurs de jeu, vous serez probablement surpris de la simplicité et de la facilité d'utilisation de Good. En comparaison, lorsque vous êtes prêt, cliquez sur le bouton Nouveau projet. Donnez un nom à votre projet. C'est souvent le même que le titre de votre jeu, mais il arrive souvent que les parties démarrent sans qu'il y ait encore de titre officiel. Les développeurs utiliseront des éléments tels que Untitled Platform ou Untitled Pirate jusqu'à ce qu'un titre officiel soit Sélectionnez l'endroit de votre disque dur où vous souhaitez que le projet soit stocké. Je recommande de créer un sous-dossier dans les documents nommé Godot Projects et de donner à chacun de vos projets son propre dossier dédié dans ce dossier pour les organiser. Comme le jeu que nous allons créer utilise de simples images en deux pixels dans deux scènes en D, nous pouvons utiliser le moteur de rendu de compatibilité qui prend en charge les plateformes de bureau, mobiles et Web et qui est le plus rapide pour le rendu de scènes simples comme Enfin, Dieu optimisera compatibilité avec le contrôle de version de Github par défaut, ce qui est très utile lorsque vous avez terminé Cliquez sur Create and It pour créer le projet et l' ouvrir pour le modifier Le projet s'ouvre sur une scène en trois D vide, mais nous sommes en train de créer un jeu en deux D. Sous l'onglet Scène, qui se trouve dans le coin supérieur gauche. Par défaut, cliquez sur deux scènes en D pour créer une nouvelle scène en deux D. Cela fera automatiquement passer vue de notre éditeur en mode deux D. Si jamais vous trouvez que votre éditeur est en mode 3D, vous pouvez toujours passer à l'aide des boutons situés en haut de la fenêtre de l'éditeur. Cado. Chaque scène est définie comme un arbre de nœuds. La scène elle-même est définie comme un nœud deux. Il s'agit d'un nœud deux D, c'est le nœud racine de la scène. Nous construisons nos scènes en ajoutant des branches à l'arbre des scènes. Cliquez sur le bouton plus sous l'onglet Scène pour ajouter un nœud à l'arborescence des scènes. Comme vous pouvez le constater, il existe de nombreux types de nœuds différents. Tapez, étiquetez dans la barre de recherche et ajoutez un nœud d'étiquette à votre scène. Sélectionnez votre nouveau nœud Les propriétés des nœuds A peuvent être modifiées dans l'onglet inspecteur , situé sur le côté droit de la fenêtre de l'éditeur. Par défaut, saisissez le message de votre choix dans la zone de texte. Lorsque vous avez terminé, enregistrez votre scène en sélectionnant scène dans la barre de menu, puis enregistrez la scène. Vous pouvez également utiliser le raccourci clavier S, ou la commande S, pour donner un nom à votre scène. La convention de dénomination de Godot consiste à utiliser des majuscules en forme de serpent, qui sont toutes en minuscules avec des traits de soulignement au lieu d'espaces Cliquez sur le bouton Enregistrer pour enregistrer votre première scène. Lorsque vous avez terminé, cliquez sur le bouton Exécuter la scène actuelle dans le coin supérieur droit de la fenêtre de l'éditeur. C'est celui avec l' icône de jeu sur un clapet. Ce n'est pas encore une scène très excitante, mais elle fonctionne. Cliquez sur l'icône d'arrêt pour arrêter la scène. Dans l'onglet Système de fichiers , situé dans le coin inférieur gauche, vous pouvez voir par défaut une liste de tous les fichiers qui composent votre projet. Chaque nouveau projet Godot n'a qu'un seul fichier de ressources fourni par défaut, le logo Godot Cliquez sur le logo et faites-le glisser dans votre scène. Cela a ajouté un nœud sprite en deux D nommé icon à l' arbre de la scène et défini l' icône comme texture du sprite Il s'agit simplement d'une image dessinée à l'écran. Préparons-nous pour la prochaine section du parcours en créant un sol solide sur lequel notre personnage pourra marcher et sauter. Pour cela, nous devrons ajouter la collision. Cliquez avec le bouton droit sur le nœud icône et sélectionnez Ajouter un nœud enfant. À l'aide de la barre de recherche, recherchez le corps statique à deux nœuds D. Cela ajoute le nouveau nœud en tant qu'enfant du sprite, mais il affiche un avertissement Si nous survolons l'icône d'avertissement, cela nous donnera plus d'informations Ce nœud ne peut entrer en collision avec quoi que ce soit car il ne connaît pas sa forme Pour ce faire, le nœud à deux corps statique en D a besoin d' un autre nœud enfant. En ajoutant un autre nœud, comme avant cette fois, recherchez une collision en forme de deux nœuds D, l'icône d'avertissement sur le corps statique Tu T note a disparu. Mais le nœud Tut en forme de collision récemment ajouté contient un autre avertissement Il nous demande de bien vouloir créer une ressource de forme pour cela. Cela se fait dans le panneau de l'inspecteur à l'aide du menu déroulant intitulé Shape Select New Rectangle Shape. Cela a satisfait à l'avertissement. Mais en regardant la scène, nous pouvons voir que la forme de collision ne correspond pas à l'icône. Si nous voulons que la collision couvre l'intégralité de l'icône, nous devons l'ajuster. Vous pouvez cliquer et faire glisser le pointeur sur les cercles rouges pour redimensionner la forme de collision Si vous souhaitez un contrôle plus précis, vous pouvez cliquer sur la ressource en forme de rectangle en deux D pour l'agrandir, ce qui expose des champs de texte dans lesquels vous pouvez entrer des valeurs exactes pour la taille Si la forme de collision est décentrée, vous pouvez étendre la section de transformation sous le nœud deux D pour ajuster sa position. Vous pouvez également ajuster cette valeur manuellement en cliquant et en faisant glisser la croix rouge au centre de la forme de collision Sélectionnez le nœud d'icône et renommez-le en étage. Comme nous n'avons plus besoin d'apporter modifications aux nœuds enfants, nous pouvons réduire ce nœud en cliquant sur la flèche de réduction. Maintenant, transformons-en un véritable plancher. Ajustez votre affichage dans la fenêtre d'affichage jusqu'à ce que vous puissiez voir toute la bordure bleue Comme il chevauche l'axe X rouge, le haut de la boîte apparaît en magenta et le côté gauche chevauchant l'axe Y vert Cette boîte bleue peut-elle être les limites de l'écran lorsque nous lançons le jeu avec le nœud de sol sélectionné, ajustons sa position, sa taille et sa forme pour qu'il couvre le bas de l'écran. Maintenez le bouton Alt ou Options enfoncé pour déplacer uniquement le nœud sélectionné et ses enfants. Nous venons de créer un étage fonctionnel pour notre environnement de test de jeux à partir de l'icône Godot Ce type de flux de travail est courant dans le développement de jeux vidéo. Utiliser des éléments d'espace réservé pour créer un projet minimal, qui peut être utilisé pour prototyper et démontrer les mécanismes du jeu Mais pour créer un jeu qui soit beau, nous aurons besoin d'actifs. J'ai créé ce cours à l'aide d'un pack d'actifs gratuit appelé Treasure Hunters, créé par Pixel Frog. À partir de là, ces actifs sont publiés sous une licence Creative Common Zero. Vous pouvez distribuer, remixer, adapter et développer le matériel sur n'importe quel support ou format, même à des fins commerciales L'attribution n'est pas requise. Vous pouvez télécharger l'intégralité du pack d'actifs gratuitement ou éventuellement soutenir l'artiste en payant le montant de votre choix. Une fois le téléchargement terminé, décompressez le dossier. Pour importer les actifs, il suffit cliquer dessus et de les faire glisser dans la fenêtre du projet J'utiliserai également effets sonores et de la musique téléchargés sur FreeSound.org. La bibliothèque de boucles Victory War et Battle Music a été composée par Little Robot Le pack de sons Battle est créé par Luke Sharpals. Ces fichiers audio et musicaux sont soumis à une licence d' attribution. Ils peuvent toujours être utilisés gratuitement à n'importe quelle fin, mais vous devez attribuer le crédit approprié au créateur de ces actifs et fournir un lien vers la licence. une attention particulière aux exigences de licence et d'attribution des actifs que vous incluez dans vos jeux. L'importation de ces actifs fonctionne de la même manière que l'illustration. Il suffit de cliquer dessus et de les faire glisser dans l'éditeur. Cependant, ces fichiers audio sont beaucoup plus volumineux que les images et nous n' en utiliserons pas beaucoup. Je recommande de n'importer ces actifs que lorsque vous décidez de les implémenter. Nous avons maintenant un étage fonctionnel avec collision et tous les éléments artistiques dont nous avons besoin pour passer à la section suivante, qui sera consacrée à la mise en œuvre d'un personnage. Je vous verrai dans la section suivante. 15. 2 1 personnage: Bonjour les amis. Dans la première section, nous avons lancé le projet, importé certains actifs et créé un sol fonctionnel avec collision. Dans cette section, nous allons nous concentrer sur la création d'un personnage que le joueur pourra contrôler et avec lequel il pourra jouer. Pour commencer, nous allons d'abord créer la structure des nœuds d' un personnage typique dans le panneau de scène. Cliquez sur le bouton plus pour ajouter un nouveau nœud à l'arborescence des scènes. Recherchez un nœud de corps de personnage en deux D et créez-le. Je vais renommer ce nœud avec le nom de mon personnage. Tout comme pour le sol, il y a un avertissement. Ce nœud n'a aucune forme. Il ne peut donc pas entrer en collision ou interagir avec d'autres objets. Nous savons déjà comment remédier à ce problème. Il suffit d'ajouter une forme de collision deux nœuds en D et de définir sa forme. L'avertissement nous rappelle que nous devons créer une ressource de forme dans l'inspecteur. La plupart des personnages des jeux utilisent des capsules comme formes de collision, car elles sont facilement ajustables pour englober la forme générale d' un humanoïde et sont simples à utiliser pour le moteur. Par défaut, les nouveaux nœuds sont ajoutés à l'origine de la scène dans le coin supérieur gauche. Zoomons sur les nouveaux nœuds. Nous devons également être en mesure de voir à quoi ressemble le personnage. Pour cela, nous allons ajouter un autre nœud enfant au personnage, un sprite, deux D. Nous avons vu dans la leçon précédente qu'il existe une propriété de texture dans le panneau d' inspection pour les sprites, mais que celle-ci est vide en parcourant le pack d'actifs des chasseurs de trésors Sélectionnez le personnage sprite à utiliser. Par défaut, je ne veux pas que mon personnage soit équipé d'une épée par défaut. Je vais sélectionner dans le dossier Without Sword et choisir Idle One. Nous pouvons maintenant voir le personnage tel qu'il sera dessiné dans le jeu, mais il est flou Cela est dû au fait que les paramètres de projet par défaut de Godo ne sont pas optimisés pour le pixel art. Pour résoudre ce problème, sélectionnez le projet dans la barre de menu, puis les paramètres du projet. Il existe de nombreux paramètres de projet et, selon votre version de Godot, ils peuvent ne pas être organisés ou nommés de la même manière Si vous ne parvenez pas à trouver les paramètres du projet, trouverez une barre de recherche en haut de la fenêtre intitulée Paramètres de filtre. Nous devons trouver les paramètres de rendu de deux textures en D, puis changer le filtre de texture par défaut du linéaire au plus proche. Cela empêchera le moteur graphique d'essayer de lisser la texture et de simplement dessiner tel quel à l'écran. Avec les modifications apportées, nous pouvons fermer la fenêtre et maintenant le personnage est dessiné en pixels parfaitement définis. Lorsque vous travaillez avec du pixel art, c'est généralement l'esthétique préférée. Avec les axes X rouge et Y vert marquant l'origine de la scène. Nous devons partir du principe que l' origine du personnage sera à ses pieds. Faisons glisser la planche vers le haut jusqu'à ce l'axe X rouge fasse office de plancher où le personnage se tiendra debout. Assurez-vous qu'ils sont également centrés sur l'axe Y vert. Pour faciliter le réglage de la forme de collision, je vais la réorganiser pour qu'elle se trouve en dessous du sprite dans l'arbre des scènes, tout en restant une enfance pour le personnage Cela détermine également l'ordre dans lequel les nœuds sont dessinés à l'écran. Avec la forme de collision située devant le sprite, il est plus facile de le déplacer et d'ajuster sa taille en fonction du personnage N'oubliez pas que le point inférieur de la capsule de collision doit être aligné avec les pieds du personnage et l'axe X rouge pour le personnage puisse se tenir proprement sur le sol Et doit également être centré sur l'axe Y vert. Dans deux jeux en D comme celui-ci, il est généralement considéré comme une bonne pratique de réduire la forme de la collision par rapport au personnage. Cela empêchera le joueur d' touché par des attaques qu' il percevrait comme étant être touché par des attaques qu' il percevrait comme étant proches de Mme et lui permettra de se rapprocher de l'environnement. Avant de passer à l'étape suivante, assurez-vous que panneau de votre système de fichiers est centré sur le dossier de ressources racine. De nouvelles ressources seront créées dans le dernier dossier avec lequel vous avez interagi Dans le panneau du système de fichiers, vous pouvez réduire tous les dossiers ouverts et cliquer sur l'espace vide. Si votre assureur bien fait cela, cliquez sur votre personnage. Nous pouvons prendre n'importe quelle branche de notre arbre de scènes et l' enregistrer en tant que scène à part entière. Je vais donner à cette nouvelle scène le nom du personnage qu'elle a déjà créé puisqu'elle utilisera le nom du nœud comme nom de scène par défaut. Maintenant, Roger est leur propre scène séparée de la scène sur laquelle nous avons travaillé. nœud de Roger dans l'arbre des scènes possède un bouton en forme de clapet et les nœuds enfants ont été masqués Cliquez sur le clapet pour ouvrir la scène de Roger. Cela nous permet de modifier Roger de manière isolée. Toutes les modifications que nous apportons ici seront transférées à toutes les scènes contenant Roger dans la scène principale. Nous pouvons maintenant déplacer Roger de l'origine de la scène jusqu' au sol où ils seront dessinés à l'écran. Si nous parcourons la scène actuelle, nous pouvons voir Roger planer au-dessus du sol, mais il devrait probablement tomber sur le sol à cause de la gravité Pour que Roger se comporte comme un personnage, nous devons ajouter un commutateur de script à la scène de Rogers et sélectionner le nœud racine. Cliquez ensuite sur le défilement avec un bouton plus pour ajouter un nouveau script. Il est recommandé d'écrire les comportements courants de manière aussi générique que possible. Ce script ne doit pas être Roger. Je vais plutôt nommer le personnage du script et écrire le script de manière à ce qu'il puisse s'appliquer à n'importe quel personnage Roger Godot ne propose pas seulement un modèle par défaut pour les scripts attachés à certains nœuds Nous verrons ce que contient ce modèle. Par défaut, le script héritera des comportements du type de nœud auquel il est attaché, dans ce cas un corps de caractère de deux D. Nous allons écrire tous nos scripts dans la langue maternelle de Goido, le script Godot Cliquez sur Créer pour créer le nouveau script et l'associer au nœud. Le panneau principal passe automatiquement en mode script et ouvre le script pour le modifier. Comme vous pouvez le constater, le modèle possède déjà plusieurs fonctionnalités. Le personnage a une vitesse et une vélocité de saut. Ils sont mesurés en pixels par seconde. Il existe également une force gravitationnelle définie par les paramètres du projet. Dans la fonction du processus physique, nous pouvons voir que la gravité est appliquée au personnage s'il n'est pas au sol. Un bouton de saut a été implémenté pour ajouter de la vélocité au saut. Lorsque vous appuyez sur UI, à l'exception de la barre d'espace, un contrôle directionnel pour les directions gauche et droite permet au personnage de se déplacer et de s'arrêter Move inside est une fonction intégrée qui prend en compte la position du corps du personnage, sa vélocité et les forces extérieures. Déterminez ensuite où se trouvera le personnage une fois le temps delta écoulé Avec les paramètres par défaut, ce code sera exécuté 60 fois par seconde. Si nous reprenons la scène actuelle, nous verrons Roger tomber de la scène d'origine. Mais c'est la scène de Rogers, elle n'est pas faite pour être jouée. Revenez à la scène principale et passez à deux D. En jouant cette scène, nous pouvons voir Roger tomber immédiatement par terre. Appuyez sur la barre d'espace pour faire sauter Roger. Appuyez sur les flèches gauche et droite déplacer Roger vers la gauche et vers la droite. Cette implémentation des contrôles n'est pas très bonne, mais elle constitue un point de départ à partir duquel nous pouvons créer notre jeu. Nous avons maintenant un personnage de base dessiné à l' écran avec des commandes et une physique de base. Dans la prochaine leçon, nous allons nous concentrer sur l'amélioration des contrôles des joueurs. Je te verrai dans la prochaine leçon. 16. 2 2 entrées: Bonjour les amis. Dans la leçon précédente, nous avons créé un personnage de base avec une physique des collisions par pulvérisation et des données de base. Dans cette leçon, nous allons configurer une meilleure gestion des entrées pour contrôler notre personnage. Commençons cette leçon par un peu de ménage. Comme vous pouvez l'imaginer, notre jeu contiendra de nombreuses ressources différentes. Et il est important de les organiser afin que nous puissions trouver rapidement et facilement toutes les ressources dont nous avons besoin, n'est-ce pas ? Cuisiner dans le dossier racine ou dans un espace vide. Créez un nouveau dossier et nommez-le. Scripts, puis faites glisser le script du personnage dans le dossier. Répétez ensuite le processus avec les scènes. Mais nous avons deux types de scènes différents. Nous pouvons également les distinguer avec un sous-dossier dans le dossier des scènes nommé characters et placer Roger dans ce sous-dossier Lorsque vous avez terminé, passez en mode script. Réexaminer le modèle par défaut fourni pour le script en deux D avec le corps du personnage ne répond pas vraiment à nos besoins. Nous avons nommé ce script « Personnage et prévoyons de l'appliquer à tous les personnages de notre jeu, dont la plupart ne seront pas contrôlés par le joueur. Il est important d'isoler et de séparer les fonctionnalités dans différents scripts pour ce script, que nous utilisons pour décrire les attributs et les comportements des personnages. Nous devons supprimer toute gestion des entrées. Je vais commenter ces lignes en appuyant sur la commande K ou la commande K. L'application d'entrées de gravité et de mouvement pendant le processus physique est toujours utile. Mais ajoutons quelques méthodes publiques au script pour décrire exactement ce que peut faire un personnage. Dans notre jeu, un personnage peut faire face à gauche ou à droite. Pour l'instant, nous allons simplement laisser le corps de ces méthodes vide en écrivant, en passant ou en retournant. Un personnage peut courir, ce qui nécessite une direction pour savoir s'il se déplace vers la gauche ou vers la droite. Nous pouvons représenter la direction sous la forme d'un flottant, qui est un nombre qui autorise les valeurs décimales Cela sera non seulement utile pour connaître la direction, mais aussi pour permettre une vitesse variable. Nous devrons stocker cette valeur dans une variable afin qu'elle puisse être utilisée lors du prochain processus physique. Définissons une variable locale privée dans notre script appelée direction du soulignement, puis définissons sa valeur dans la fonction d'exécution Nous pouvons également modifier le processus physique pour utiliser cette variable au lieu de celle qu'il utilisait auparavant. Un personnage peut également sauter, mais nous n'avons pas besoin de paramètres pour celui-ci. Si le personnage est au sol, ajoutez la vélocité de saut à la vélocité y du personnage. Ce seront nos méthodes publiques que les autres scripts pourront utiliser pour contrôler n'importe quel personnage de notre jeu. Nous ajouterons d'autres méthodes au script au fur et à mesure que nous ajouterons des comportements supplémentaires à nos personnages. D'autres méthodes, comme le processus physique, qui ne concernent pas les autres scripts, sont signalées par un trait de soulignement précédent, tout comme la variable de direction du trait de soulignement Ils ne sont pas destinés à être utilisés par d'autres scripts, ils sont uniquement destinés à ce script. Si un autre script souhaite contrôler la direction d'un personnage, il doit plutôt appeler la méthode run, car celle-ci est publique. Cela crée un ensemble universel de comportements clairement nommés pour décrire comment un personnage agira à notre avantage. Une pratique connue en programmation sous le nom d'encapsulation. Le contenu de ces méthodes, de ces variables et du processus physique n'est pas important pour les autres scripts. Les autres scripts n'ont pas besoin de savoir comment le personnage saute, ils doivent juste savoir qu'il s' agit d'un personnage et qu' il peut sauter en se cachant Les détails de la mise en œuvre des fonctionnalités sont connus en programmation sous le nom d'abstraction. Ces pratiques rendront vos scripts beaucoup plus organisés, faciles à comprendre, à utiliser et à adapter à d'autres fins. Cela commence à sembler être un meilleur script de personnage, mais nous avons empêché le joueur de contrôler le personnage, car nous voulons que cela se fasse en passant d'un script distinct à la scène principale. Si vous n'y êtes pas déjà, cliquez avec le bouton droit sur votre personnage et ajoutez un nœud enfant. Ce nœud n'a besoin d'aucun type. Il peut simplement s'agir d'un nœud de base et le nommer Player. Nous ne l'utilisons que pour associer un script supplémentaire au personnage. Ensuite, dans le panneau du système de fichiers, écrivons, cliquez sur le dossier des scripts pour créer un nouveau script et appelons-le player. Attachez-le ensuite au nouveau nœud. Cliquez sur l'icône du script pour ouvrir le script afin de le modifier. Le but du script sera de recevoir des entrées et d'appeler les méthodes appropriées dans le script du personnage en conséquence. Ce qui signifie que nous devrons faire référence au personnage. Si vous vous souvenez bien, nous attachons ce script à un nœud enfant du nœud du personnage. Nous pouvons facilement obtenir une référence au nœud du personnage en déclarant une variable en haut du script. Nous nommerons cette variable trait de soulignement, car seul ce script devrait avoir besoin d' y accéder et d'attribuer sa valeur à get parent Commencer la déclaration par at on ready nous permettra d'attribuer une valeur à cette variable une fois que le nœud a été créé, entré dans l'arborescence des scènes et qu'il est prêt à démarrer. Cela signifie que le nœud saura qui est son parent à ce moment-là. Pour recevoir et traiter les entrées, nous utiliserons deux méthodes différentes, processus de soulignement et l'entrée de soulignement La méthode de saisie est plus efficace pour gérer les événements liés à la pression et au relâchement des boutons. Cette méthode prend un paramètre, généralement nommé event, et son type sera un événement d'entrée. Il suffit de vérifier l'événement pour voir si le joueur a appuyé sur le bouton de saut. Si c'est le cas, nous demanderons au personnage sauter comme le processus physique Underscore Process prend le delta comme paramètre, qui est un type flottant représentant le temps écoulé depuis le dernier processus Généralement un soixantième de seconde. Mais comme nous n'allons pas utiliser la valeur de delta ici, nous pouvons préfixer son nom par un trait de soulignement, indiquant au moteur Goodot que nous n'avons pas besoin cette valeur dans la méthode de traitement, qui exécutera chaque image, que l'entrée ait été donnée ou modifiée ou non De toute façon, nous pouvons vérifier l'état de notre saisie de mouvement. Cela nous permettra de gérer les pressions sur les touches et axes analogiques plus facilement et de manière interchangeable. Nous appellerons character do run ici en transmettant l'argument de input get axis, run left comme valeur négative et run right comme valeur positive. Vous avez peut-être remarqué que les entrées par défaut étaient UI accept, UI left et UI right. Il s'agit de mappages d'entrée intégrés destinés à contrôler les interfaces utilisateur Comme nous avons utilisé des noms différents pour les mappages d'entrée, nous devrons les ajouter aux paramètres du projet avant qu'ils ne fonctionnent Ouvrez les paramètres du projet et passez de l'onglet à la carte d'entrée. Si vous cliquez sur le bouton Afficher les actions intégrées, vous pouvez voir les actions de saisie utilisées précédemment Vous pouvez masquer à nouveau ces mappages avec le même type de bascule. Courez vers la gauche dans le champ d'action Ajouter une nouvelle action et cliquez sur le bouton Ajouter. Répétez ensuite l'opération pour courir à droite et sautez pour associer chacune d' elles à un bouton. Cliquez sur le bouton plus sur la droite. Cela ouvre une fenêtre contextuelle dans laquelle vous pouvez sélectionner n'importe quelle entrée pour le clavier, la souris ou le joypad Vous pouvez utiliser la barre de recherche pour filtrer les options ou utiliser un champ d'écoute pour le détecter automatiquement. Pour courir à gauche, j' utiliserai la touche A. Répétez ensuite le processus pour ajouter une touche pour courir à droite et sauter. Vous pouvez également ajouter plusieurs boutons à chaque mappage pour que vos jeux fonctionnent parfaitement. Avec une manette de jeu, j' utiliserai le joystick gauche pour courir et le bouton inférieur pour sauter. Lorsque vous avez terminé, essayez de lancer la scène et tester vos nouveaux mappages d'entrée pour contrôler le personnage Tout devrait fonctionner de la même manière qu'avant, mais à présent, le traitement des entrées et contrôle des caractères sont gérés par des scripts distincts. En utilisant cette méthode, vous pouvez imaginer comment le personnage que le joueur contrôle peut devenir interchangeable. Le script de gestion des entrées peut également être remplacé par un script AI pour contrôler assez facilement les autres personnages de votre jeu. Nous avons désormais une meilleure gestion des entrées pour contrôler un personnage dans votre jeu. Dans la prochaine leçon, nous nous concentrerons sur l'amélioration la sensation de locomotion et de la mécanique du saut Je te verrai dans la prochaine leçon. 17. 2 3 Locomotion: Bonjour, mes amis. Dans la leçon précédente, nous avons amélioré la gestion des entrées de notre personnage en l'isolant dans son propre script distinct de notre personnage Dans cette leçon, le joueur appréciera mieux les commandes de locomotion du personnage Si vous lancez la scène principale et que vous prêtez attention à la sensation des mouvements de gauche et de droite, elle est très rigide. La vitesse de déplacement est instantanée et constante, ce qui n'est pas la façon dont les humains ou les autres objets se déplacent réellement Ouvrez le script du personnage pour simuler un mouvement plus réaliste. Nous pouvons en fait utiliser des variables issues de la physique du monde réel. En réalité, un objet accélérera progressivement jusqu'à sa vitesse maximale et accélérera également. Ici, en haut du script, Godot a défini une valeur constante pour la vitesse des caractères Ajoutons ici deux nouvelles variables pour représenter l'accélération et la décélération, que nous mesurons en pixels par seconde au carré Ils peuvent être privés précédés d' un trait de soulignement et seront de type flottant Nous allons leur donner les valeurs initiales pour le moment. J'utiliserai simplement la même valeur que la vitesse et je les ajusterai plus tard après avoir testé leur sensation. Le processus physique devra maintenant utiliser ces valeurs pour calculer la vélocité du personnage. Si nous examinons d'abord le bloc else, c'est là que le personnage décélère lorsque le joueur ne fournit aucune entrée Il suffit de changer la vitesse en décélération. Cette fonction utile appelée move towards démarrera à la valeur de la vitesse x et déplacera vers zéro une certaine décélération Cela fonctionne bien dans les directions gauche et droite, car s'arrêter signifiera déplacer la vitesse vers zéro. Mais si vous regardez ci-dessus, la valeur de gravité est multipliée par le delta. N'oubliez pas que ce code s'exécute 60 fois par seconde. Et nous indiquons notre taux de décélération en unités de pixels par seconde au carré. Nous pouvons multiplier la valeur de décélération par delta pour ajuster sa valeur en fonction du temps écoulé depuis le dernier écoulé depuis le Ensuite, nous pouvons réécrire le bloc F pour utiliser la même fonction et appliquer l'accélération Cette fois, nous commençons à la vitesse x, en nous dirigeant vers la vitesse multipliée par la direction à un taux d'accélération multiplié par delta. N'oubliez pas que nous pouvons utiliser ce script pour tous les personnages de notre jeu, et que nous ne voulons peut-être pas que tous les personnages aient exactement la même vitesse constante. Tout d'abord, changeons la vitesse d'une constante à une variable privée et modifions la formule d'accélération en conséquence. Ensuite, nous pouvons ajouter lors de l' exportation au début de ces déclarations de variables pour les rendre accessibles à d'autres parties du moteur Godot, à savoir l'inspecteur Si nous passons à la scène du personnage et que nous sélectionnons le nœud racine, vous verrez désormais ces variables dans l'inspecteur et pourrez modifier leurs valeurs. Ainsi, chaque personnage peut définir ses propres valeurs de mouvement, vitesse, d'accélération et de décélération. Il n'est pas nécessaire qu'il s'agisse de valeurs constantes identiques. Revenez à la scène principale et essayez de jouer avec ces nouvelles valeurs. Vous pouvez voir comment le personnage accélère progressivement pour atteindre la vitesse maximale et décélère également Comme nous avons utilisé la même valeur que la vitesse des caractères pour l'accélération et la décélération, nous savons que le temps nécessaire pour atteindre vitesse maximale est exactement de 1 seconde De même, le temps qu'il faut au personnage pour s' arrêter complètement est également d'une seconde. Nous pouvons ajuster ces valeurs rapidement et facilement à partir de l'inspecteur même pendant le déroulement de la scène. Cela nous permet de tester et de sentir rapidement comment les différentes valeurs de nos variables affecteront le jeu et de voir quelles valeurs fonctionnent le mieux. Je pense que le personnage doit atteindre sa vitesse maximale en une demi-seconde et s'arrêter en un quart de seconde. Nous allons augmenter les valeurs d' accélération et de décélération d'un facteur de 2,4 en conséquence, essayons-le Cela me convient mieux si votre taux d'accélération réglé à un niveau inférieur à votre taux de décélération Cependant, si vous essayez de changer de direction en vous déplaçant, la redirection ne vous semblera pas naturelle En effet, vous vous attendez à ce que le personnage décélère jusqu'à zéro, puis accélère dans la direction opposée Mais le code tel qu'il est écrit indique qu'ils devraient simplement accélérer de la mauvaise direction vers la bonne direction. Pour que cela soit plus agréable, nous pouvons modifier l'instruction if pour vérifier d' abord si la direction est nulle, auquel cas le personnage devrait décélérer Ensuite, sachant que la direction n'est pas nulle, nous pouvons vérifier si la vitesse x est nulle, est-à-dire que le personnage est immobile et lui dire d'accélérer. Nous avons également besoin de la condition si le sinus de direction est le même que le sinus de la vitesse x, ce qui signifie qu'ils se déplacent déjà et le joueur souhaite continuer à se déplacer dans la même direction. Notre dernière possibilité est si ni la direction ni la vélocité ne sont nulles et que leurs sinus ne correspondent pas, ce qui signifie que le joueur veut se déplacer dans la direction opposée à celle du personnage Dans ce cas, nous pouvons plutôt passer la vitesse au rythme de la décélération Cela paraîtra beaucoup plus naturel lorsque le joueur essaiera de faire demi-tour en se déplaçant. Essayons-le beaucoup mieux avant de passer à autre chose. Personnellement, je n' aime pas vraiment penser en termes de pixels, notamment parce qu'il peut s'agir simplement d'actifs fictifs Et si vous décidiez de créer ce jeu en utilisant un pack d'actifs différent utilisant des tuiles de 64 pixels au lieu de 32 pixels ? Désormais, tous vos mécanismes ne fonctionneront plus de la même manière, et chaque valeur doit être ajustée pour correspondre à la nouvelle taille en pixels de vos actifs. Je préfère plutôt penser à ma mécanique en unités de tuiles par seconde, en pixels par seconde. Il s'agirait d'une valeur constante à l' échelle du projet, laquelle de nombreux scripts différents auront besoin d'un accès rapide et facile. Pour cela, nous pouvons créer un nouveau dossier de scripts appelé chargement automatique, puis créer un nouveau script dans ce dossier appelé global. Ce script n'a pas besoin d'exécuter de code. Il ne sera utilisé pour contenir des variables que lorsqu'elles sont utilisées par l'ensemble du projet. Comme celui-ci, nous pouvons déclarer notre variable dans ce script, PPT ou pixels par vignette. Il s'agit d'un entier, un nombre sans décimales, dont la valeur sera 32 Mais comment les autres scripts accèdent-ils à cette valeur ? Ouvrez les paramètres du projet et passez à l'onglet de chargement automatique. Il s'agit d'une liste de scripts qui seront automatiquement chargés démarrage de votre jeu et y resteront jusqu'à sa fermeture. peuvent également y accéder par Tous les autres scripts peuvent également y accéder par leur nom de nœud. Cliquez sur l'icône du dossier pour ouvrir un navigateur et trouver votre script global. Le nom du script sera utilisé pour générer automatiquement le nom du nœud. Cliquez sur le bouton Ajouter et ajoutez-le à la liste des nœuds chargés automatiquement dans le script de caractères. Nous pouvons ajuster les valeurs de nos nouvelles variables à définir en unités de tuiles plutôt qu'en pixels. À mon avis, il est plus logique que le personnage se déplace à une vitesse de huit tuiles par seconde, plutôt que de 300 pixels par seconde. Si je choisis de passer à un pack d'actifs utilisant des tuiles de 64 pixels, tous mes mécanismes fonctionneront toujours de la même manière. Tout ce que j'aurais besoin de changer, c'est la seule valeur du script de chargement automatique global. Si vous préférez utiliser les pixels comme unité principale, n'hésitez pas à continuer. Lorsque nous commençons notre jeu. Cado exécutera automatiquement une méthode sur chaque nœud lorsqu'il sera prêt, nommée à juste titre underscore Dans cette méthode, nous multiplions simplement chacune de ces valeurs par point global pour les convertir en unités de pixels. Notre personnage accélère et court désormais de façon plus réaliste Dans la prochaine leçon, nous allons améliorer les mécanismes du saut et de la gravité. Je te verrai dans la prochaine leçon. 18. 2 4 Saut: Bonjour les amis. Dans la leçon précédente, nous avons amélioré les mécanismes de locomotion du personnage Dans cette leçon, nous allons apporter des ajustements similaires au saut et à la gravité du personnage. Si nous lançons la scène principale et essayons de sauter, vous verrez que le personnage saute très haut et flotte longtemps dans les airs Ça ne fait pas vraiment du bien de regarder le script du personnage. La vitesse de saut est une autre valeur constante arbitraire qui ne correspond pas vraiment à nos besoins. Définissons plutôt le saut de nos personnages en fonction du nombre de tuiles qu'ils devraient être capables de sauter. Il s'agira d'une variable privée exportée nommée hauteur de saut soulignée de type float Et j'utiliserai une valeur par défaut de 2,5, bien que ce ne soit pas tout à fait réaliste. Cela permet au joueur de sauter au sommet d' une plate-forme sous laquelle il peut également choisir de marcher. Nous devons également multiplier ce chiffre par le bt mondial. Dans la méthode prête, avant le début du jeu, nous devrons calculer la vélocité dont le personnage aura besoin pour atteindre cette hauteur de saut. Nous pouvons remplacer la constante de vitesse de saut par une variable privée pour conserver cette valeur. Comme il sera calculé au moment de l'exécution, il n'est pas nécessaire de l'exporter. Ce calcul peut être ajouté à la méthode prête. Deuxièmement, la vitesse de saut peut être calculée en utilisant la racine carrée de la hauteur de saut multipliée par la gravité multipliée par deux. On ne peut pas utiliser la racine carrée sur un nombre négatif, il doit être positif. Heureusement, dans deux jeux en D, l'axe y est inversé. La gravité est déjà exprimée sous forme de valeur positive. Cependant, notre résultat pour la vitesse de saut est également un nombre positif. Par conséquent, nous devons multiplier par moins un pour que le personnage saute vers le haut, pas vers le bas. Nous pouvons maintenant modifier la méthode de saut pour utiliser cette nouvelle variable. Si nous le testons, le personnage sautera exactement 2,5 tuiles de haut lorsque nous appuierons sur le bouton de saut, mais le saut est toujours lent et flottant. Pour résoudre ce problème, nous pouvons ouvrir les paramètres du projet et modifier la valeur de la gravité. Soit en filtrant les paramètres soit en cliquant sur Physics Two D, nous pouvons trouver le réglage de gravité par défaut. Ce paramètre est défini sur 980 pixels par seconde au carré. Je vais plutôt taper le calcul directement dans le champ commençant par 9,8, qui correspond à la gravité sur Terre, multiplié par la taille du carreau de 32 pixels, puis multiplié par huit, me donne une valeur de 2508 0,8 qui me donne une valeur de 2508 0,8, soit environ 2,5 fois ce qu'elle était Cela rendra tout le jeu plus lourd et tombera plus rapidement, ce qui semblera plus réaliste au joueur. Maintenant, le saut est beaucoup plus agréable, mais j'aimerais donner au joueur la possibilité de contrôler la hauteur à laquelle le personnage saute Les jeux implémentent cette fonctionnalité de différentes manières, par exemple en mesurant la durée pendant laquelle le bouton de saut est resté enfoncé avant de le relâcher. ajoutez une force de saut initiale, une force supplémentaire à chaque image pendant une courte période après, etc., si vous faites mal, cela peut donner aux commandes frustrantes et cela peut donner aux commandes frustrantes insensibles ou donner aux personnages impression de porter un jet pack Ma solution préférée est très simple et très réactive pour le joueur. Empêchez simplement le joueur de se déplacer vers le haut lorsque le bouton de saut est relâché dans le script du personnage. Sous la méthode jump, nous pouvons ajouter une méthode stop jump. N'oubliez pas que l' axe y est inversé. Dans deux jeux en D, la valeur zéro pour Y se trouve en haut de l'écran et les valeurs positives se déplacent vers le bas. Si la vélocité y des caractères est inférieure à zéro, ce qui signifie qu'ils se déplacent vers le haut, nous pouvons la régler à zéro pour les empêcher de monter. Ensuite, la gravité commencera à se déplacer vers le bas. Le joueur percevra cela comme un contrôle son saut Ppe en maintenant le bouton de saut enfoncé et en le relâchant. Il suffit d'appeler cette nouvelle méthode depuis le script du lecteur. Lorsque le joueur relâche le bouton de saut, si l'événement est déclenché par une action, sautez, puis le personnage arrête de sauter. Essayons-le maintenant. Nous pouvons facilement contrôler la hauteur à laquelle le personnage saute en relâchant le bouton de saut avant qu'il n' atteigne son sommet maximum C'est facile à mettre en œuvre et efficace pour que le joueur ait sentiment d' avoir le contrôle total. La dernière chose que je veux aborder dans cette leçon est que le joueur a autant de contrôle sur les mouvements du personnage dans les airs qu'au sol. réalité, il n'y aurait pas de contrôle aérien pendant le Mais dans la plupart des jeux vidéo, le contrôle aérien existe pour permettre au joueur de garder le contrôle du personnage. Il peut être particulièrement utile dans les jeux de plateforme pour permettre au joueur d'éviter les pièges ou rediriger ses attaques vers des plateformes certain contrôle aérien peut être une bonne chose, mais cela ne devrait pas être la même chose qu'un mouvement au sol. Pour ajouter un contrôle aérien plus spécifique à notre personnage, nous pouvons définir une autre variable exportée en haut du script en tant que type float et lui donner une valeur par défaut de 0,5. Il suffit de la multiplier par accélération lorsque le joueur ne touche pas le sol. Pour simplifier la méthode des processus physiques, divisons-la en deux méthodes distinctes, la physique et la physique du sol. Ces deux méthodes peuvent être privées dans le processus physique. Si le personnage est au sol, appliquez la physique du sol, sinon appliquez la physique de l'air. Procédez ensuite au déplacement et au glissement. La physique du sol ne changera pas par rapport à ce que nous avons déjà dans la méthode de physique de l'air. Si la direction n'est pas nulle, nous pouvons déplacer la vitesse x vers la vitesse multipliée par la direction à un taux d' accélération multiplié par le temps de contrôle aérien par le delta. Cela permettra toujours au joueur d'avoir un certain contrôle dans les airs, mais réduit de moitié. Séparons ces variables de celles ci-dessus en exportant également les catégories correspondantes. Ces variables seront exportées dans la catégorie de saut. Les variables ci-dessus seront exportées dans la catégorie locomotion. Essayons-le. Comme pour les autres variables, vous pouvez ajuster la valeur et voir ce que cela vous fait du bien. Notre personnage saute et tombe désormais plus réaliste et avec un meilleur contrôle pour le joueur Dans la leçon suivante, nous allons animer le personnage en fonction de ses mouvements Je te verrai dans la prochaine leçon. 19. Animation 2 5: Bonjour les amis. Dans la leçon précédente, nous avons amélioré la perception générale des mécanismes de saut du personnage et avons donné au joueur un meilleur contrôle de la hauteur et de la trajectoire de ses sauts. Dans cette leçon, nous allons ajouter des animations à la scène du personnage, ouvrir la scène du personnage et obtenir une bonne vue du personnage. Tout d'abord, faisons en sorte que le personnage face à la direction dans laquelle il se déplace. Si vous sélectionnez le nœud Sprite Two D et que vous regardez dans l'inspecteur, développez la section de décalage sous le sprite Two D. La propriété que nous voulons modifier est flip H. cliquez horizontalement sur la case à cocher, nous pouvons voir que le sprite Le passage de la souris sur le nom nous indique comment accéder à cette propriété Dans notre script, le nom de la propriété est flip underscore H, ouvre le script de caractère Nous avons créé des méthodes pour le visage gauche et le visage droit, mais nous ne les avons pas encore utilisées. Il suffit de modifier la valeur de la propriété flip H du nœud Sprite Two D. Nous pouvons obtenir une référence au nœud en D du sprite en haut du script en utilisant at on ready var, nous l'appellerons underscore Ce sera du type sprite deux D. Ensuite, attribuez à cette variable la valeur du signe dollar sprite deux D. Quel que soit le nœud ce script de caractère est attaché, il recherchera dans les nœuds enfants un nommé sprite deux D et l' attribuera à N'oubliez pas que pour que ce script fonctionne comme prévu, chaque personnage que nous créons doit avoir un nœud enfant nommé sprite two D. Sinon, cette variable ne contiendra aucune valeur Maintenant, dans les méthodes face gauche et face droite, nous pouvons utiliser cette référence au sprite two D pour modifier la propriété flip H. Si le caractère est orienté vers la gauche, la propriété flip H doit être vraie. S'ils font face à droite, cela devrait être faux. Mais ces fonctions ne sont appelées nulle part. Le meilleur endroit pour les appeler serait au début du processus de physique. Peu importe que le personnage soit au sol ou dans les airs. Après tout, si le sinus de direction est négatif, le caractère doit être orienté vers la gauche. Si le sinus de direction est un, le personnage doit être orienté vers la droite. Nous n'avons rien à faire si le sinus de direction est nul. Maintenant, lorsque nous lançons la scène principale, le personnage sera orienté dans le sens de la saisie du joueur. C'est un bon début, mais commençons également à travailler sur l' animation du personnage Cliquez avec le bouton droit sur le nœud Sprite Two D dans l'arborescence de la scène et ajoutez un nœud enfant Le nœud que nous devons rechercher est un nœud de lecteur d'animation. Ce nœud nous permettra de modifier certains aspects du personnage au fil du temps, en particulier la texture du sprite L'ajout de ce nœud ouvrira automatiquement le panneau d'animation en bas de la fenêtre de l'éditeur. Cliquez sur le bouton d'animation, puis sur Nouveau nom, la nouvelle idole de l'animation. Vous pouvez maintenant voir une chronologie dans le panneau d'animation. Chaque aspect du personnage modifié par l'animation sera répertorié dans cette chronologie. Cliquez sur le bouton plus pour ajouter une nouvelle propriété à l'animation. La propriété que nous devons modifier est la texture du sprite à deux ts. Afin de marquer les positions dans la chronologie où le sprite va changer Nous pouvons ajouter une image-clé en cliquant avec le bouton droit sur la piste des propriétés et en sélectionnant Insérer une clé Une fois qu'une image-clé est ajoutée à la chronologie, nous pouvons facilement la déplacer En cliquant et en faisant glisser, si ce n'est pas au bon endroit. En cliquant sur une image clé, nous pouvons définir sa valeur dans l'inspecteur. Le sprite 01 inactif est déjà renseigné dans le champ de texture Comme il s'agit de sa valeur actuelle, je pense que ces actifs sont les plus beaux. Avec une fréquence d'images de dix images par seconde, je voudrais changer la texture du sprite tous les dixièmes de seconde, ce qui signifie que la durée totale de l' animation sera de 0,5 seconde. La chronologie affiche actuellement 15 secondes, ce qui rend difficile de ne modifier que le premier segment de l'ensemble de la chronologie. Zoomons en utilisant le curseur en bas à droite jusqu'à ce que nous puissions facilement voir toutes les 0,1 secondes sur la chronologie Ajoutons donc quatre images-clés supplémentaires et remplissons chacune d'elles avec les sprites restants Pour ce faire, nous devons réduire la durée de l' animation actuellement fixée à 1 seconde à 0,5 seconde. Nous voulons que cette animation soit en boucle. Cliquez sur le bouton Animation Looping sur la droite. Nous pouvons prévisualiser cette animation en cliquant sur l'icône Play en haut du panneau d'animation. Ça a l'air plutôt bien. Ensuite, nous devons exécuter l'animation. Cliquez sur le bouton d'animation et sélectionnez Dupliquer. Nommez ensuite la nouvelle séquence d'animation. En élargissant le dossier de ressources qui contient l'animation d' exécution, nous pouvons voir qu'il contient six sprites Nous devrons étendre la durée de l'animation à 0,6 seconde et ajouter une autre image clé. Remplissez ensuite chaque image clé avec les sprites appropriés dans l' ordre. Lorsque vous avez terminé, prévisualisez l'animation pour vous assurer qu'elle est belle Répétez le processus trois fois de plus pour créer les animations pour le saut, la chute et le sol. Faites attention à la durée de chaque animation en fonction du nombre de sprites fournis dans le pack d'actifs Cependant, ces animations ne sont pas destinées à fonctionner en boucle, alors assurez-vous de désactiver la boucle pour celles-ci. Les animations de nos personnages sont maintenant toutes configurées. Dans la leçon suivante, nous allons créer une machine à états pour synchroniser les animations avec ce que fait le personnage. Je te verrai dans la prochaine leçon. 20. 2 6 State Machine: Bonjour les amis. Dans la leçon précédente, nous avons configuré des animations pour les mouvements de nos personnages. Dans cette leçon, nous allons implémenter ces animations et les synchroniser avec le comportement du personnage. Mais avant cela, ajoutons rapidement un autre nœud à la scène principale. Une caméra à deux nœuds D. Cela nous aidera à obtenir rapidement une meilleure vue de notre personnage puisque nous pouvons repositionner et le zoomer en modifiant ses propriétés dans l'inspecteur Maintenant, lorsque nous effectuerons des tests sur scène, nous aurons une meilleure vue des résultats de ces animations. Maintenant, pour implémenter les animations, nous allons ouvrir la scène du personnage et ajouter un autre nœud enfant au lecteur d'animation. Ce nœud est appelé arbre d'animation. Le nœud de l'arbre d'animation nous envoie un avertissement, aucun nœud d'animation racine n'est défini pour le graphe. Dans le panneau de l'inspecteur, il y a un champ intitulé Anim player En cliquant à l'endroit où il est indiqué un signe, nous pouvons sélectionner le lecteur d'animation créé dans la leçon précédente. Le but de cet arbre d'animation sera de contrôler quelle animation est jouée à un moment donné. À l'aide de la liste déroulante intitulée « racine de l'arbre » sélectionnez la nouvelle machine d'état du nœud d'animation. Cela ouvrira la machine à états nouvellement créée dans le panneau de l'arbre d'animation en bas de la fenêtre de l'éditeur. Avant de commencer à modifier la machine à états, examinons toutefois le dossier des actifs de notre personnage. Les animations sont divisées en deux dossiers étiquetés avec épée et sans épée. Le contenu de chacun de ces dossiers est constitué des mêmes animations, l' exception du personnage tenant une épée. Ou afin d'éviter des efforts inutiles, je vais planifier à l'avance la structure de cet arbre d' animation afin fonctionnalités qui ne seront implémentées que plus tard dans le cours Pour commencer à utiliser notre machine à états, nous allons d'abord cliquer avec le bouton droit sur un espace vide dans le panneau de l'arborescence d'animation et sélectionner Ajouter une machine à états. Alors nommez cette nouvelle machine d'État sans épée. Nous pouvons également le refaire et créer une autre machine d'État nommée With sword. Nous pouvons ensuite cliquer sur le bouton de transition dans le coin supérieur gauche et ajouter une transition du début vers le mode sans épée. Désormais, lorsque le jeu démarre pour la première fois, l'arbre d'animation diffusera par défaut des animations pour notre personnage sans l'épée. Nous pouvons ignorer la machine à états d'épée pour le moment, revenir en mode sélection et cliquer sur l'icône en forme de crayon pour ouvrir la machine à états sans épée afin de la modifier. À l'intérieur de la machine à états, nous pouvons créer une autre machine à états nommée mouvement. Ajoutez ensuite la transition du début au mouvement par défaut. Cette couche de l'arbre sera utilisée ultérieurement dans un autre but. Ouvrez à nouveau la machine à états de mouvement pour la modifier. Créez une autre machine à états, cette fois nommée locomotion, et créez une transition entre le début et la locomotion Ouvrez ensuite la machine d' état de locomotion pour la modifier. Enfin, nous pouvons ajouter des animations à la machine à états. Cliquez avec le bouton droit sur Ajouter une animation, puis passez au ralenti et répétez l'opération pour ajouter une exécution. Créez une transition entre le mode démarrage et le mode veille pour en faire l'animation par défaut. Ajoutez ensuite une transition de idle à run et de run back à idle. Le but de cette machine à états sera de changer l'animation entre ces deux états. Nous pouvons définir les conditions dans lesquelles ces transitions se produiront en cliquant dessus, puis en les éditant dans l'inspecteur la transition entre inactif et exécution, développant la section avancée et en sélectionnant la zone de texte de l' expression. L'expression saisie dans cette zone de texte doit produire une valeur booléenne, vraie ou fausse La condition dans laquelle nous voulons que le personnage passe de l'état inactif à l'état de course est si la vélocité n'est pas nulle. De même, la condition pour passer de l'état d'exécution au mode veille sera que la vélocité x soit égale à zéro Nous devons également indiquer à l'arbre d'animation quel nœud contrôle ces expressions avancées. Sélection de l'arbre dans l'arbre des scènes. Ensuite, en regardant dans le panneau de l' inspecteur, nous pouvons remplacer le champ de base de l' expression avancée par le nœud racine du personnage. Nous pouvons maintenant exécuter la scène principale et voir l'arbre d'animation fonctionner. Basculer l' animation du personnage entre le mode veille et le mode exécution en fonction de la vélocité x du personnage. Pour intégrer le reste des animations. Retournez au panneau de l'arborescence des animations et accédez à la couche de mouvement de la machine à états. Cliquez avec le bouton droit pour ajouter les animations de saut, de chute et de sol pour créer des transitions entre locomotion, saut pour chute, chute au sol, sol vers locomotion et locomotion Ensuite, nous pouvons définir les conditions de chacune de ces transitions. L'animation des personnages doit changer pour sauter si leur vélocité y est inférieure à zéro, puis passer en mode chute si leur vélocité devient supérieure ou égale à zéro, puis en mode sol s'ils sont au sol. Comme il s'agit d'une méthode intégrée du nœud à deux corps de caractères, nous pouvons y accéder et elle renvoie une valeur booléenne n'y a aucune condition pour passer du sol à la locomotion Développez plutôt la section du commutateur et sélectionnez la fin dans la liste déroulante. Cela permettra de terminer l'animation au sol avant de passer à la locomotion, mais n'imposera aucune autre condition Enfin, si le joueur sort d'un rebord, nous voulons que l'animation passe de la locomotion à la chute Ce sera vrai si ce n'est pas le cas au sol. Mais les transitions entre la locomotion et le saut et la chute seront toutes deux vraies à chaque fois que le joueur saute Nous pouvons donner la priorité au saut en modifiant sa priorité 1-0 en revenant à la scène principale et en exécutant la scène en cours. Nous pouvons maintenant voir l'arbre d'animation à l'œuvre, car il fera automatiquement passer le personnage entre les différents états. Nous avons maintenant les mouvements de base du personnage animés. Dans la leçon suivante, nous allons ajouter la poussière et des effets sonores à certaines de ces animations. Je te verrai dans la prochaine leçon. 21. 2 7 effets: Bonjour les amis. Dans la leçon précédente, nous avons utilisé une machine à états pour synchroniser l' animation des personnages avec leur comportement. Dans cette leçon, nous allons ajouter des effets sonores et visuels pour peaufiner les animations. En commençant par la scène du personnage, ajoutons un nouveau nœud, un sprite animé en deux D, et renommons-le en particules de poussière Un avertissement nous indique que nous devons créer une ressource Sprite Frames pour que ce nœud fonctionne avec le nouveau nœud sélectionné En regardant dans l'inspecteur, développez la section d'animation. En cliquant sur le menu déroulant intitulé Sprite Frames, sélectionnez de nouveaux sprites Frames, puis cliquez sur la ressource Sprite Frames pour l'ouvrir afin de la modifier, qui apparaîtra en bas de la fenêtre de l' Ici, nous pouvons voir une animation de sprite nouvellement créée nommée Default, avec une fréquence d'images de cinq images par seconde Dans le panneau du système de fichiers, parcourez le pack de ressources pour trouver le groupe de dossiers sur les particules de poussière, sélectionnez les sprites automnaux et faites-les glisser dans la zone des images d'animation En appuyant sur play pour prévisualiser l'animation, nous pouvons voir à quoi elle ressemblera. Nous ne voulons pas que cette animation soit en boucle, désactivez-la en faisant cuire le bouton de boucle de l'animation Développez la section de décalage et ajustez le décalage y jusqu'à ce qu'il soit au même niveau que l'axe X rouge, qui sera notre sol. Il est important d'utiliser le champ de décalage et non la position des transformations afin de faire apparaître les particules sur le sol. Je vais également modifier la fréquence d'images pour qu'elle corresponde aux animations de mes personnages, qui avaient une fréquence d'images de dix images par seconde. Maintenant, lorsque nous appuyons sur Play, l' animation ne sera jouée qu'une seule fois. Et nous pouvons voir à quoi cela ressemblera dans le jeu par rapport au personnage. Le but de cette animation sera de jouer une fois lorsque le personnage atterrira au sol et de disparaître une fois l'animation terminée. Ces types d'effets sont plus beaux lorsqu' ils existent indépendamment du personnage, comme si la poussière faisait partie du monde et ne devait pas suivre le personnage partout. Faisons un clic droit sur le nœud de particules de poussière et enregistrons cette branche comme scène à part entière. Cela n'appartient vraiment à aucun de nos dossiers existants. Créons-lui un nouveau dossier nommé dust. Nommez cette scène en particulier, la poussière d' automne qui cuit sur le clapet, l'icône dans l'arbre des scènes Nous pouvons ouvrir la scène de poussière automnale afin de faire disparaître les particules. Une fois l'animation terminée, nous devrons joindre un script au nœud racine, en cliquant sur le bouton du script publicitaire pour nommer le nouveau script dust. Nous n'avons pas besoin d'utiliser les modèles par défaut. Décochez la case du modèle et assurez-vous que le script est enregistré dans le dossier des scripts Cela démarrera le script en prolongeant simplement sprite animé de deux lignes D en haut Mais avant d' écrire du code avec le nœud 2D du sprite animé sélectionné, examinez le panneau d'inspection et passez au panneau des nœuds Les signaux doivent être sélectionnés par défaut. Il s'agit d'une liste de signaux que le nœud peut utiliser pour déclencher des comportements dans son propre script ou dans d'autres scripts. Nous pouvons utiliser le signal de fin d'animation pour savoir quand l' animation est terminée. Et lancez une méthode dans notre script. Cliquez avec le bouton droit sur l'animation terminée. Connectez-vous pour ouvrir une nouvelle fenêtre. Assurez-vous que les particules de poussière sont sélectionnées comme destinataires du signal. Cliquez ensuite sur Connecter. Vous remarquerez que Do a automatiquement généré une méthode dans le script qui sera déclenchée lorsque l' animation sera terminée. Une icône de connexion verte apparaît à gauche de la déclaration de méthode pour nous indiquer que cette méthode est déclenchée par un signal. Toujours dans l'arbre des scènes, l'icône du signal est affichée à côté du nœud de particules de poussière pour nous indiquer que ce nœud dispose d'une connexion de signal. La seule chose que nous devons faire dans le script lorsque l' animation est terminée, c'est dire au moteur que nous en avons terminé avec ce nœud et qu'il peut être supprimé. Cela se fait à l'aide d'une méthode intégrée appelée free. Nous voulons également indiquer au script de jouer automatiquement l'animation lorsqu' elle est ajoutée à la scène. remplaçant la méthode underscore ready, nous pouvons simplement appeler lorsque ce nœud est ajouté à l'arbre, il ne jouera qu'une seule fois et se supprimera lorsqu'il Nous pouvons désormais dupliquer cette scène pour créer des scènes de particules de poussière similaires à celles des particules de saut et de course dans ces nouvelles scènes, et remplacer les sprites l'animation par les sprites appropriés du pack d'actifs Nous avons maintenant trois effets de particules de poussière différents que nous voulons générer dans des conditions différentes pour notre personnage, mais ils peuvent tous utiliser la même méthode. Pour en revenir à la scène du personnage, nous pouvons désormais supprimer le nœud de particules de poussière puisqu'il n'est pas censé faire partie de la scène. Passez ensuite en mode script et ouvrez le script du personnage. Ajoutons une nouvelle fonction privée appelée spawn dust, qui prendra un paramètre nommé dust Le type de ce paramètre sera une scène compressée nous permettant d'utiliser les scènes que nous venons de créer comme argument de la méthode. Nous devons d'abord instancier la scène, puis changer sa position pour qu'elle se trouve au même endroit que le personnage Ensuite, ajoutez-le à l'arbre de scène en obtenant d'abord le nœud parent du personnage, puis en ajoutant la poussière en tant que nœud enfant. En faisant de la poussière une sœur du personnage, elle existera dans le monde indépendamment du personnage et ne le suivra pas. Dès qu'il est ajouté à l'arbre de la scène, le sprite animé joue son animation par défaut, puis Q lui-même sera supprimé lorsque l'animation sera terminée une fraction de seconde plus tard Pour déclencher les particules de poussière de saut, nous pouvons appeler cette méthode directement à partir de la méthode de saut, en faisant passer la poussière de saut comme argument. Déclarez ensuite la poussière de saut en haut du script en tant que variable exportée de type scène compressée. Sélection du nœud racine du personnage et retour au panneau d'inspection. Nous pouvons ensuite le renseigner dans l'inspecteur en cliquant et en faisant glisser la scène dans le champ exporté les particules de course et de chute ne Dans notre script, les particules de course et de chute ne trouvent pas un endroit simple où elles peuvent être générées. Cependant, nous pouvons plutôt sélectionner le lecteur d'animation de notre personnage, ouvrir l'animation au sol et ajouter une nouvelle piste. Cette fois, il s'agit d'une piste de méthode d'appel. Ensuite, nous pouvons accéder au nœud racine du personnage et appeler la méthode spawn particles au début de l'animation En ajoutant une image-clé. La sélection de l'image clé nous permettra de transmettre des arguments à la méthode que nous pourrons ensuite renseigner. En cliquant et en faisant glisser la poussière qui tombe. Nous pouvons faire la même chose avec les particules de poussière de course, en les ajoutant à l'animation de course. N'oubliez pas que l' animation s'exécute en boucle, nouvelles particules apparaissent donc à chaque fois que l' animation tourne en boucle En ce qui concerne les particules qui tombent et sautent, peu importe la direction dans laquelle le personnage fait face. Mais pour ce qui est des particules de course, il est important qu'elles semblent se déplacer derrière le personnage. Nous pouvons définir la propriété animée de Steph pour qu'elle corresponde à celle du personnage au moment de sa création Essayons-le. La course crée de la poussière toutes les 0,6 seconde de fonctionnement continu. saut et l'atterrissage créent également leurs propres nuages de poussière uniques. Pour peaufiner encore, nous pouvons également ajouter des sons à nos pistes d'animation, revenir à la scène du personnage et ajouter un nouveau nœud à l'arbre des scènes, un lecteur de flux audio en deux nœuds D. Avec ce nœud dans l'arborescence, nous pouvons maintenant ouvrir l'animation du saut et ajouter une nouvelle piste de lecture audio. Sélection du nœud du lecteur de flux audio comme cible. Placer une image-clé au début de l'animation. Nous pouvons ensuite remplir cette image-clé avec un flux audio. Parcourez les sons fournis dans les sons de combat fournis par Luke Sharps. Il existe quelques sons appropriés parmi lesquels choisir qui correspondent parfaitement à ce personnage. Importez les sons que vous aimez et placez-les dans un dossier d'effets sonores désigné pour organiser votre projet. Remplissez ensuite votre image-clé d'animation en conséquence. Pour que l'animation de la course passe en boucle sur le son des chaussures. Assurez-vous de modifier le décalage de début et le décalage de fin pour sélectionner un échantillon plus court que l'animation. Essayons-le maintenant. Le personnage émet un grognement lorsqu'il saute, un bruit d'impact lorsqu'il atterrit et des bruits de pas Tout au long de cette première section du cours, nous avons créé un personnage entièrement animé avec des effets audio et visuels et des mécanismes de plateforme amusants Dans la section suivante, nous allons commencer à travailler sur la création de niveaux pour notre jeu. Nous vous verrons dans la section suivante. 22. 2-1 Tilemap: Bonjour les amis. Dans la dernière section, nous avons créé un personnage entièrement animé avec des mécanismes de plateforme Si vous avez terminé la mission, vous devriez maintenant avoir un casting complet de quatre personnages. Et nous aurons découvert que vous pouvez dupliquer le nœud du joueur pour contrôler plusieurs personnages simultanément. Si vous parvenez à relever le défi intermédiaire, vous aurez également accès à des scripts d'IA contrôlant un ou plusieurs personnages. Avec le défi le plus avancé, vous aurez probablement tous les nœuds du personnage, enfant au nœud joueur, où le personnage est contrôlé, pouvant être changés en appuyant sur un bouton. Dans cette section, nous allons créer un niveau pour notre jeu. Notre première leçon, nous allons commencer par construire un terrain plat. Ajoutez un autre nœud à la scène principale. Le nœud que nous recherchons cette fois est la carte des tuiles. Une carte de tuiles nous permettra d' ajouter et de modifier rapidement des sprites dans notre niveau, qui seront organisés en tuiles d'une taille spécifique Pour qu'une carte en tuiles fonctionne, elle a besoin d'un jeu de tuiles. Comme vous pouvez le voir dans le menu déroulant de l' inspecteur, étiquetez le jeu de tuiles, sélectionnez un nouveau jeu de vignettes, puis cliquez sur la ressource du jeu de tuiles pour l'agrandir, exposant ainsi certains champs dont nous aurons besoin pour modifier nos vignettes sont carrées. Mais vous pouvez constater qu'il existe un certain nombre d'autres options pour faciliter le travail avec d'autres formes de carreaux. La première chose que nous devons changer est la taille des carreaux. La taille des vignettes du pack de ressources que j' utilise est de 32 pixels en largeur et en hauteur. Il est important de définir cette propriété avant d'ajouter des tuiles au jeu de tuiles. Comme nous utilisons cette carte en tuiles pour le terrain, nous devrons également ajouter une couche physique pour les collisions. Un ensemble de terrains facilitera grandement la modification du terrain. Le kit de terrain peut contenir plusieurs terrains. Nous devons ajouter un terrain à l'ensemble de terrains. Vous pouvez considérer chaque terrain comme un biome ou un matériau de construction différent Nommons cette première île de terrain. Chaque type de terrain peut être associé à une couleur différente pour les distinguer les uns des autres. Comme nous n' allons utiliser qu' un seul type de terrain pour le moment, nous pouvons simplement utiliser la couleur par défaut. Cette couleur ne sera pas utilisée dans le jeu uniquement lorsque nous modifierons le terrain. C'est uniquement dans notre intérêt en tant que développeur. fois ces modifications apportées, nous pouvons porter notre attention sur le bas de la fenêtre de l'éditeur où un nouvel onglet s'est ouvert pour la carte en tuiles. Le message nous indique que nous devons d'abord configurer un jeu de vignettes en passant à l' onglet jeu de vignettes en bas. Ici, nous pouvons ajouter les tuiles fournies dans le pack d'actifs à cet ensemble de tuiles. Soit en cliquant sur le bouton plus, soit en cliquant sur le fichier image et en le faisant glisser depuis le système de fichiers Le code d'onglet proposera de créer automatiquement des vignettes pour nous. Sélectionnez Oui. Si vous êtes sûr d'avoir correctement défini la taille de la vignette , sélectionnez non dans le cas contraire. Les carreaux devraient maintenant être plus clairs et avoir une bordure orange. La sélection de l' outil d'effacement vous permettra de supprimer les vignettes du jeu de tuiles en cliquant dessus. De même, la désactivation de l'outil d'effacement vous permettra d'ajouter des vignettes au jeu de vignettes en cliquant dessus. Pour revenir à l'onglet Carte des tuiles, nous pouvons maintenant sélectionner et dessiner n'importe quelle tuile du jeu de tuiles dans la vue en deux D Pour faciliter les choses, Goode fournit une grille orange correspondant à la taille des tuiles L'éditeur de cartes à carreaux fournit également tous les outils habituels pour sélectionner les lignes de peinture, les rectangles et le remplissage des seaux Vous pouvez également déposer des vignettes, les sélectionner, les effacer, les faire pivoter, les retourner ou les répartir de manière aléatoire Créez un sol de base, placez votre personnage dessus et positionnez la caméra pour voir les résultats. Puis joue la scène. Vous remarquerez qu'il n'y a pas encore de collision sur le terrain. Revenez à l'onglet du jeu de vignettes. Passez en mode sélection et sélectionnez en groupe toutes les vignettes en cliquant dessus et en les faisant glisser Ajoutons d'abord la collision à nos tuiles en développant la section physique. Ensuite, couche physique zéro. Cet outil vous permettra de créer des formes de collision complexes pour chaque tuile, mais nous n'avons besoin que de carrés de base. En cliquant sur l'icône en forme d'ellipse, sélectionnez Rétablir la forme de tuile par défaut ou appuyez sur la touche pour que la forme de collision corresponde simplement à que la forme de collision corresponde simplement la forme des carreaux carrés Désormais, toutes nos tuiles vont entrer en collision, tout comme l'icône Codell nous utilisions comme plancher de scène C'est génial, mais créer des niveaux en remplissant des tuiles individuelles sur la carte des tuiles sera extrêmement fastidieux Heureusement, Godel fournit un éditeur de terrain très facile à utiliser Passez en mode peinture. Cela nous permet de peindre les propriétés sur les carreaux. La propriété que nous voulons peindre est la propriété du terrain. Particulièrement en terrain nul, le terrain insulaire. Vous souhaiterez peut-être agrandir le panneau ou zoomer sur la zone des vignettes. Pour cette partie, chaque tuile est divisée en neuf petits carrés que l'on peut peindre à la couleur du terrain en cliquant ou en effaçant en cliquant avec le bouton droit de la souris. Chaque tuile faisant partie de ce terrain doit avoir son carré central rempli. Pour que l' éditeur de terrain fonctionne comme prévu, nous devons peindre les bords de chaque tuile destinée à être dessinée à côté d'une autre tuile. Lorsque vous aurez terminé, il ne devrait y avoir aucun doublon dans ce jeu de vignettes Chaque carreau doit avoir un motif unique. Revenez à l'onglet Carte en tuiles. Passez à l' onglet terrains en haut de la page. Et notre terrain insulaire devrait être répertorié comme une option, en sélectionnant toutes les tuiles du jeu de tuiles répertoriées, ainsi que deux options supplémentaires, mode continu et le mode trajectoire. Sélectionnez le mode continu, puis dessinez librement le terrain dans la vue en deux D en cliquant et effacez en cliquant avec le bouton droit de la souris Chaque tuile se connectera automatiquement correctement à ses tuiles adjacentes. Vous devriez être capable de dessiner un terrain de n'importe quelle forme imaginable et les tuiles appropriées seront automatiquement sélectionnées pour chaque position de tuile. S'il y a des incohérences, vérifiez la présence d'erreurs dans la peinture des propriétés du terrain Grâce à cet outil, nous pouvons rapidement et facilement générer le terrain pour chaque niveau de notre jeu. Nous avons maintenant un terrain de base dans notre jeu que nous pouvons utiliser pour construire les bases de nos niveaux. Dans la leçon suivante, nous ajouterons de la végétation décorative pour rendre l' environnement plus vivant. Je te verrai dans la prochaine leçon. 23. 2-2 décorations: Bonjour les amis. Dans la dernière leçon, nous avons configuré le terrain de base avec les collisions et l'édition du terrain. Dans cette leçon, nous allons ajouter quelques décorations à notre terrain pour le rendre plus intéressant. Comme pour la carte de tuiles, passez à l'onglet jeu de tuiles en bas de la fenêtre de l'éditeur. pack de ressources contient un autre graphique du jeu de tuiles qui appartient à ce jeu de carreaux nommé front, palm, bottom et grass. Ajoutons cela à l'atlas. Ces éléments décoratifs ne nécessitent pas vraiment de modification physique ou de terrain. L'herbe peut simplement être dessinée sur des zones aléatoires autour de votre niveau où vous pensez qu'elle sera belle. Les racines, cependant, sont destinées à être dessinées sur des dalles de terrain. Mais si nous essayons de le faire, cela remplacera plutôt le terrain. Pour ce faire, nous devons ajouter une autre couche à notre carte de tuiles pour ces racines. En sélectionnant la carte de tuiles dans l'arbre des scènes, nous pouvons réduire la ressource du jeu de tuiles et agrandir la section des couches. Nous avons ici une couche qui n'a pas de nom. Nommons cette couche terrain, puis cliquez sur le bouton Ajouter un élément, Ajouter une autre couche, et nommons cette couche racines Pour que cette couche soit dessinée devant le terrain, nous pouvons modifier l'indice z en l'augmentant à un. Comme le terrain se trouve sur la couche zéro, les racines de la première couche seront toujours dessinées par-dessus. La liste déroulante en haut à droite de l'onglet de la carte en tuiles contient désormais nos deux couches différentes. Cela nous permet d'ajouter des tuiles racines à la couche racine, que nous pouvons ensuite peindre par-dessus les tuiles de terrain de la couche de terrain. Lorsque chaque couche est modifiée, elle apparaît en couleur, tandis que toutes les autres couches sont estompées Mais ces racines ont également besoin d'arbres. Construisons également les arbres. Si vous voulez que les arbres entrent en collision et soient des objets immobiles agissant comme du terrain, le type de nœud le plus approprié à utiliser serait un corps statique en deux D, que nous appellerons Palm Tree Il s'agit du même type de nœud que celui que nous avons utilisé à l'origine pour l'icône Godot Ce nœud peut toujours avoir des collisions, mais il ne sera pas déplacé par des collisions avec d'autres objets. Il restera statique. Cet arbre comportera une animation. Ajoutons donc un sprite animé, deux D comme nœud enfant du palmier Créez une ressource de cadres de sprite pour le sprite animé. Ouvrez ensuite la ressource pour la modifier. Cliquez sur les images du palmier et faites-les glisser dans l'animation. Modifiez la fréquence d'images et appuyez sur Play pour prévisualiser l'animation. Ça a l'air bien. Assurons-nous que cette animation s' exécute automatiquement par défaut en cliquant sur le bouton Autoplay en haut du panneau Enregistrez le nœud Palm Tree en tant que scène à part entière et trions-le scène à part entière et dans un nouveau dossier de scènes pour les décorations. Le palmier peut désormais être modifié de manière isolée, et toutes les modifications apportées à la scène du palmier s'appliqueront à toutes les copies du palmier le nœud du palmier est sélectionné, cliquez dessus et faites-le glisser pour le déplacer le niveau et le positionner au-dessus des racines. Nous pouvons vous faciliter la tâche en activant la capture de grille à l'aide du bouton situé en haut de la vue en deux D. Nous pouvons également configurer les options de capture en cliquant sur l'icône en forme d'ellipse. Vérifions-nous que les objets sont capturés sur des multiples de 32 pixels pour correspondre à la taille du carreau Mais le palmier ne veut pas s'aligner car l'origine de l' arbre se trouve en son centre. Pour que l'arbre s'aligne avec les tuiles, l'origine doit se trouver dans le coin qui sélectionne le sprite animé, à savoir deux nœuds en D. Ajustez le décalage pour que le sprite dessine 16 pixels, soit la moitié d'une tuile vers le bas, à droite de l'origine Désormais, le palmier peut facilement être déplacé pour correspondre aux tuiles du terrain. Le corps statique a besoin d'une forme de collision. Pour entrer en collision avec quoi que ce soit, nous devons ajouter un autre nœud enfant, une forme de collision, deux D. Pour rendre ce palmier plus intéressant Faisons également en sorte qu'il fonctionne comme une plate-forme sur laquelle le joueur peut sauter. Définissez la forme de collision comme une forme de segment en deux D, il s' agit simplement d'une ligne que nous pouvons modifier en déplaçant les deux points. Alignez le segment de ligne avec le sommet du palmier. Essayons-le. Il fonctionne comme une plate-forme, mais ce serait bien de pouvoir sauter par le bas au lieu de le percuter J'aimerais que le joueur ne passe pas trop loin du bord avant de tomber Réglage des paramètres de capture de grille à huit pixels ou à un quart de vignette Je vais faire en sorte que le segment de ligne ne couvre que la moitié de la longueur totale de la tuile. Si vous voulez que le joueur puisse passer par le bas de la plateforme et atterrir dessus. Il existe une implémentation intégrée simple pour ce comportement. Dans Godot, cochez simplement la case « collision unidirectionnelle  » dans deux D » de la forme de collision Cela dessine une flèche dans l'éditeur nous indiquant dans quelle direction la collision sera appliquée. C'est bien mieux. Maintenant, je peux sauter par le bas de la plateforme en forme de palmier et glisser hors du bord au lieu de me tenir debout sur une barrière invisible. Ce qui peut être gênant pour certains joueurs qui aiment particulièrement le style graphique pixelisé, c'est que le joueur n'est pas dessiné exactement sur les mêmes décalages de pixels Si je place le personnage à côté de l'herbe, vous pouvez voir que les pixels de mon personnage ne s' alignent pas toujours avec les pixels de l'herbe dans les paramètres du projet. Nous pouvons ajuster ces paramètres de rendu pour forcer toutes les images dessinées à l'écran à être dessinées aux coordonnées exactes en pixels, ce que les fans de pixel art préféreraient. Ces paramètres sont masqués par défaut. Cliquez sur le bouton des paramètres avancés sous Rendu. Une nouvelle option pour deux D est dévoilée. Nous avons ici des options pour convertir les transformations et les sommets Cela peut amener le joueur à curseur d'un pixel au-dessus du sol Si tel est le cas, réglez leur collisionneur de manière à ce qu' il repose proprement sur le sol Désormais, lorsque nous appuyons sur Play, le personnage et tous les autres éléments de notre jeu seront toujours dessinés en pixels. Nous avons maintenant de l'herbe et des palmiers animés qui décorent notre île parfaite au pixel près. Dans la leçon suivante, nous allons ajouter un script à notre caméra, qui suivra le joueur et nous permettra de créer des niveaux plus grands qu'un écran. Je te verrai dans la prochaine leçon. 24. Caméra 2-3: Oh, mes amis. Dans la leçon précédente, nous avons décoré notre île de végétation. Dans cette leçon, la caméra suivra le joueur tout au long du niveau. Le moyen le plus simple d' y parvenir serait de simplement adapter la caméra au joueur. Mais cette approche est très restrictive et peut provoquer le mal des transports. Les mouvements de caméra devraient être plus subtils et montrer au joueur ce qui attend son personnage. Si le personnage du joueur est dans la caméra en tant que frère et sœur, nous aurons besoin de la caméra pour réagir aux actions du joueur et avoir son propre comportement scénarisé en réponse Commençons par créer un nouveau script pour la caméra. Nous pouvons simplement l'appeler caméra et nous assurer qu'elle est enregistrée dans le dossier des scripts. Cette caméra devra savoir ce qu'elle suit. Exportons une variable privée que nous appellerons underscore subject n'est pas nécessaire que ce soit un corps de personnage deux D. Au lieu de cela, il peut s' agir de quelque chose de plus générique, comme un nœud deux D. Si vous regardez dans l'arbre des scènes, vous remarquerez que les nœuds ont des couleurs différentes, dont la plupart sont bleues. Ces nœuds bleus sont tous des nœuds deux D, mais sont des types plus spécifiques de nœuds deux D, y compris la caméra elle-même. Il y a deux personnages en D, deux corps statiques en D, deux sprites animés en D, etc. En sélectionnant l'un d' entre eux, vous verrez dans l'inspecteur qu'ils possèdent les propriétés étiquetées nœud deux D ainsi que la propriété de transformation qui contient leur position, rotation, leur échelle et leur inclinaison En réglant le type de notre sujet sur le nœud deux D, la caméra pourra suivre tout notre scène considéré comme un nœud deux D. Comme il suffit de savoir qu'il a une position permettant à la caméra de le suivre, cliquez et faites glisser le personnage du joueur dans le champ exporté pour notre sujet de caméra Dans la méthode de traitement, qui s' exécutera 60 fois par seconde, nous pouvons simplement régler la position de l'appareil photo sur celle du sujet. Ce seront les mêmes comportements que lorsque la caméra était enfant pour le personnage, sans mouvement vertical, ce qui réduira considérablement le mal des transports. Il serait cependant plus utile que le personnage ne soit pas centré dans le champ de vision de la caméra. Mais au lieu de cela, il doit regarder devant le personnage et légèrement vers le haut afin que le joueur puisse voir les parties les plus pertinentes du niveau. Comme pour les sprites animés, nous pouvons ajouter un décalage à notre script de caméra pour le décaler par rapport à sa position initiale Nous allons en faire une variable privée exportée, soulignement étant décalé par le type de vecteur deux Un vecteur deux contient deux flottants, une valeur x et une valeur y. Il est utilisé pour définir n'importe quoi en deux dimensions, y compris les variables de position avec lesquelles nous avons travaillé. Désormais, la méthode de traitement peut simplement ajouter la partie x du décalage à la position X de la caméra. Si nous positionnons le personnage exactement à l'origine de la scène, nous pouvons déplacer la caméra pour nous donner une idée de l'endroit où nous pensons qu'il sera le plus beau. Utilisez ensuite la position actuelle de la caméra comme valeur de décalage. Vous pouvez également définir le décalage dans tuiles et le multiplier par Google Ppt dans la méthode prête. La caméra va maintenant suivre le mouvement horizontal du joueur tout en regardant vers la droite. Mais que se passerait-il si nous ne voulions pas que nos niveaux soient aussi linéaires ? Et si le joueur veut aller à gauche ? La caméra doit également regarder vers la gauche du personnage. La caméra devra réagir à une action du personnage. Notre script de personnage comporte deux fonctions, qui sont appelées chaque fois que le joueur fait face à gauche ou à droite, mais elles sont appelées constamment à chaque saisie. N'appelons ces fonctions que lorsque le personnage change réellement de direction. Pour ce faire, nous pouvons exporter une variable privée pour enregistrer si le personnage est actuellement orienté vers la gauche ou non . En tant que booléen. Les méthodes face gauche et face droite définiront cette valeur comme vraie ou fausse en conséquence. Ensuite, au début du processus physique, nous pouvons ajouter des conditions pour n'appeler face gauche que si le personnage n'est pas déjà tourné vers la gauche, s'il est orienté vers la gauche. Maintenant, nos méthodes face gauche et face droite ne sont appelées que lorsque le joueur choisit de changer de direction. Nous devons également appeler les méthodes face gauche ou face droite appropriées pendant la méthode prête fonction de la valeur de la variable exportée. Cela présente également l'avantage de faire fonctionner cette fonction avec les personnages dont les sprites sont orientés vers la gauche Par défaut, le script de caméra peut désormais réagir au changement de direction du personnage à l'aide de signaux. En haut du script du personnage, nous pouvons créer un signal personnalisé que nous appellerons Changed direction, et ajouter un paramètre indiquant la caméra si le personnage est actuellement orienté vers la gauche. Désormais, les méthodes face gauche et face droite peuvent indiquer à ce signal d' émettre un passage, que le caractère soit ou non orienté vers la gauche ou non en tant qu'argument. Avec les notes du personnage sélectionnées dans l'arborescence de la scène. Passez au panneau des nœuds, cliquez avec le bouton droit sur notre nouveau signal et sélectionnez Connecter. Sélectionnez ensuite l'appareil photo. Remarque tirée de la liste. La caméra écoutera ce signal. Nous pouvons renommer la méthode qui sera appelée en conséquence Pour le dire en termes plus faciles à comprendre dans le contexte de la caméra, nommons-le sur Subject changed Direction. La méthode est automatiquement ajoutée au script de caméra. Nous pouvons maintenant modifier le décalage de la caméra pour qu'elle regarde à gauche ou à droite. Puisque nous savons dans quelle direction le personnage est orienté. Pour préserver la valeur du décalage, créons une autre variable privée nommée look Ahead distance. Cela commence par une copie du décalage de soulignement X défini pendant la phase de préparation avec at on ready Ensuite, nous pouvons définir la distance d'orientation vers l'avant comme étant le décalage X, mais multipliée par moins un si le sujet est orienté vers gauche ou par un positif si ce n'est pas le cas. Utilisez ensuite la distance de visée dans la fonction de traitement pour définir la position de la caméra. Désormais, la caméra regarde devant le personnage, quelle que soit la direction dans laquelle il se trouve. Mais que se passerait-il si nous voulions également que nos niveaux augmentent et diminuent ? Nous pouvons utiliser une méthode similaire pour faire réagir la caméra lorsque le sujet émet un signal. Cette fois, déplacez la caméra lorsque le personnage atterrit à la fin de son saut, en ajustant la caméra à une nouvelle hauteur dans le script du personnage. Ajoutons un autre signal appelé landed et passons un paramètre appelé hauteur du sol, qui sera un float. Comment savoir quand le personnage débarque ? Eh bien, nous avons la méthode pratique au sol. Si nous stockons cette valeur dans une variable privée, nous l'appellerons was on floor en tant que booléen Nous allons l'enregistrer ici. Au-dessus, déplacez et glissez. Ensuite, après être passé dans la diapositive, nous pouvons vérifier si le personnage n'était pas sur le sol et s'il l' est maintenant, ce qui signifie que c'est le moment exact où il a atterri. Appelons ici une nouvelle méthode privée appelée underscore landed rédigeant une définition pour cette méthode, nous n'avons pas vraiment besoin de faire autre chose pour le moment, part émettre le signal d'atterrissage passant dans notre position Y comme nouvelle hauteur de plancher. En demandant à la caméra d' écouter le signal, la caméra peut alors appeler une nouvelle méthode appelée «   sujet atterri ». Il suffit d' ajuster la valeur de la position Y de la caméra pour qu'elle corresponde à la nouvelle hauteur du sol plus le décalage Y. La caméra suit désormais le joueur, ce qui nous permet de créer des niveaux plus grands que ceux que nous pouvons afficher sur un seul écran, mais les mouvements sont irréguliers. Dans la leçon suivante, nous allons faire en sorte que la caméra passe doucement d'une position à l'autre à l'aide de tweens. Je te verrai dans la prochaine leçon. 25. 3 4 Tween: Bonjour, mes amis. Dans la dernière leçon, nous déplaçons la caméra suivant le joueur lorsqu'il se déplace vers droite, la gauche, le haut et le bas. Dans cette leçon, la caméra va passer doucement d'une position à l' autre La méthode la plus simple pour ajuster progressivement les valeurs au fil du temps consiste à utiliser un interpolateur Déclarons deux nouvelles variables privées. En haut de notre script de caméra, deux signaux différents déclenchent deux comportements différents dans notre script de caméra. Nous voulons qu'ils restent séparés les uns des autres. La première variable s'appellera look ahead tween, la deuxième variable « floor height tween Les deux sont de type tween. En commençant par l' interpolation prospective, lorsque notre sujet change de direction, nous pouvons définir la valeur de l'interpolation prospective pour créer une interpolation Il s'agit d'une méthode intégrée que nous pouvons utiliser pour créer notre comportement d'interpolation rapidement et facilement. Nous indiquons ensuite cette interpolation prospective pour interpoler une propriété commençant par le nœud auquel appartient la propriété et qui est elle-même Ensuite, nous désignons entre guillemets le nom de la propriété. Nous allons modifier la valeur de la distance de prévision pour obtenir cette valeur que nous avons déjà calculée sur une certaine période Pour l'instant, nous allons dire 1 seconde. Ça a l'air mieux. Mais si le joueur change direction alors que la caméra halète, nous ne devrions pas créer deux préadolescents même temps qui se disputent le contrôle de la Cela ne semble pas poser de problème. Mais nous pouvons éliminer cette possibilité en vérifiant d'abord si le préadolescent existe déjà et est en cours d'exécution Si c'est vrai, alors nous devrions le tuer avant d'en commencer un autre. Cette interpolation est actuellement linéaire et a une durée de 1 seconde Mais nous pouvons facilement le personnaliser pour créer une grande variété d'effets. abord, exportons une variable flottante appelée durée du soulignement et donnons-lui une valeur par défaut de un Branchez ensuite cette variable dans l'appel de la méthode d'interpolation. Nous pouvons maintenant régler la vitesse de panoramique de la caméra en modifiant simplement la valeur de cette variable dans l'inspecteur. N'oubliez pas qu'il n'est pas nécessaire d'arrêter le jeu pour ajuster les valeurs dans l'inspecteur. Je pense que cela devrait être un peu plus lent au cas où le joueur tournerait le dos à un ennemi, mais ne voudrait pas qu'il soit immédiatement retiré de la vue. Par exemple, pour modifier la façon dont la caméra se déplace au fil du temps, nous pouvons ajouter des types d'assouplissement et de transition à l'interpolation, ce qui ralentira ou accélérera son déplacement au début ou à la fin Vous pouvez même rebondir ou dépasser les limites définies. Exportons une nouvelle variable privée nommée trans type. Le type de cette variable sera de type transition entre deux. Ensuite, lorsque nous créons l'interpolation, nous pouvons également appeler une autre méthode, définir trans pass notre type de transition comme argument de cette méthode Nous pouvons le faire car les méthodes create tween et set trans renvoient toutes deux l'interpolation Par conséquent, la méthode create tween crée l'interpolation et la renvoie, qui est ensuite utilisée pour appeler le set trans et renvoie à nouveau l'interpolation, qui est ensuite affectée à notre variable sélectionnant la caméra dans l'arbre de la scène et en regardant l'inspecteur, vous verrez que le type de transition par défaut est linéaire, ce qui signifie que la valeur progresse uniformément sur le crée l'interpolation et la renvoie, qui est ensuite utilisée pour appeler le set trans et renvoie à nouveau l'interpolation, qui est ensuite affectée à notre variable. En sélectionnant la caméra dans l'arbre de la scène et en regardant l'inspecteur, vous verrez que le type de transition par défaut est linéaire, ce qui signifie que la valeur progresse uniformément sur le durée dans le menu déroulant. Il existe diverses options pour modifier l' évolution de la valeur au fil du temps. Nous pouvons également ajouter une autre variable appelée type d'assouplissement, de type tween ease de type similaire Cela modifiera la transition pour n'affecter que le début de la fin de l'interpolation ou les deux Tout comme pour le type de transition, nous pouvons également définir le type d'assouplissement dans la même ligne de code. Lorsque nous avons créé l'interpolation, essayez d'expérimenter différentes durées, transitions et types d'assouplissement pour voir comment ils se sentent Nous pouvons utiliser la même technique pour ajuster progressivement hauteur actuelle du sol de la caméra au fil temps après l'atterrissage du sujet. Au lieu d'utiliser une découpe dure, nous devons d' abord stocker la hauteur actuelle du sol dans une variable privée. Ensuite, lorsque le sujet arrive, nous pouvons copier près le même code à partir du moment où il change de direction, en modifiant uniquement la variable d'interpolation, de look ahead à hauteur du sol, et en modifiant également le nom de la propriété dont nous interpolons la valeur Nous allons en espacer deux, c'est le même que le paramètre de la méthode. Nous pouvons ensuite modifier la méthode de traitement pour régler la position y de la caméra comme étant la hauteur du sol plus le décalage y. La caméra se déplace ensuite doucement vers le haut ou vers le bas une fois que le sujet a atterri, en ajustant la hauteur du sol à une nouvelle hauteur de sol. Si vous souhaitez que ces deux comportements aient des durées, des types de transition ou des types d'assouplissement différents , il suffit d'exporter davantage de variables pour eux. J'aimerais que la peinture horizontale soit plus lente et plus douce, mais que la verticale soit plus rapide et plus réactive. J'aurai une durée plus longue pour l'horizontale, mais j'aurai aussi le type de facilité à entrer et à sortir. Pour la verticale, je vais avoir une durée plus courte et je ne ferai que m'assouplir. La caméra se déplace plus vite au début et plus lentement après nous. Selon la version de do que vous utilisez, déplacer la caméra et le personnage en même temps peut poser problème , ce crée un effet de nervosité Pour résoudre ce problème, essayez d'ouvrir les paramètres du projet. Recherchez V sync en bas de la fenêtre d'affichage et désactivez le paramètre. Nous avons maintenant notre caméra, qui montre au joueur exactement ce qu'il a besoin de voir d'une manière fluide et douce. Dans la leçon suivante, nous allons ajouter un arrière-plan animé à notre scène. Je te verrai dans la prochaine leçon. 26. 2-5 arrière-plan: Bonjour les amis. Dans la leçon précédente, nous avons terminé le script de comportement de notre caméra afin qu'il suive le personnage du joueur. Dans cette leçon, nous allons ajouter un arrière-plan animé à notre niveau. L'arrière-plan du niveau doit donner l'impression qu' il est très éloigné. Sinon, l' environnement apparaîtra très plat et bidimensionnel au joueur Nous pouvons créer une illusion de profondeur en ajoutant un nœud enfant à la caméra. Un nœud deux D, il aura une valeur de position ainsi qu'un index Z, un nom en arrière-plan. Développez ensuite la section de commande sous l'élément du canevas et définissez l'indice Z de ce nœud sur une valeur négative. Le terrain plat utilise l'indice Z par défaut de zéro. Un nombre négatif sera indiqué en fonction du nombre de couches de profondeur souhaitées dans votre environnement. Vous souhaiterez peut-être placer l'indice z d'arrière-plan plus loin qu'un indice négatif. Je vais placer l' arrière-plan à moins dix, en laissant les valeurs de moins un à moins neuf disponibles pour tout ce qui doit se trouver entre l'arrière-plan et le terrain. Même si je n'ai pas l' intention de le faire, il vaut mieux laisser cette possibilité là. Désormais, chaque nœud enfant que nous ajoutons à ce nœud suivra automatiquement la caméra et sera dessiné derrière tout le reste du niveau. Le pack d'actifs contient plusieurs sprites que nous pouvons utiliser pour assembler un environnement d'arrière-plan. Nous pouvons simplement cliquer et faire glisser les images pour l' arrière-plan dans notre scène. Et Godot les transformera automatiquement en un groupe de deux nœuds Sprite en sélectionnant tous les nouveaux Faites-en tous des enfants du nœud d'arrière-plan. faisant glisser dedans, je vais simplement étirer les images du coucher du soleil, du ciel et de l'eau manière à ce qu'elles couvrent toute la fenêtre de l'appareil photo Faisons de l'arrière-plan sa propre scène afin qu'elle puisse être modifiée isolément et enregistrons-la dans le dossier des scènes. Cliquez ensuite sur l'icône du clapper board pour l'ouvrir. Dans le même dossier, il y a des animations de sprites pour faire scintiller l'eau Ajoutons trois sprites animés (deux D) à notre couture. Nous pouvons ensuite renseigner chacun d'entre eux avec une ressource Sprite Frames Et remplissez les images de sprites avec chacune des trois animations de sprites Assurez-vous également qu'ils exécutent automatiquement leurs animations en boucle avec la bonne fréquence d'images, puis positionnez-les dans l'eau où elles seront belles Lorsque vous avez terminé, vous pouvez enregistrer votre travail et voir à quoi il ressemblera en exécutant la scène principale. Ensuite, ajoutons quelques nuages dans le ciel. Ils ne sont pas animés, nous pouvons donc simplement les faire glisser dans la vue en deux D pour créer un sprite à deux nœuds en D. Si vous souhaitez ajuster la façon dont les sprites sont superposés, au lieu d'ajuster la valeur de l' indice Z de chaque sprite, nous pouvons également utiliser l' arbre des scènes pour réorganiser les nœuds Les nœuds ayant le même indice Z seront dessinés du haut vers le bas de l'arbre de scène. Le simple fait d'organiser la liste des nuages en fonction de leur taille permet également de trier leur ordre et de placer le plus petit nuage à l'arrière et le plus grand au premier plan. Ouah, ouah. Ce plus grand nuage est également déjà plus grand que la fenêtre d'affichage de la caméra et possède ces bords rigides Il est conçu de cette façon pour être enroulé sur lui-même à l'aide d'une technique appelée défilement parallaxe, dupliquer Nous pouvons en placer deux dans notre scène et les déplacer progressivement sur le côté. Ensuite, lorsque l'un d'eux sort de l'écran, nous pouvons le repositionner de l'autre côté, faisant tourner en boucle à l'infini en arrière-plan Cela ajoutera à l'illusion de profondeur que l' arrière-plan est éloigné, mais créera également l'illusion qu'il y a du vent. Ajoutons un script au nœud racine de cette scène, qui créera l'effet de défilement parallaxe abord, nous devons obtenir une référence aux nœuds enfants que nous voulons déplacer, nous pouvons utiliser et prêts à les stocker dans des variables, nous assurant de mettre le nom exact des nœuds après le signe dollar dans leurs assignations. Exportons également une variable de vitesse de défilement, qui est un float basé sur l'animation du palmier Cela implique que le vent soufflera vers la gauche. Utilisons une valeur par défaut négative 100 dans la méthode de traitement. Nous pouvons ensuite ajouter une vitesse de défilement multipliée par delta à l'exposition des nuages, les faisant ainsi se déplacer vers la gauche à une vitesse constante Mais nous allons le faire sur cinq clouds différents. Il serait donc préférable de faire en sorte que cette méthode prenne un nœud deux D comme paramètre ainsi que la distance sur laquelle il fait défiler comme un flottant Ensuite, nous pouvons simplement ajouter la distance à sa position. La méthode de traitement peut maintenant appeler cette méthode, en transmettant à chaque nuage la vitesse de défilement multipliée par le delta. Pour calculer la distance par image, nous pouvons encore améliorer l'illusion de profondeur en faisant également en sorte que les nuages se déplacent à des vitesses différentes Les plus grands nuages les plus proches du joueur se déplacent plus rapidement et les petits nuages plus éloignés se déplaçant plus lentement. Mais évitez d'utiliser des multiplicateurs de vitesse multiples les uns des autres Cela formera un schéma très évident et brisera l'illusion si la vitesse d'un nuage est exactement la moitié de celle d'un autre. Par exemple, le joueur remarquera qu'il est utile d'utiliser des nombres premiers pour. La dernière chose à faire est de vérifier si l'un de nos nuages s'est complètement éloigné de la caméra, puis de le déplacer de l'autre côté. Si nous positionnons un gros nuage au milieu, l'autre est maintenant là où il se trouvera lorsque nous voulons qu'il tourne en boucle, ce qui correspond également à la largeur en pixels de l'image. Faisons en sorte que cette valeur de largeur soit de type flottant variable exportée avec une valeur par défaut de 448 Vérifier si la position x d' un nuage est inférieure à multipliée par moins un. Nous pouvons ensuite le déplacer vers la droite par la largeur multipliée par deux pour le placer de l'autre côté du deuxième gros nuage. Cela permettra également aux autres nuages de tourner périodiquement seuls. Voyons à quel point c' est beau. Cependant, dès que votre joueur redimensionne la fenêtre de jeu, l'illusion est brisée ouvrant les paramètres du projet sous la fenêtre d'affichage, nous pouvons définir la résolution souhaitée pour notre jeu. Plus important encore, nous pouvons changer le mode Stretch pour étirer les objets en toile, ce qui est essentiel dans notre jeu en deux D. Nous voulons absolument conserver le même rapport hauteur/largeur même si le joueur redimensionne la fenêtre Une nouvelle fonctionnalité a récemment été ajoutée Nous pouvons également limiter l'étirement à une échelle uniquement en nombres entiers. Cela peut empêcher nos pixels d' être dessinés à des tailles incohérentes. Une fois que vous avez choisi un paramètre de résolution, assurez-vous que votre arrière-plan correspond aux nouveaux paramètres et qu'il devrait être impossible voir en dehors de votre arrière-plan. Nous avons maintenant un beau coucher de soleil nuageux en arrière-plan de notre niveau. Dans la leçon suivante, nous allons ajouter de l'eau au premier plan. Je te verrai dans la prochaine leçon. 27. 2-6 Eau: Bonjour, mes amis. Dans la leçon précédente, nous avons ajouté un arrière-plan animé à notre scène. Dans cette leçon, nous allons ajouter de l'eau au premier plan. Pour cette leçon, j'ai téléchargé et modifié un autre effet sonore pour les éclaboussures d'eau Cet effet sonore a été créé par Yin Yang Jake 007 sur FreeSound.org Tout comme pour l'arrière-plan, nous pouvons commencer par créer un nœud racine pour Cette fois, utilisez un nœud en zone 2 D et nommez-le eau. Réglez ensuite à l'index z un nombre positif, sorte qu'il soit toujours dessiné devant, laissant de la place pour des couches supplémentaires entre les deux. Les actifs relatifs à l'eau contenus dans le pack d'actifs comportent une animation pour les vagues et un carré plat pour tout le reste. Ajoutons un sprite animé deux nœuds D pour la surface de l'eau Créez une nouvelle ressource Sprite Frames. Ajoutez la boucle de lecture automatique des sprites, puis réglez la fréquence d'images , ajoutez un décalage ou déplacez la transformation des sprites animés de manière à ce que l'origine de l'eau trouve dans le coin supérieur gauche Cela facilitera l' alignement sur la carte en tuiles et fournira également la valeur Y de zéro correspondant à la surface de l'eau. Ajoutez ensuite le sprite inférieur en tant que nœud sprite à deux D. Bien que le bas puisse facilement être étiré pour remplir n'importe quelle zone, la surface devra être dupliquée et répétée pour que l'arbre de scène reste organisé Nous devrions créer un autre nœud deux D, qui servira de dossier pliable contenant ces sprites animés La zone deux D a besoin d'une forme pour définir le fonctionnement de sa collision. La physique de l'eau a besoin de deux comportements différents. Lorsque quelque chose se trouve à la surface de l'eau ou sous l'eau, nous pouvons utiliser un segment de ligne tracé au-dessus de la surface de l'eau, car cela nous indiquera si quelque chose touche la surface ou non. Pour faciliter les choses, assurez-vous que l'origine de l' objet aquatique est alignée avec celle du collisionneur de surface Dupliquons également rapidement l'une de nos scènes de particules de poussière pour créer une scène d'éclaboussure. Supprimez ensuite les images de sprites de cette scène et remplacez-les par les sprites Splash One du pack d'actifs Pour que l'eau réagisse aux collisions, nous devons créer un script hydraulique. Ce script devra réagir à deux signaux lorsqu'un corps y pénètre et qu'un autre en sort Nous pouvons simplement connecter ces signaux au script lui-même en utilisant les noms par défaut. Les paramètres du corps de ces méthodes sont de type node two D, comme vous pouvez le voir dans la liste des signaux. Mais afin de définir comportement de nos personnages par rapport à l'eau, nous devons savoir si ce nœud nommé corps en deux D est un personnage ou s'il s'agit d'un autre personnage. Nous devrons donner un nom de classe à notre script de personnage avant que le mot ne s'étende. Dans la première ligne, ajoutez le nom de la classe, le caractère. Il s'agit désormais d'un mot que d'autres scripts peuvent utiliser pour désigner ce script en tant que type général. Pour revenir au script aquatique, lorsqu'un corps entre dans l'eau, on peut maintenant vérifier si le corps est un personnage, puis appeler une méthode que nous n'avons pas encore définie, nous appellerons entrer l'eau et passer dans la position y de l'eau, qui est la surface de l'eau dans le corps. Méthode terminée. Nous pouvons effectuer la même vérification pour voir si le corps est un personnage. Encore une fois, lorsqu'un personnage sort, est-à-dire qu'il ne touche plus le segment de ligne recouvrant la surface de l'eau, l' une des deux choses suivantes peut se produire Soit ils sont maintenant au-dessus de la surface de l'eau, soit ils sont sous la surface. Puisque nous savons que la position Y de ce nœud correspond à la surface de l'eau, le corps a également une position Y. Nous pouvons comparer les deux valeurs pour déterminer de quel cas il s'agit. Mais aussi en ajoutant un PPT global divisé par deux ou deux tuiles. Si la position du corps est inférieure ou égale à la surface de l'eau, cela signifie que le corps a cessé entrer en contact avec la surface de l'eau et qu'il se trouve entièrement au-dessus de la surface de l'eau. Étant donné que les pixels par carreau sont définis comme un entier, mais que la position y est définie comme un flottant, Godel nous avertira que les valeurs décimales seront ignorées Nous pouvons y remédier en convertissant la valeur entière en valeur flottante ici et le personnage sort de l'eau Sinon, le personnage se trouve sous la surface de l'eau. Et nous devrions appeler une autre méthode, que j'appellerai la plongée. En passant au script de caractères, nous pouvons ajouter ces trois définitions de méthodes à nos méthodes publiques. Entrez l'eau, qui prend comme paramètre une valeur flottante représentant la surface de l'eau. Plongez également et sortez de l'eau. Le but de ces méthodes publiques est de faire savoir au processus physique et aux méthodes de saut où se trouve le personnage et comment il doit se comporter. Nous devrons ajouter de nouvelles variables privées. La hauteur de la surface de l'eau sous forme de flotteur, et deux booléens nous indiquant si le personnage est dans l'eau et s'il est sous la Chacune de nos nouvelles méthodes permet désormais définir ces variables de manière appropriée. Enter water sets La hauteur de la surface de l'eau nous indique que nous sommes dans l'eau mais pas en dessous de la sortie de surface. L'eau s'installera dans l'eau jusqu'aux chutes. La plongée se fera simplement sous la surface. Pour ce qui est de la physique, nous devons déterminer si le personnage va flotter ou couler, quelle mesure le fait d'être dans l'eau limite ses mouvements Nous pouvons ajouter une nouvelle catégorie de variables exportées à notre script nommée Swim. Par souci de simplicité, la valeur qui détermine si un caractère flotte ou non, nous pouvons appeler densité et lui donner une valeur par défaut de moins 0,1 . Cette valeur sera comparée à la densité de l'eau Une valeur de zéro aura une flottabilité parfaite, inférieure à zéro flottera, une valeur supérieure à zéro baissera pour restreindre les mouvements Nous pouvons également définir une valeur pour la traînée, qui sera multipliée par les forces afin de réduire leur efficacité. Et utilisez une valeur par défaut de 0,5. Pour commencer, lorsqu'un objet atteint la surface de l'eau pour la première fois, une force d'impact réduit sa vitesse dans la méthode d' entrée dans l'eau Si notre vitesse y est supérieure à zéro, nous pouvons la multiplier par la traînée. Pour simuler cette force d'impact, comme nous l'avons fait pour le sol en physique de l'air, nous pouvons d'abord vérifier le processus physique, si le personnage est dans l'eau, puis appliquer la physique de l'eau, assurant de passer le delta, en le remplaçant par un autre sur la ligne suivante, vérifiant s'il est au sol. mouvements horizontaux dans l'eau se comporteront à peu près de la même manière qu'au sol, mais la décélération et accélération seront également multipliées par traînée pour réduire leur efficacité Comme j'ai copié cette ligne ci-dessus, je dois changer la décélération en Le mouvement vertical dépendra si le personnage se trouve sous la surface de l'eau ou si sa densité est supérieure à zéro. Dans l'un ou l'autre cas, nous devrons déplacer leur vitesse Y vers la flottabilité, c' est-à-dire la gravité multipliée par la densité, et également appliquer une traînée pour ralentir Le taux de variation est calculé en utilisant gravité multipliée par le temps de traînée par le delta. Si le personnage touche la surface de l'eau, nous voulons le faire bondir de haut en bas. Ce qui peut être divisé en deux situations avec une autre instruction if. Si le centre de flottabilité du personnage se trouve au-dessus ou en dessous de la surface de l'eau, ajustez la vitesse y pour le déplacer vers le haut ou vers le bas en conséquence. Nous pouvons simplifier cela comme suit : si la position y du personnage moins un quart de tuile est inférieure à la hauteur de la surface de l'eau. Pour simplifier, nous pouvons simplement copier la formule ci-dessus multipliée par moins un s'ils sont sous la surface de l'eau pour se déplacer dans la direction opposée. La dernière chose à faire est modifier le fonctionnement du saut dans l'eau. Si le personnage est dans l' eau et sous la surface, vitesse de saut doit être affectée par la traînée. Si le personnage n'est pas sous la surface, il doit avoir la force de saut maximale pour pouvoir facilement sauter sur la terre ferme. Nous pouvons également émettre le signal d'atterrissage ici pour régler la caméra. De plus, lorsqu'ils entrent dans l'eau la méthode stop jump doit également être désactivée lorsqu'ils sont dans l'eau. Pendant que le script de personnage est ouvert, copions la méthode spawn dust et utilisons-la pour créer une méthode splash Dans le script relatif à l'eau, nous aurons besoin d'une référence à la scène pleine, qui contient le splash. Renommer nos variables et méthodes en conséquence. Comme l'eau crée des éclaboussures et que l' eau ne bouge pas, les éclaboussures peuvent être projetées dans l'eau, sans problème La position y des éclaboussures sera définie par défaut sur zéro, ce qui correspond déjà à la surface de l'eau Et sa position globale x peut être définie sur la valeur transmise à la méthode en tant qu'argument. Il s'agira de la position du corps qui est entré dans l'eau pour créer l'éclaboussure. Nous pouvons régler la position du splash X pour qu'elle corresponde exactement à cela. L'eau a également besoin d'un lecteur de flux audio en deux D pour générer l'effet sonore des éclaboussures. Rempli avec le fichier modifié que j'ai téléchargé sur FreeSound.org, le script peut obtenir une référence à ce nœud enfant pendant la phase de préparation, puis indiquer à l' effet sonore Nous pouvons générer une éclaboussure chaque fois qu'un corps entre dans l'eau en passant par la position du corps. De plus, lorsque le corps d'un personnage choisit de sortir de l'eau, de positionner l'eau à un endroit où le joueur peut y accéder et penser à remplir la scène pleine à craquer dans l'inspecteur, nous pouvons le tester rapidement et apporter les ajustements souhaités à la densité de traînée du personnage ou aux calculs de flottabilité ou d' éclatement à la surface jusqu'à ce qu'il apporter les ajustements souhaités à la densité de traînée du personnage ou aux calculs de flottabilité ou d' se la surface jusqu' L'eau étant entièrement fonctionnelle, nous allons faire en sorte qu'elle englobe l' ensemble du premier plan du niveau. En étirant le bas, en dupliquant la surface et en modifiant la forme de collision pour qu'elle corresponde au sol que nous avons créé dans la toute première leçon, et en modifiant la forme de collision pour qu'elle corresponde au sol que nous avons créé dans la vous pouvez également vous empêcher de le faire Maintenant, nous avons l'eau au premier plan de notre niveau et les personnages peuvent y nager Dans la leçon suivante, nous allons structurer notre niveau et ajouter des limites. Je te verrai dans la prochaine leçon. 28. 2-7 limites: Bonjour les amis. Dans la leçon précédente, nous avons ajouté de l'eau au premier plan de notre scène Dans cette leçon, nous allons définir la structure de nos niveaux et de nos limites. abord, la carte des tuiles déclenche actuellement le bruit d'éclaboussure. Lorsque nous exécutons notre scène, la méthode d' ajout d'une condition au corps saisi peut être renvoyée si le corps est une carte en tuiles, empêchant ainsi l'exécution de ce code. Dans ce cas également, certaines animations aquatiques n' ont peut-être pas été synchronisées lors de l'exécution de la scène, ce qui n'est qu'un problème temporaire dû au fait que les animations sont diffusées dans l'éditeur Si vous observez un joint sur les nuages défilants, vous pouvez également réduire la propriété de largeur d' Nous devrions également régler les autres personnages, les colliders afin qu'ils puissent se tenir debout proprement sur le sol Notre arbre de scènes contient désormais de nombreux composants différents. L'étiquette et les nœuds d'étage ne sont plus pertinents. Supprimons-les. Nous devrions séparer tous les nœuds qui seront utilisés pour construire les différents niveaux en une seule branche, transformant toutes nos décorations en enfants d' un nœud deux D. Ceux-ci deviennent plus faciles à organiser Faites de même avec nos ennemis, faisant tous les enfants d' un nœud deux D pour qu'ils restent organisés. Comme ce sont tous des composants de notre niveau de jeu, nous pouvons créer une nouvelle zone en deux D pour les contenir et la nommer niveau. Créez ensuite les décorations de la carte en tuiles, les ennemis et les enfants aquatiques du nœud de niveau. Par souci de simplicité, définissons temporairement l'origine du niveau comme étant le point de départ du joueur et déplaçons le joueur vers l'origine de la scène. Ajustez ensuite tous les nœuds enfants du niveau pour ils correspondent, sauvegardez le niveau en tant que scène propre, qui appartient à un nouveau dossier nommé levels. Nous pouvons nommer ce niveau un, un. La caméra et l'arrière-plan du personnage du joueur seront utilisés pour chaque niveau puisque le pack d' actifs ne contient aucun autre élément pour les arrière-plans Selon la façon dont vous prévoyez de concevoir votre jeu, l'arrière-plan peut également faire partie du niveau. Nous pouvons maintenant ouvrir la scène de niveau 1. Puisque nous avons transformé le nœud racine de notre niveau en une zone deux D, cela signifie que nous pouvons lui donner une forme. Définissons notre niveau sous la forme d'un rectangle. Et ajustez la taille et la position du rectangle pour définir les limites auxquelles le joueur et la caméra seront confinés. Et ajustez la couleur du bogue D de cette zone de collision pour qu'elle soit plus transparente. Cela n'affecte pas notre vision de tout le reste. En créant un nouveau script pour le niveau, nous pouvons obtenir une référence à la forme de collision entre deux nœuds D pendant la phase de préparation. Le but de ce rectangle est de faire en sorte que le joueur et la caméra sachent où s'arrêter. Nous devrons obtenir les valeurs minimales et maximales autorisées dans les limites de ce rectangle Écrivons deux méthodes, get min et get max, qui seront publiques et renverront un vecteur deux. La valeur minimale sera la position de la forme de collision moins la moitié de sa taille. Mais pour accéder à la taille, nous devons d'abord accéder à sa forme, puis au rectangle, puis à la taille, et répéter pour obtenir la valeur maximale. Pour éviter de répéter ce code plusieurs fois, nous devons également le définir comme une variable, le nommant demi-taille. Revenons à la scène principale. Le but de cette scène est de faciliter la communication entre le personnage du joueur, la caméra et le niveau actuel, nous permettant de changer facilement le niveau par un nouveau selon les besoins. Vous pouvez renommer cette scène et son nœud racine pour refléter cet objectif Dans un jeu simple comme celui-ci, vous pouvez appeler cela la scène principale ou la scène de jeu. Si votre boucle de jeu inclut un gameplay autre que le jeu de plateforme, vous pouvez donner un nom à la scène de plateforme pour la distinguer des autres scènes de jeu Pour gérer les règles du fonctionnement de cette scène de jeu , nous devons lui donner un script. Le nom du script est généralement le nom de la scène suivi du gestionnaire de mots. travail de ce responsable consiste à s' assurer que toutes les notes des enfants contiennent toutes les informations dont ils ont besoin pour accomplir chacune de leurs tâches uniques. Afin d'empêcher le personnage du joueur ou la caméra de quitter les limites du niveau, ils doivent connaître ces limites. Comme cette scène peut exécuter n'importe quel niveau, elle devra demander des informations sur les limites du niveau dans le script de niveau et transmettre ces informations au script du personnage du joueur ainsi qu'à la caméra. En haut du script du gestionnaire. Trouvons d'abord les références au niveau, au joueur et à la caméra dans la méthode Ready. Nous pouvons ensuite obtenir les limites à partir du niveau et définir les limites pour le joueur et la caméra. Désormais, les scripts du personnage et de la caméra auront besoin de méthodes publiques pour définir ces limites, puis les appliquer eux-mêmes. En commençant par le caractère, nous pouvons simplement créer deux nouvelles variables de type vecteur deux et stocker les valeurs minimale et maximale. Écrivez une méthode set bounds qui prend deux vecteurs deux et définit les valeurs des variables privées Ensuite, à la fin du processus physique, nous pouvons restreindre la position du personnage pour qu'elle soit contenue dans ces limites en utilisant la méthode de serrage, en fournissant à la valeur actuelle un minimum et un maximum. C'est à vous de décider si vous souhaitez imposer ces restrictions à tous les personnages de votre jeu ou uniquement au personnage du joueur. Mais je pense que les ennemis devraient être libres de quitter les limites de niveau dans mon jeu. Je vais subordonner cette dernière étape au fait que ces limites ont été définies ou non en ajoutant également une variable booléenne nommée is bound Lorsque la méthode set bounds est appelée sur le personnage du joueur, elle définit également cette variable sur true, mais les autres personnages restent indépendants L'appareil photo sera légèrement plus compliqué puisque l'appareil photo lui-même a également une forme. Copier les mêmes variables et méthode de réglage dans le script de caméra. Nous pouvons modifier les valeurs min et max en fonction de la taille de la vue de la caméra. Nous pouvons récupérer cette valeur en utilisant get Viewport wrecked size divisée par le zoom et réduite Ajoutez ensuite cette valeur au minimum et soustrayez-la du maximum Il est presque toujours préférable de stocker valeur calculée dans une variable plutôt que de la calculer plusieurs fois. Ensuite, nous pouvons ajuster la position de la caméra de la même manière que nous l'avons fait pour les personnages. Essayons-le. La vue de la caméra est limitée à la limite du niveau comme l'origine du personnage, et elle fonctionne de tous les côtés. Nous pouvons garder tout Roger à l' écran en appliquant la même logique, en utilisant la taille du sprite Mais comme le sprite n'est pas centré sur l' origine du personnage, nous devons calculer les valeurs x et y différemment. Roger ne sera désormais autorisé là où le sprite entier restera affiché à l'écran Tout au long de cette section, nous avons développé de nombreuses fonctionnalités qui seront utilisées pour générer des niveaux pour notre jeu. Dans la section suivante, nous ajouterons des trésors de collection et une interface utilisateur à notre scène principale Je vous verrai dans la section suivante. 29. 3-1 Données: Bonjour les amis. Dans la section précédente, nous avons créé de nombreux composants structurels dont nous avons besoin pour créer les niveaux de notre jeu. Dans cette section, nous allons créer un trésor à collectionner que le joueur pourra collecter et disperser dans nos niveaux Si vous avez terminé la mission, vous devriez avoir deux niveaux de base construits avec des terrains, des décorations et des limites différents. Au fur et à mesure que vous avez terminé cette tâche, vous avez probablement également apporté des modifications afin mieux vous adapter à votre jeu. Par exemple, j'ai ralenti la vitesse de défilement des nuages à 32 pixels par seconde parce que je n'aimais pas leur apparence lorsque l'appareil photo s'interrompait Lorsque la caméra a fait demi-tour, j'ai réduit la gravité d'environ la moitié par rapport à ce qu'elle était auparavant et modifié les valeurs de tous les personnages, de la locomotion et de la natation J'ai également apporté une petite correction à l'effet sonore des éclaboussures dans le script en forme d'eau. Comme le lecteur audio à deux nœuds D réduit le volume en fonction de la proximité de la caméra, le son sera d'autant plus faible que vous vous éloignez du début du niveau. Pour résoudre ce problème, j'ai défini l'exposition globale du nœud du lecteur de flux audio sur l'exposition transmise dans la méthode selon laquelle le son proviendra du même endroit que le splash à plein volume. Bien que les didacticiels soient toujours la dernière chose que vous créez pour votre jeu, j'aimerais profiter de l' occasion pour passer en revue certains principes de conception de niveaux pour un apprentissage intuitif. Pour le premier niveau de l'île, j'ai commencé le jeu avec un obstacle immédiat qu'il devait franchir, suivi d'un obstacle plus haut et d'un autre encore plus haut. Après cela, cela devrait être suffisant pour que le joueur comprenne qu'il peut maintenir le bouton de saut enfoncé pour atteindre le haut du deuxième obstacle, mais pas le troisième. J'ai présenté l'arbre comme une plateforme à sens unique dans un environnement sûr, et j'ai demandé au joueur d'apprendre à l' utiliser avant de passer à la section suivante du niveau. Ici, les mêmes arbres sont disponibles, avec un risque légèrement plus élevé d'être introduits, de devoir sauter d'arbre et de tomber à l'eau. S'ils échouent, le risque n'est pas réel, mais uniquement perçu par le joueur. J'ai créé trois voies différentes à partir de cette partie, la plus simple étant la voie à suivre, et les deux autres pouvant mener à des récompenses. Toutes sont clairement visibles, au joueur qu'il devrait faire attention à d'autres embranchements comme celui-ci à l'avenir. La prochaine fois que je toucherai d'autres embranchements comme celui-ci à l'avenir quelque chose comme ça, le joueur verra la récompense en premier, mais il devra faire demi-tour pour la récupérer, enseignant au joueur ce qu'il doit rechercher C'est la première fois que j' utilise un arbre d'arrière-plan. Parce que je ne voulais pas que le joueur pense pouvoir sauter sur cet arbre, échouer et apprendre faussement que tous les arbres ne sont pas des plateformes À ce stade, le joueur a déjà utilisé les arbres de premier plan comme plateformes Cet arbre est positionné pour être sauté dessus depuis l'arbre vers la gauche ou depuis le sol. Cela enseigne au joueur que seuls les arbres d'arrière-plan ne sont pas des plateformes pour continuer, il doit ignorer l' arbre d'arrière-plan et sauter du rebord Au lieu de cela, au cas où le premier arbre ne fonctionnerait pas, je l'ai suivi avec un deuxième arbre destiné à inciter le joueur à essayer de sauter dessus . Et au lieu de cela, suivre. Voici une autre grotte secrète. Mais cette fois, le joueur ne le voit pas. S'ils ont appris les parties précédentes du niveau qu'ils devraient explorer dans l' eau, ils seront récompensés. Toutes ces entrées dans l'eau sont clairement signalées par des rayons lumineux, dont deux, qui aident à attirer l'attention du joueur et à donner à l'eau un aspect accueillant J'ai placé des arbres de premier plan et d' arrière-plan ensemble pour tester la capacité du joueur à sauter jusqu'à l'arbre le plus haut Les arbres se distinguent également par leur couleur et leur superposition devant ou derrière le joueur L'utilisation de couleurs ou d'un éclairage cohérents pour attirer l' attention du joueur s'appelle utiliser langage visuel ou des affordances pour indiquer au joueur qu'il peut ou doit faire quelque chose à cet endroit ou en utilisant cet objet De nombreux jeux utilisent ces techniques pour indiquer les corniches escaladables, les objets cassables, objets cassables Ou pour vous dire quand vous devez utiliser une arme ou une capacité spécifique. Déplacer le premier niveau, le remplacer par un niveau de vaisseau et renommer les nœuds Je peux alors jouer à l' autre niveau à la place. Lorsque le joueur atteindra ce niveau, il aura une bonne compréhension des mécanismes de plateforme et n'aura pas besoin d'être enseigné Je me concentre plutôt sur la création de l'apparence générale d'un bateau pirate, façonnant l'ensemble du niveau pour qu'il représente une coque. Et des tuiles supplémentaires ont été ajoutées pour masquer l'arrière-plan jusqu'à ce que le joueur atteigne le niveau de l'eau J'ai décoré des pièces spécifiques et des impasses avec des barils et des bouteilles, et j'ai positionné les escaliers manière thématique empêcher le joueur de quitter le navire Avant que le joueur puisse collecter un trésor, nous devons créer un script pour connaître la quantité de trésor dont il dispose. Nous pouvons placer ce script dans le dossier Autolodes et le nommer Data Mais au lieu d'étendre le nœud, nous devons cette fois étendre. Nous pouvons supprimer le modèle. Le but du script sera de contenir toutes les informations relatives à la progression d'un joueur dans le jeu. Pour commencer, ajoutons simplement un entier, qui sera le nombre de pièces que le joueur a collectées, et un autre entier représentant le nombre de vies qu'il lui reste. L'exportation de ces variables nous permettra de les visualiser dans l'inspecteur pendant que le jeu est en cours d'exécution. S'il le faut, la valeur par défaut d'un entier est zéro, ce qui convient aux pièces d'un joueur comme valeur de départ, mais pas très agréable pour sa vie au début de la partie. Nous devons définir exactement ce que cette ressource contiendra lors de sa création initiale. Soulignons que nous pouvons définir les valeurs initiales pour chaque variable, ainsi que suivre toute autre logique que nous voulons cadre de l' initialisation des ressources, j'aimerais que les joueurs commencent ma partie avec zéro pièce et trois vies. Afin de référencer cette ressource par son type, nous devons lui donner un nom de classe. Appelons-le Data avec une majuscule D. Au fur et à mesure que notre jeu se complique, cette ressource de données contiendra nombreuses autres variables de différents types pour suivre la progression des joueurs. Nous avons maintenant un endroit où stocker ces informations, mais nous avons besoin des scripts de notre jeu pour pouvoir y accéder librement. Comme nous l'avons fait avec le chargement automatique global, nous pouvons créer un autre chargement automatique dont la responsabilité est d' accéder aux données et de les gérer. Nommons que ce fichier contiendra une variable appelée data avec une minuscule du type data avec une majuscule D. Le but du script sera de permettre au reste du jeu d' accéder au fichier de données actuel, mais également de gérer le fichier de données Ici, nous devrons écrire des méthodes pour démarrer un nouveau jeu, en sauvegarder et en charger deux. Nous ne sommes vraiment intéressés que par la création d'une nouvelle ressource de données. Nous devons définir la valeur des données comme étant des données, nouvelles données créeront une nouvelle ressource de données et déclencheront automatiquement la méthode d' initialisation que nous venons d'écrire, en définissant les vies à trois au lieu de zéro Pour l'instant, nous pouvons simplement appeler la nouvelle méthode de jeu lorsque ce nœud est prêt. Ouvrez les paramètres du projet, passez à l'onglet chargement automatique, puis ajoutez le nouveau script de fichier à la liste des chargements automatiques. Le nom du nœud par défaut fonctionnera correctement si nous exécutons cette scène. Nous pouvons revenir à Dieu pendant que le jeu est en cours. Passez ensuite du mode local au mode distant dans l'onglet scène. Cela nous montrera l'arborescence des scènes du jeu en cours d'exécution. En sélectionnant le nœud chargé automatiquement du fichier et en regardant dans l'inspecteur, nous pouvons voir qu'il contient une ressource de données. Le nom de la ressource de données est l'identifiant de l'objet, suivi d'un nombre long. En cliquant sur la ressource, nous pouvons voir et modifier son contenu. N'importe lequel de nos scripts permet d'accéder facilement à ces informations. Pour le démontrer, ouvrons le script du gestionnaire de jeu. Et après avoir fait les choses habituelles avec les limites de niveau, il suffit d'imprimer la valeur des vies classées. En cours de scène, nous pouvons voir le numéro trois imprimé dans le panneau de sortie. Nous avons maintenant une ressource personnalisée configurée pour stocker les informations de nos joueurs auxquelles nous pouvons accéder à tout moment. Dans la prochaine leçon, nous allons créer des pièces que le joueur pourra collecter. Je te verrai dans la prochaine leçon. 30. 3-2 pièces: Bonjour les amis. Dans la leçon précédente, nous avons créé une ressource personnalisée pour suivre les progrès et les données du joueur. Dans cette leçon, nous allons créer des pièces à collectionner. Nous pouvons nous disperser dans nos niveaux pour que le joueur puisse les collectionner Pour cette leçon, j'ai importé un ensemble de sons provenant de FreeSound.org créés par Val Inspire avec une licence Creative Commençons par ouvrir notre premier niveau et créer un nouveau dossier à deux nœuds en D pour le trésor. Les pièces de monnaie sont des objets physiques qui existent dans le monde. Nous devrons détecter les collisions. Nous souhaiterons peut-être également qu'ils soient affectés par la gravité. Le nœud qui définit le mieux ces comportements sera un nœud à deux D à corps rigide. Renommons-la en pièce d'argent afin de pouvoir voir notre pièce Ajoutons-y d'abord un sprite animé. Créez une nouvelle ressource Sprite Frames. Trouvez les sprites à pièces d'argent dans le pack d'actifs et complétez l'animation par défaut Définissez cette animation par défaut pour qu'elle soit exécutée automatiquement, bouclée et définissez le nombre d' images par seconde. Nous pouvons également ajouter une deuxième animation à ce sprite animé en cliquant sur le nom du bouton Ajouter une animation Cet effet d'animation, puis remplissez-le avec les sprites à effet de pièce du pack d'actifs Cette animation ne doit pas être mise en boucle. Il s'agit de l'animation qui doit être jouée lorsque la pièce est collectée avant qu'elle ne disparaisse. Revenez à l'animation par défaut. Nous pouvons donc voir clairement la taille et la forme de la pièce dans l'éditeur. Maintenant que nous pouvons voir notre pièce, comme tous les objets physiques de ces collisions, nous devons lui donner une forme de collision, créant ainsi une ressource en forme de cercle. Nous pouvons le redimensionner pour l'adapter à la taille de la pièce. Vous pourriez avoir besoin pour désactiver le cliquetis. Les collisions avec des pièces génèrent également généralement des effets sonores. Nous devrions également y ajouter un lecteur de flux audio au nœud et le remplir avec l'effet sonore coin Cl Sauvegardons la branche de la pièce d'argent comme scène à part entière et plaçons-la dans un nouveau dossier de scènes nommé Treasure. Comme tout le reste, les pièces auront besoin d'un script pour contrôler leur comportement. Nous devrions commencer à organiser nos scripts dans des dossiers désignés. Je vais créer un dossier nu pour les scripts Treasure. Nous pouvons commencer notre script en saisissant références aux nœuds du sprite et du lecteur audio pendant la phase de préparation. Une fois le nœud racine de la pièce sélectionné, connectez le signal saisi au corps à lui-même afin que la pièce puisse réagir en cas de collision avec d'autres Lorsqu'un corps entre dans le collimateur, nous devons d'abord jouer l'effet sonore Ensuite, nous voulons vérifier si la pièce est entrée en collision avec autre chose qu' un caractère, et si ce n'est pas un caractère, retourner pour qu'elle soit ignorée S'il s'agit bien d'un personnage, nous pouvons demander au sprite animé jouer l'animation de l'effet Ensuite, ce nœud doit être retiré de la scène. Avec une version gratuite, ce code s' exécutera dans un seul cadre. Nous n'aurons pas l'occasion de voir l' animation se dérouler. Nous pouvons utiliser une nouvelle commande appelée poids pour suspendre ce code jusqu'à ce que quelque chose se passe. Ce que nous voulons attendre, c'est lorsque l'animation du sprite sera terminée avec le nœud racine des pièces sélectionné Nous devrons modifier certains des paramètres par défaut du nœud rigide. Par défaut, le signal saisi par le corps ne se produit que lorsque les collisionneurs se chevauchent Mais comme la physique est appliquée à la fois au personnage et à la pièce, cela ne se produira pas. Le collisionneur des personnages poussera plutôt le collisionneur de pièces Nous pouvons modifier ces paramètres pour permettre au signal de se produire lorsque les collisionneurs entrent en contact En réglant le moniteur de contacts vrai maximum de contacts signalés à toute valeur supérieure à zéro, mais nous ne devrions vraiment en avoir besoin que d'un ensuite. Développez la section de désactivation. La plupart des gens ne voudraient pas que les pixels pivotent Nous pouvons donc verrouiller la rotation des pièces en cliquant sur cette case à cocher. Dans la plupart des jeux, les pièces de collection appartiennent à l'une des deux catégories suivantes Ceux qui planent dans les airs et ceux qui sont projetés après avoir cassé une boîte ou vaincu Nous pouvons choisir la première option en définissant la propriété freeze sur true et en changeant le mode freeze en mode cinématique Désormais, la pièce ne sera pas affectée par la physique, y compris la gravité, mais elle entrera tout de même en collision avec d'autres objets Si nous voulons activer la gravité ou faire lancer la pièce, il suffit de régler freeze false et d'appliquer les forces que nous voulons Nous voulons également nous assurer que nos pièces ne sont collectées que par le personnage du joueur, non par les ennemis ou tout autre personnage. Le moyen le plus simple d'y parvenir est d'utiliser des couches de collision. Jusqu'à présent, tout dans notre jeu a utilisé la couche de collision par défaut, la couche 1. En utilisant différentes couches de collision, nous pouvons facilement contrôler quels objets réagissent aux autres objets ou les ignorent. Laissons la couche par défaut, la couche 1, représenter le terrain. Étant donné que la plupart des objets, sinon tous, devront entrer en collision , par défaut, nous souhaiterons peut-être avoir différents types d' environnements avec différents types de collisions à l'avenir Laissons simplement le monde utiliser les huit premières couches de collision ouvrant la scène de Rogers Nous pouvons remplacer sa couche de collision par la couche neuf et laisser le deuxième bloc représenter les couches de collision de nos joueurs. De même, nous pouvons placer les personnages ennemis sur la couche 17. Et supposons que le troisième bloc représente les couches de collision de nos ennemis. Enfin, les pièces peuvent se trouver sur la couche 25, le quatrième bloc représentant un trésor. en collision avec la section masquée Cet objet va entrer en collision avec la section masquée des couches de collision La seule chose avec laquelle nous voulons que la pièce entre en collision, c' est l'environnement. Et le joueur à qui nous avons attribué les couches 1 et 9 pièces ignorera désormais les collisions avec des ennemis ainsi que d'autres trésors. Je vais faire entrer le personnage du joueur en collision avec des ennemis, les ennemis entrent en collision avec le joueur ainsi que d'autres Nous devons également ouvrir les paramètres du projet et attribuer un nom à chacune de ces couches de collision afin de pouvoir facilement nous souvenir de la raison pour laquelle nous les avons réservées. Les noms seront affichés sous forme d'infobulle lorsque vous curseur sur la couche de collision dans l'inspecteur Il y a une deuxième série de sprites dans le pack d'actifs pour une pièce en or de deux Dupliquons notre scène de pièces d'argent et renommons-la en pièce d'or Et remplacez les sprites à pièces d'argent par des sprites à pièces d'or si nous voulons que les différentes pièces aient des dénominations différentes Nous pouvons également ajouter une valeur entière exportée à notre script et lui donner une valeur par défaut de un pour mon jeu. Je vais faire en sorte que les pièces d'or aient une valeur de dix pièces d'argent. Bien que cela soit peu probable, il est possible qu'une fois que le joueur entre en collision avec la pièce, il entre en collision avec la même pièce une seconde fois avant qu'elle ne disparaisse Pour éviter cela, nous devons mettre le masque de collision de la pièce à zéro, afin d' éliminer toute possibilité qu'elle entre en collision avec quoi que ce soit une fois qu'elle a été collectée En plaçant une pièce de chaque pièce dans notre niveau, le joueur peut désormais les récupérer. Nous pouvons également placer l'eau sur une couche séparée du terrain et la faire entrer en collision avec les personnages et le trésor, et nommer la couche dans les paramètres du projet Nous avons maintenant des pièces de collection de valeur variable que le joueur sera incité à collectionner tout au long de notre jeu Dans la leçon suivante, nous allons créer une interface utilisateur avec un compteur pour montrer au joueur combien de pièces il possède. Je te verrai dans la prochaine leçon. 31. Interface utilisateur 3-3: Bonjour les amis. Dans la leçon précédente, nous avons créé des pièces de différentes valeurs que le joueur peut collectionner. Dans cette leçon, nous allons afficher nombre de pièces que le joueur possède sur l'interface utilisateur. Dans la scène principale de la plate-forme maximale, nous pouvons ajouter une interface utilisateur pour afficher toutes sortes d' informations importantes dont le joueur a besoin. Ces informations doivent être indépendantes de la caméra et toujours affichées avant tout le reste. Serez-vous tenté d'en faire un enfant de la caméra, comme nous l'avons fait avec le fond d'écran. Il existe un type non permettant de créer ce type de couche, appelé couche de canevas. Chaque nœud d'arsène possède un ordre de dessin basé sur son indice défini et sa position dans l'arbre de scène Mais une fois que tout a été traité par l'appareil photo en une seule image, tout cela devient le calque par défaut, le calque zéro. Par défaut, un calque de canevas dessine une toute nouvelle image sur le calque 1. plus, les couches du canevas sont remplies d'un nouveau type de nœud. En fait, nous en avons utilisé un dès la toute première leçon. Ils sont appelés nœuds de contrôle et sont marqués en vert. Pour afficher des chiffres à l'écran, nous pourrions utiliser un nœud d'étiquette, qui peut afficher le texte que nous voulons, mais cela ne correspond pas vraiment à notre esthétique du pixel art. Et notre pack d'actifs contient de jolis sprites numérotés, alors utilisons-les plutôt Nous pouvons ajouter des nœuds de contrôle à la couche de canevas appelés texture Rets pour afficher ces sprites à notre Ajoutons une texture pour un chiffre, autre pour les dix chiffres, et remplissons les deux avec Par défaut, vous devez définir une limite quant au nombre de chiffres que vous souhaitez afficher à l'écran. Conformément aux conventions de jeux tels que Mario et Donkey Kong, je plafonnerai le nombre de pièces à 99 et je donnerai au joueur une récompense supplémentaire pour 100 pièces collectées Nous devrions également ajouter une texture d'icône pour indiquer au joueur ce que signifie ce nombre et l'image d' une pièce de monnaie afin d'éviter de réorganiser manuellement les nœuds de contrôle individuels Sur la couche de canevas, il existe également des nœuds fournis par Godot, dont le but est d'organiser leurs nœuds enfants pour nous Ajoutons une boîte horizontale au canevas, nommons-la compteur de pièces et définissons nos autres nœuds comme enfants de la boîte. Ils sont automatiquement réorganisés pour s'adapter horizontalement à l'intérieur de la boîte. Je vais positionner ce compteur à 32 pixels du coin. Et en augmentant l'échelle de deux, c'est beaucoup plus facile à remarquer et à lire Nous pouvons ensuite modifier les paramètres des contrôles individuels pour déterminer comment ils seront dessinés par rapport à leur conteneur parent. J'aimerais que l'icône soit affichée, ajustée proportionnellement à sa largeur Et agrandissez en fonction de la taille du conteneur parent. J' aimerais doubler les chiffres pour qu'ils soient plus faciles à lire. Sachant qu'il y a cinq pixels de large, je vais définir leur largeur minimale personnalisée à dix pixels. Ajustez-les proportionnellement à leur hauteur. Et conservez leur ratio hauteur/largeur tout en les gardant centrés sur le parent. Remarquez comment les commandes du canevas sont dessinées ici, dans l'eau. Mais si nous appuyons sur Play, ils s'affichent dans le coin supérieur gauche de la fenêtre. Si vous vous souvenez de la première leçon, l'image dessinée à l'écran par défaut est ce rectangle bleu. Si cela peut vous aider, vous pouvez masquer le niveau, personnage et la caméra lorsque vous travaillez sur le canevas en cliquant sur les icônes. N'oubliez pas de les dévoiler lorsque vous serez prêt à tester votre jeu Essayez de tester la façon dont votre compteur est affiché à l'écran et vérifiez à quoi il ressemble pendant que vous jouez Pour que le compteur fonctionne, nous devons écrire un script pour celui-ci. Je vais le mettre dans un nouveau dossier de scripts pour l' interface utilisateur et le nommer Counter. Comme la nature d'un compteur de pièces n'a rien à voir avec l'organisation d'une boîte horizontale, je vais lui demander d'étendre le type de contrôle plus générique. Au lieu de cela, nous aurons besoin de références à chacune de nos recs de texture que nous souhaitons modifier pendant la phase de préparation Nous aurons également besoin d'une liste de textures avec lesquelles les échanger, représentant chacun de nos nombres de 0 à 9. Nous pouvons les stocker dans un tableau exporté de textures à deux D nommés chiffres de soulignement Un tableau est similaire à une liste, dans ce cas une liste de deux textures en D ou des images de nombres affichées dans l'inspecteur. Nous pouvons cliquer sur ce tableau exporté pour l'agrandir et lui donner une taille de dix. Les éléments du tableau sont commodément numérotés de zéro à neuf. Ce sont les indices que nous utilisons pour accéder aux différents éléments du tableau. Renseignez chaque index de tableau avec le chiffre correspondant du pack d'actifs Ce script a besoin d'une fonction que nous pouvons appeler pour définir le numéro affiché. Je vais l'appeler set value et prendre un entier comme paramètre. Sachant que ce compteur est uniquement destiné à afficher un nombre compris entre 0 et 99, appliquons d'abord cette règle En bloquant la valeur entre ces chiffres. Nous pouvons définir la texture affichée par la texture k comme étant des chiffres à un index. Qu'est-ce que l'indice ? C'est le même que le chiffre lui-même. Mais comment extraire le chiffre unique ? Nous pouvons utiliser un opérateur courant en programmation appelé module, représenté par le signe du pourcentage, qui renvoie le reste d'une valeur de division Ten renverra le chiffre, qui est l'indice matriciel de la texture que nous voulons afficher. Nous pouvons ensuite également définir le chiffre des dizaines en effectuant une division au lieu du module Maintenant, nous avons besoin que le joueur entre en collision avec nos pièces pour mettre à jour notre interface utilisateur d'une manière ou Mais ils existent dans différentes scènes, ce qui rend les signaux ou les appels de méthode quelque peu difficiles. Pour combler cette lacune, nous pouvons déléguer cette responsabilité au game manager puisqu'il est facilement accessible en tant que nœud racine et a accès à tous les enfants. Ouvrir le script de la pièce. Lorsque la pièce est collectée, nous pouvons obtenir une référence à la racine de la scène en utilisant racine du signe dollar suivie du jeu qui est le nom du nœud racine de la scène. Appelez ensuite une méthode dans le script du gestionnaire de jeu que nous n'avons pas encore écrite. Nous collecterons les pièces et communiquerons la valeur de la pièce collectée. Pour passer au script du gestionnaire de jeu, nous aurons besoin d'une référence au compteur de pièces pendant la phase de préparation. Il n'est pas nécessaire que ce soit une boîte horizontale. Comme nous n'accédons rien de spécifique à ce type de nœud, nous tenons vraiment à ce qu'il s' agisse d'une forme de nœud de contrôle. Tout d'abord, nous pouvons définir cette méthode de collecte de pièces, en prenant la valeur entière de la pièce comme paramètre. Ensuite, nous ajouterons la valeur de la pièce aux données du fichier. Mettez ensuite à jour le compteur sur l'interface utilisateur, en définissant sa valeur sur la nouvelle valeur monétaire des données du fichier. De plus, cette mise à jour du compteur doit également avoir lieu lorsque le joint est chargé pour la première fois. Testons également le compteur en définissant sa valeur sur quelque chose de aléatoire, comme 77. parcourant la scène, nous pouvons constater qu' elle était bel et bien réglée sur 77. Et lorsque nous heurtons une pièce d'argent, le compteur augmente d'une unité La collecte de la pièce d'or l' augmente également de dix. N'hésitez pas à tester le réglage du compteur sur n'importe quel nombre aléatoire , négatif ou supérieur à 99. Mais n'oubliez pas de supprimer cette ligne. Lorsque vous avez terminé, Dieu nous avertit que nous divisons par un entier. En cliquant sur l'avertissement, nous accédons au script de la pièce, où nous sommes effectivement en train de diviser par un entier, et les valeurs décimales sont ignorées Comme c'est fait exprès, nous pouvons ajouter une ligne supplémentaire ici lors de la division en nombres entiers. Pour ignorer cet avertissement, l'interface utilisateur affiche désormais le nombre de pièces que le joueur a collectées. Dans la leçon suivante, nous ajouterons un objet de vie à collectionner et en assurerons également le suivi Je te verrai dans la prochaine leçon. 32. 3-4 vies: Bonjour les amis. Dans la leçon précédente, nous avons créé un compteur de pièces à afficher sur l'interface utilisateur. Dans cette leçon, nous allons ajouter un objet de vie à collectionner à notre jeu Commençons par notre scène de premier niveau. L'atout que j' aimerais représenter, la vie du joueur dans mon jeu, est un crâne doré. Et je ne pense pas qu'il serait bon de le voir affecté par des forces telles que la gravité. Contrairement aux pièces de monnaie, je veux qu'elle paraisse plus inquiétante et mystérieuse Ce sera toujours quelque chose qui flottera jusqu'à ce qu'il soit collecté Nous allons utiliser un nœud en zone 2 D pour définir ses propriétés de base et le renommer Golden Skull Ajoutez ensuite un sprite animé. Deux D, créez une ressource Sprite Frames et remplissez-la avec les actifs Golden Skull Sprite Boucle de lecture automatique et réglage du nombre d'images par seconde. Ensuite, comme pour la pièce, ajoutez une deuxième animation nommée Effect et remplissez-la avec les sprites à effet crâne Pour en revenir au crâne et avoir une bonne vue dans l'éditeur, nous pouvons y ajouter une forme de collision , qui sera un cercle. Je vais ajuster le sprite d'un pixel vers la gauche et le bout de la pomme pour qu'il soit mieux centré Et ajustez le planeur Circle en fonction de vos besoins. Ajoutez un lecteur de flux audio à deux nœuds D. L'effet sonore que j'ai sélectionné pour le crâne sera teinté, ouvert, créé par une soupe new age Mais je l'ai légèrement réduite dans un éditeur audio, elle est quand même plus longue que l'animation Je vais donc devoir ajouter une ou deux images vides la fin de l'animation pour que le son puisse se terminer. Enregistrez ensuite la branche du crâne comme position de scène, le crâne où elle pourra être collectée lors de notre test, ouvrez la scène du crâne et ajoutez un script au nœud racine. La plupart des comportements du crâne seront très similaires à ceux du script monétaire que nous avons écrit précédemment. Commençons par copier-coller le script de la pièce dans le script du crâne Mon script de crâne n'a pas besoin de valeur, puisque chaque crâne représentera une vie. Mais il aura toujours un sprite et un effet sonore en cas de collision. Nous pouvons toujours suivre la même logique, sauf la partie où nous disons au game manager que le joueur a collecté une pièce. Séparons cela en une méthode privée distincte appelée underscore collect et appelons la méthode depuis le même endroit passant au script coin, nous pouvons apporter les mêmes modifications au format. Désormais, tout est presque identique dans ces deux scripts , à l'exception du contenu de cette méthode de collecte unique qui étend différents types de nœuds. Si nous sélectionnons la pièce et le crâne, nous pouvons constater qu'ils ont tous deux les propriétés d'un objet de collision deux D. Nous ne voulons pas écrire exactement le même script Chaque fois que nous créons un nouveau type de trésor à ajouter à notre jeu, nous pouvons définir un script plus abstrait nommé trésor et étendre l'objet de collision deux D. Ici, nous pouvons écrire tous les comportements courants du différents types de trésors pour notre jeu, copiant tout le contenu dans le nouveau script de trésor. Le comportement par défaut de la méthode de collecte peut être vide car de trésor est trop abstrait concept de trésor est trop abstrait pour savoir ce que nous devons en faire une fois collecté. Le but de cette méthode est simplement de dire à Godot que tout ce qui est un trésor peut être collecté Donnez à ce script le nom de classe Treasure. Comme les pièces et crânes sont des types d'objets de collision différents, nous pouvons leur faire gagner du trésor et bénéficier tous les avantages utiles que contient le script du trésor Maintenant, dans notre script de création de pièces, nous avons des éléments spécifiques aux pièces, comme la valeur. Nous pouvons annuler le comportement de collecte au lieu de ne rien faire pour indiquer au game manager qu' une pièce a été collectée Une méthode qui remplace une autre méthode est indiquée par cette flèche bleue Vous avez peut-être remarqué que cette flèche apparaît chaque fois que nous avons remplacé la méthode prête De même, lorsque le crâne est collecté, il indiquera au game manager qu'un crâne a été collecté. Désormais, quel que soit le type de trésor collecté, ces mêmes comportements se produiront automatiquement pour chacun d'entre eux. Mais il faut faire attention et s'assurer que tous les trésors possèdent ces nœuds enfants, et que le sprite animé doit avoir un effet d'animation traiter différents types d'objets comme ayant tous un ensemble de comportements similaires est appelé polymorphisme Toutes les pièces et tous les crânes peuvent être traités comme des trésors. La seule différence sera ce qu'ils feront lorsqu'ils seront collectés. Tout nouveau type de trésor que nous ajoutons peut également suivre ce modèle. passant au script du gestionnaire de jeu, nous pouvons simplement ajouter une méthode de collecte de crânes, augmentant ainsi la vie du joueur d'une unité. Lorsque cela se produit, en dupliquant la référence du compteur de pièces, nous pouvons ajouter une référence au compteur de vies, puis également mettre à jour l'interface utilisateur lorsqu'une vie est ajoutée Puisque la méthode prête consiste à effectuer deux tâches différentes et indépendantes, nous devons les séparer en différentes méthodes pour les organiser. Écrivons des limites d' unités privées et des méthodes d'interface utilisateur informatique qui exécutent chacune de ces tâches de manière isolée et sont appelées par la méthode Ready. Je suivrai les conventions établies par Mario et Donkey Kong, qui accordent au joueur une vie supplémentaire après avoir collecté 100 pièces Lorsque le nombre de pièces déposées est supérieur ou égal à 100, soustrayez 100 pièces, ajoutez un point de vie, et mettez également à jour le compteur de vies Ensuite, nous pouvons dupliquer le nœud du compteur de pièces sur la couche de toile et le renommer en Lives Counter Pour le placer dans le coin supérieur droit, je vais modifier la propriété de direction de la mise en page de droite à gauche. Puisque mon compteur de pièces se trouvait 32 pixels du côté gauche de l'écran. Je peux refléter cela en soustrayant 64 pixels pour ajouter le même rembourrage sur le L'inversion du sens de mise en page a également inversé l'ordre des nœuds enfants J'aime que l'icône soit sur le côté droit, mais le chiffre un et les dizaines sont inversés. Je vais les faire glisser dans la bonne position. J'ai modifié le zéro chien pour qu'il s'adapte mieux à l'interface utilisateur en supprimant les particules au-dessus de l'image du crâne pour créer ce Png à zéro point à utiliser comme texture d'icône. Enfin, dans les cas où la pièce n'est pas gelée, je veux qu'elle reste immobile pendant qu'elle est collectée. heure actuelle, la collision de Rogers avec la pièce ajoute de la force au corps rigide de la pièce, la faisant bouger pendant que l'animation de l'effet apparaît dans le script de la pièce. Dans la méthode de collecte, nous voulons accéder aux propriétés des modes gel et gel du corps rigide deux D. Mais elles sont inaccessibles pour ce script car il étend l'objet de collision deux D et Godot n' aime pas que nous les paramètres de collision lorsqu' une collision se produit Nous pouvons résoudre ces deux problèmes en utilisant une méthode intégrée nommée call deferred. La méthode d'appel différé indiquera à Godot de l'exécuter une fois la collision terminée Le traitement de l'appel différé prend un argument de chaîne du nom de la méthode que nous voulons appeler. Dans ce cas, set free a activé la valeur que nous voulons lui attribuer, ce qui est vrai. Ensuite, je dois également régler le mode de congélation sur une valeur définie à l'intérieur du corps rigide. Mode de congélation à deux classes D, statique. Un corps rigide statique ne bougera pas sous l' effet de forces ou de collisions, et c'est ce que j'aimerais. Cela empêchera la pièce de bouger une fois qu'elle été collectée avec le nœud racine du crâne sélectionné Définissez la couche de collision sur la couche de trésor et le masque de collision sur la couche de joueur. Connectez également le signal saisi par le corps à la méthode des crânes sur le corps saisi Nous avons désormais un compteur de points de vie et le joueur peut gagner plus de vies en collectant des crânes ou des pièces Dans la leçon suivante, nous allons créer un coffre au trésor rempli de butin de pirate Je te verrai dans la prochaine leçon. 33. 3-5 Poitrine: Bonjour les amis. Dans la leçon précédente, nous avons ajouté un trésor crânien à collectionner à notre jeu Dans cette leçon, nous allons créer un coffre rempli de trésors que le joueur pourra ouvrir. Je vais faire en sorte qu'un coffre au trésor soit un objet fixe qui semble être en arrière-plan afin que le joueur puisse marcher devant lui. Quand ils le feront, le coffre s'ouvrira et lancera une certaine quantité de pièces en l'air. À partir de la scène des niveaux, ajoutons un nœud de zone 2 au dossier des trésors. Avoir des comportements plus complexes que les autres objets du jeu. Un sprite animé ne suffira pas. Comme nos personnages, nous devrons utiliser un sprite à deux nœuds en D, puis utiliser un lecteur d'animation pour le contrôler et un arbre d'animation pour contrôler le joueur Définissons d'abord le sprite par défaut pour le nœud Sprite two D. J'utilise les sprites du coffre du navire marchand, pas celui du dossier Palm Tree Island J'en veux un où le coffre n'est pas verrouillé, juste fermé dans le dossier déverrouillé Je vais choisir le sprite numéro trois. Nous pouvons également ajouter une forme de collision, qui devrait être un rectangle et l'étirer pour couvrir toute la poitrine. Et un lecteur de flux audio pour ajouter des effets sonores. Renommez le coffre à nœuds de branche et enregistrez-le en tant que scène à part entière dans le dossier des trésors Notre test aura besoin d'un script pour le contrôler, qui devrait également se trouver dans le dossier Treasure Scripts. Le coffre aura une variable exportée pour savoir s'il est ouvert ou non. La valeur par défaut d' un lingot étant fausse, le coffre n'est pas ouvert Le coffre devra également savoir ce qu'il contient. Ajoutons une variable entière pour spécifier la valeur totale de toutes les pièces à l'intérieur du coffre et donnons-lui une valeur par défaut de un. Cela n'aurait aucun sens de permettre à ce nombre d'être un nombre négatif ou un nombre ridiculement élevé Nous pouvons restreindre la plage de valeurs de la variable exportée en ajoutant plage de soulignement et en spécifiant à la fois une valeur minimale et une valeur maximale Maintenant, ce nombre ne peut pas être défini comme négatif ou trop élevé. Nous pouvons également ajouter une variable nommée underscore booty sous forme de tableau de trésors pour représenter les véritables nœuds de pièces à l'intérieur du coffre au trésor Pour fabriquer ces pièces, nous aurons besoin de scènes complètes représentant à la fois la pièce en argent et la pièce en or. Dans la méthode Ready, nous pouvons ensuite écrire un algorithme simple pour instancier les pièces nécessaires pour obtenir la valeur totale Bien que la valeur totale soit supérieure à dix, nous pouvons réduire la valeur totale de dix et instancier une pièce d'or Cette pièce nouvellement instanciée peut être ajoutée au booty array par Cela se répétera jusqu'à ce que la valeur totale soit inférieure à dix ou sera complètement ignoré S'il était déjà inférieur à dix, répétez le processus. Tant que la valeur totale est supérieure à zéro, nous pouvons la réduire d'un et instancier une pièce en argent, puis la placer au dos de la matrice À la fin de ce processus, la valeur totale sera nulle et le coffre contiendra un tas de pièces représentant ce montant, prêtes à apparaître Lorsque le joueur ouvre le coffre, nous pouvons ensuite parcourir le butin un objet à la fois à l' aide d'une boucle, régler la position globale de chaque objet sur la même position globale que le coffre, mais également déplacer le coffre vers le haut d'une tuile Transformez la propriété de gel fausse physique qui sera appliquée à la pièce. Nous pouvons appliquer une force aléatoire à chaque pièce pour la disperser dans les airs lorsque le coffre s'ouvre Pour ce faire, nous devons créer une variable de générateur de nombres aléatoires et initialiser avec un nouveau générateur de nombres aléatoires pendant la phase de préparation Ajoutez ensuite une impulsion à l'objet. La direction de l' impulsion doit être d' une tuile multipliée par un nombre aléatoire. Je vais définir ma plage aléatoire 5-10, puis ajouter le vecteur deux, droite une tuile, et multiplier par un nombre aléatoire entre moins un et un positif. Les nombres négatifs le feront tourner vers la gauche au lieu de la droite. Cela devrait produire une fontaine de pièces satisfaisante. Lorsque nous devons ajouter l' objet à l'arbre des scènes, je préférerais en faire un frère ou une sœur , et non un enfant Je vais d' abord chercher le parent du coffre , puis j'ajouterai la pièce en tant qu'enfant. Lorsque cela est fait, nous pouvons effacer le tableau puisque le coffre est maintenant vide. En sélectionnant le lecteur d'animation, nous pouvons commencer par créer une animation inactive fermée, qui ne nécessite qu'une piste pour le sprite en deux D, en envoyant sa texture au même sprite qu'il possède déjà Réduisez ensuite la durée de l' animation à 0,1 seconde. Dupliquez l'animation inactive fermée et créez une animation idéale ouverte. Et change le sprite au numéro huit. Nous pouvons ensuite créer une animation fermée en changeant le sprite, comptant à rebours de 8 à 4 pour que la durée de l'animation soit de 0,5 seconde Nous pouvons également ajouter une piste audio à ces animations et fermer le coffre. Son Les sons que j'utilise pour ouvrir et fermer le coffre ont été créés par le frisbee S'il s'agit d'un article sur FreeSound.org dupliquant dupliquant Nous pouvons créer une animation ouverte en inversant simplement les sprites et en modifiant l'effet sonore Mais dans l'animation ouverte, nous pouvons également ajouter une piste d' appel de méthode à l'animation. En ajoutant une image clé pendant l' image lorsque le couvercle est ouvert, nous pouvons utiliser la méthode du pillage pour faire apparaître les pièces, changer d'arbre d'animation, définir le nœud de base d'expression avancé comme nœud racine des coffres et la propriété du joueur anime sur le lecteur d' Créez ensuite une nouvelle machine à états pour l'arbre d'animation. Nous pouvons ajouter nos quatre animations à la machine à états et les relier à un cycle de transitions. La transition du mode inactif fermé à état ouvert sera déclenchée par is open, puis open to open idle à la fin de l'animation. De même, le mode « open idle to close » se produit lorsque rien n'est ouvert, et close idle » à la fin de l'animation Cette structure nous permet d' initialiser le coffre comme étant ouvert ou fermé lorsque la scène commence en fonction de la valeur de is open également En effectuant plusieurs transitions depuis le début et en définissant leurs conditions, sélectionnez le nœud racine et remplissez les scènes pleines de pièces en les faisant glisser du système de fichiers vers l'inspecteur Nous devons également définir la couche de collision pour placer le coffre sur la couche de trésors et lui demander détecter les collisions sur la couche joueur. Et réglez l'indice Z du coffre pour qu'il soit derrière le joueur. Passez au panneau des nœuds et connectez le signal saisi par le corps à la poitrine elle-même. En ajoutant une méthode saisie sur le corps, si ce corps est un personnage, nous devons définir is open sur true, ce qui déclenche l'animation ouverte, qui à son tour déclenche la méthode du pillage faisant apparaître le trésor Placez un coffre au trésor quelque part dans votre niveau. Essayez de cliquer sur le bouton Is Open pour ouvrir et fermer le coffre et modifier la valeur totale des pièces qui seront générées. Lorsque le coffre s'ouvre, jouez à la hanche, essayez d'ouvrir le coffre récupérer vos pièces durement gagnées. Nous avons maintenant un coffre au trésor qui génère une rafale de pièces que le joueur peut collecter La leçon suivante ajoutera un cadenas au coffre au trésor et une clé que le joueur pourra utiliser pour le déverrouiller. Je te verrai dans la prochaine leçon. 34. 3-6 Lock & Key: Bonjour les amis. Dans la leçon précédente, nous avons créé un coffre au trésor qui fait apparaître une fontaine de pièces lorsqu'il est ouvert Dans cette leçon, nous allons verrouiller le coffre et cacher une clé quelque part dans le niveau pour l'ouvrir. Commençons par dupliquer la scène des pièces d'argent pour en faire une scène clé Ouvrez la nouvelle scène clé, sélectionnez le sprite animé et remplacez les sprites de la pièce par les sprites clés Et la touche possède également son propre effet d'animation. Je vais juste changer l'effet sonore des touches pour une autre pièce. Son La clé aura besoin d'un nouveau script hérité du trésor enregistré dans le dossier des scripts du trésor Tout ce que nous avons à faire est de dire au script du game manager quand la clé est collectée. Le script du trésor s' occupera de tout le reste. remplacer le script du nœud racine par ce nouveau script clé, il suffit de cliquer dessus et de le faire glisser sur le nœud Comme il s'agit toujours d'un script de trésor, le comportement du signal est toujours lié au passage à la scène de jeu. Je n'aurai qu'une seule clé par niveau dans mon jeu. Au lieu de compter les clés comme nous l'avons fait avec les pièces, j'utiliserai simplement une seule texture pour indiquer si le joueur possède ou non la clé. Je vais ajouter une texture endommagée à l'interface utilisateur, remplir avec la clé par défaut Sprat, dont l'échelle est doublée pour être plus visible, et placez-le sous la pièce Cliquez ensuite sur l' icône pour la masquer, puisque le joueur ne commence pas par la clé dans le script du game manager, nous pouvons définir une référence à cette texture dans la phase de préparation lorsque le joueur récupère la clé. Nous pouvons définir une variable dans les données du fichier dont la clé est vraie pour le joueur. Définissez également la propriété visible de l'icône en forme de clé sur true. Nous devrions également créer une autre méthode lorsque le joueur utilise la touche pour définir filet has key sur false et masquer l'icône sur l'interface utilisateur. passant au script de données, nous pouvons ajouter la variable clé has et définir sa valeur par défaut dans la méthode d'initialisation Placez une clé quelque part près du niveau et essayez de la récupérer. Pour verrouiller le coffre, nous devons ajouter une autre variable d' intimidation afin que le coffre sache s'il est actuellement verrouillé ou non Nous pouvons ensuite modifier la logique du code de collision. Si le coffre est verrouillé et que le joueur possède la clé, set passe à faux et indique au responsable du jeu que le joueur a utilisé la clé. Si le coffre n'est pas verrouillé, set est ouvert à true. Je n'utilise pas ElSef ici parce que je veux que le coffre se déverrouille et s'ouvre en une seule collision En sélectionnant le lecteur d'animation, nous devrons ajouter d'autres animations. Commençons par dupliquer l'animation inactive fermée pour créer une animation inactive verrouillée Et remplacez le sprite par le sprite inactif. Dupliquez ensuite l'animation de fermeture pour créer une animation de verrouillage. Remplacer le sprite 3-2 par un, raccourcir la durée de l' animation à 0,3 seconde et émettre un son différent Cette fois, j'utilise Key Twist in Lock créé par Karen Keegan sur FreeSound.org. Nous pouvons ensuite dupliquer cette animation pour créer également une animation déverrouillée en inversant En passant à l'arbre d'animation, nous pouvons ajouter ces nouvelles animations à la machine à états. Et connectez-les. Avec une boucle de transitions similaire à celle que nous avons faite avec l'ouverture et la fermeture. Le coffre passera d'une idole fermée à une serrure. When is locked est défini sur true, puis de block à locked idle à la fin de l'animation. De même, il passera d'une idole bloquée à une idole verrouillée lorsqu'elle est verrouillée est définie sur false, puis à une idole fermée à la fin de l'animation déverrouillée Nous pouvons alors également démarrer le coffre à l'état inactif verrouillé s'il est verrouillé, mais les conditions pour démarrer le coffre comme fermé et verrouillé peuvent être vraies dans les deux cas. Nous ajouterons la condition d'inactivité fermée, savoir que le coffre ne doit pas être ouvert ni verrouillé dans la scène de niveau. Nous pouvons maintenant modifier l'état verrouillé du coffre en cliquant sur le bouton N'oubliez pas qu'un coffre verrouillé doit être déverrouillé avant de pouvoir être ouvert Un coffre ouvert doit être fermé avant de pouvoir être verrouillé. Cela fonctionne, mais je n'aime pas ça. Le verrou disparaît tout simplement. Le pack d'actifs contient un cadenas déverrouillé en tant qu'actif distinct, alors utilisons-le Dupliquer la scène clé Pour créer une scène de cadenas, remplacez le type du nœud Sprite two D animé par un nœud Sprite two D, étant donné que le cadenas ne contient aucune animation, étant donné que le cadenas ne contient aucune animation, renommez les nœuds en conséquence et remplissez le sprite avec l' Changez la forme de collision en rectangle et redimensionnez-la pour l' adapter à la forme du verrou Supprimez sa collision avec le joueur et réduisez l'indice Z du cadenas pour qu'il corresponde à celui de la poitrine Je vais également définir le paramètre par défaut de la propriété de phrase sur false, car je veux toujours que le cadenas soit affecté par la physique Et supprimez le script en cliquant sur le bouton du script marqué d'un X rouge dessus. Le cadenas n'est pas un trésor et ne doit pas être récupéré par le joueur ouvrant le script du coffre, nous pouvons ajouter une scène compressée exportée pour le cadenas, comme nous l'avons fait avec la méthode du pillage Nous pouvons définir une autre méthode pour lancer le cadenas. Comme la méthode du pillage peut traiter un grand nombre de pièces, nous les avons instanciées lors de la méthode prête à l'emploi. Ensuite, lorsque le joueur ouvre le coffre, les pièces existent déjà en mémoire et sont simplement ajoutées à l'arbre des scènes. Il s'agit d'une méthode plus responsable pour instancier de grandes quantités de nœuds Mais comme le cadenas n'est qu'une seule chose, nous n'avons pas à nous soucier de l' instancier au moment où nous en avons besoin instancier au moment où nous en avons Dans la méthode Throw Padlock, nous pouvons définir une nouvelle variable pour le cadenas instancié Suivez ensuite la même logique que les pièces en repositionnant le verrou pour qu'il corresponde à l'emplacement du coffre En appliquant une force d'impulsion et en l'ajoutant à l'arbre de la scène, je vais supprimer la randomisation de la force ascendante Il est juste un peu jeté sur le côté. passant à la vue en deux D, j'ajouterai rapidement l'image du cadenas à la scène afin de pouvoir la repositionner là où je veux qu'elle commence, puis regarder ses valeurs transformées pour obtenir les positions x et y. Après avoir noté moins quatre et moins sept, je peux supprimer le nœud sprite, revenir à la vue du script et définir la position initiale du cadenas comme étant la position de la poitrine plus le vecteur deux, moins quatre , moins sept. Maintenant, le cadenas apparaîtra dans la position exacte où il semble correspondre au sprite verrouillé et sera jeté N'oubliez pas de remplir la scène pleine en faisant glisser le cadenas du panneau du système de fichiers vers l' inspecteur, en sélectionnant le lecteur d'animation, sélectionnant le lecteur d'animation à l'animation déverrouillée et en ajoutant une piste d' appel de méthode pendant l'image. Lorsque le cadenas a disparu, nous pouvons appeler la méthode Throw Padlock nous pouvons appeler Maintenant, lorsque le joueur récupère la clé et touche le coffre au trésor, le cadenas est jeté de côté, le coffre s'ouvre et le joueur est inondé Nous avons maintenant une clé qui permet de déverrouiller notre coffre au trésor. Dans la leçon suivante, nous ajouterons un objectif final à nos niveaux. Je te verrai dans la prochaine leçon. 35. Carte 3-7: Bonjour, mes amis. Dans la leçon précédente, nous avons verrouillé le coffre au trésor et ajouté une clé pour le déverrouiller. Dans cette leçon, nous allons créer un objectif final pour nos niveaux. J'utiliserai les petites cartes comme objectif pour mes niveaux, car cela impliquera facilement pour le joueur que Roger suit chaque segment de carte pour trouver le suivant et assembler une carte au trésor complète. C'est un concept assez simple pour que je n'aie pas besoin de l'expliquer. Et il fournit également un cadre pour la structure des niveaux. Commençons par dupliquer la scène du crâne pour créer une petite carte Une scène renomme le nœud racine. Sélectionnez le sprite animé et remplacez les sprites crâniens Pour la petite carte, un sprite. J'utiliserai les sprites d'entrée et de sortie ensemble pour créer l'animation de l'effet Changez ensuite la forme de collision en rectangle et redimensionnez-la pour l'adapter au sprite J'utiliserai le son du papier produit par Brevceps comme effet Comme pour tous les autres trésors, nous pouvons lui donner un script de trésor nommé Small Map Inheriting from Treasure Il suffit de dire au game manager que la carte a été collectée. Basculez le script sur le nœud racine pour le nouveau script de petite carte. Dupliquez ensuite cette scène trois fois pour créer une petite carte. Deux, trois et quatre. Remplacer les sprites de l'animation par défaut par les sprites correspondants du pack d'actifs pour la petite Cependant, je vais modifier l'animation de l'effet car lorsque le joueur récupère cette pièce, il a terminé la totalité de la carte. Une fois l'effet activé, je jouerai l'animation de déploiement de la grande carte, suivie de l'animation inactive, de l'animation de pliage, puis de l'effet de sortie Cela permettra au joueur de savoir que les petites cartes se sont combinées pour former une carte plus grande et que son objectif est proche. Lorsque le joueur récupère la petite carte, le niveau est terminé. Et j'aimerais récompenser le joueur avec une courte fanfare, suivie par le passage de l'écran au noir avant revenir au menu de sélection des niveaux Passons à la scène de jeu en deux dimensions. Nous pouvons recouvrir l'écran en noir avec un nœud appelé Color Wrecked et le nommer, le faire disparaître dans l'inspecteur, changer la couleur en noir Développez ensuite la section de mise en page et sélectionnez Full Wrecked parmi les ancres Liste déroulante prédéfinie pour s'assurer qu'elle figure toujours au premier plan, assurez-vous qu'elle est positionnée en bas de la branche de l'interface utilisateur ou donnez-lui une valeur d'indice Z plus élevée que tout le reste Nous ne voulons pas que cela bloque les entrées de la souris sur les commandes de l'interface utilisateur. Mais derrière, élargissez également section de la souris et dites Color Wreck d' ignorer les saisies de la souris Désormais, tout l'écran sera noir, ce qui est idéalement le début de chaque scène de notre jeu. Cela nous gêne lorsque nous développons cette scène. Masquons-le par défaut pour qu' il soit plus facile de le copier dans d'autres scènes. Enregistrons-le en tant que scène, puis ouvrons-le pour que ce rectangle noir s'estompe Il faudra un script qui appartient au dossier des scripts de l'interface utilisateur. Tout comme nous avons utilisé des interpolations pour déplacer la caméra, nous pouvons également utiliser des interpolations pour ajuster d'autres propriétés au fil du temps, telles que Définissons d'abord deux couleurs en haut du script, l' une pour le noir et l'autre pour le clair. Le noir a des valeurs rouges, vertes et bleues de zéro et une valeur alpha de un. Alors que le clair a un alpha de zéro, alpha est une mesure de transparence. Nous aurons également besoin d'une variable privée pour l'interpolation des couleurs. Commençons par estomper pour effacer car le rectangle est actuellement noir Tout comme pour l'appareil photo, il est conseillé de vérifier d'abord si le préadolescent existe déjà et fonctionne, et si c'est le cas, de le tuer Créez ensuite l'interpolation. Inutile de s'embêter avec les transitions ou les assouplissements ici, le linéaire est une bonne solution. Intercalez ensuite une propriété sur ce nœud lui-même, la propriété de couleur, avec la valeur cible de clear sur une durée d'une seconde Nous voudrons savoir quand ce comportement sera terminé, afin de pouvoir renvoyer un signal à partir de cette méthode pour nous indiquer quand l'interpolation des couleurs est terminée spécification d'un type de retour pour une déclaration de méthode dans le script Gudo se fait après les paramètres indiqués par une flèche Comme le passage au noir sera identique à l'exception du changement de couleur, changeons le nom de cette méthode fondu et prenons une couleur comme paramètre, puis utilisons cette couleur comme valeur cible Nous pouvons alors écrire fade to clear, pour simplement appeler fade passing in clear comme argument. De même, écrivez Fade to Black. En appelant fade, en passant le noir comme argument. Ces deux méthodes peuvent renvoyer les mêmes signaux renvoyés par fondu. Pour passer au script du gestionnaire de jeu, nous devrons définir une référence au fondu pendant la phase rouge. La toute première chose à faire lorsque la scène est chargée est de définir la propriété visible du fondu sur true, afin que le joueur ne voie que du noir. Ensuite, lorsque toutes les initialisations sont terminées et que le jeu est prêt pour que le joueur commence à jouer, nous pouvons indiquer au fondu de disparaître et attendre le signal pour qu'il soit terminé À ce stade, nous devrions donner au joueur la possibilité de commencer à jouer au jeu. Définissons une référence au nœud du joueur pendant la phase de préparation et appelons une méthode que nous n'avons pas encore définie. Définir activé la transmission de la valeur true en tant qu'argument. En passant au script du joueur, nous pouvons ajouter une variable booléenne privée nommée underscore Définissez également la méthode set enabled, en prenant un paramètre booléen qui définit la variable privée Vérifiez ensuite cette valeur avant de traiter les entrées renvoyées. Si le joueur n'est pas réactivé dans le gestionnaire de jeu lorsqu'il récupère la carte, nous pouvons alors lui retirer le contrôle en réglant enabled sur false. J'aimerais aussi jouer une fanfare de victoire ici. Je vais donc ajouter un nœud de lecteur de flux audio nommé Fanfare et le remplir d'un court morceau de musique La fanfare que j'ai sélectionnée est Game Success Fanfare Short de L Boss sur FreeSound.org Une fois le joueur désactivé, nous pouvons Attendez la fin de la fanfare. Attendez que le fondu passe au noir. Changez ensuite de scène. Fixez un objectif à la fin de votre niveau. Appuyez sur Play. La scène est chargée avec un écran noir et s'estompe Le joueur ne peut pas bouger tant que le fondu n'est pas terminé. La collecte du trésor à la fin du niveau permet au joueur de perdre le contrôle, déclenche la fanfare et passe au noir Nous avons maintenant un moyen de terminer nos niveaux et une transition douce à l'écran. Dans la section suivante, nous allons donner la santé au joueur et lui permettre de subir des dégâts. Je vous verrai dans la section suivante. 36. 4-1 Dommages: Bonjour les amis. Dans la section précédente, nous avons créé un tas de trésors différents que le joueur peut collectionner. Dans cette section, vous donnerez de la santé au joueur, lui permettant de subir des dégâts et de mourir. Si vous avez terminé la mission, vos niveaux devraient être remplis de trésors à collecter par le joueur et placés stratégiquement pour manipuler son comportement si vous avez terminé les défis. Vous pouvez également avoir exporté une série de scènes pleines à craquer dans votre script de coffre qui ajoute des trésors supplémentaires au butin et fait apparaître des objets de trésor supplémentaires Vous pouvez également avoir une valeur minimale et maximale de pièces, le coffre générant un entier aléatoire entre les deux. Instanciation ensuite des pièces égales à cette valeur aléatoire. Vous avez peut-être tous saisi les diamants de couleur pour créer nouveaux trésors et leur avez donné un objectif unique à votre jeu donner de la santé aux personnages. Commençons par le script des personnages, où nous pouvons ajouter une nouvelle variable exportée pour définir la santé maximale des personnages. Il doit être limité à un nombre naturel uniquement. Quelque chose de 1 à 100 devrait suffire. Je ne vais probablement avoir un accord fiscal, un dommage à la fois, 100, ce sera beaucoup, et je vais définir la valeur par défaut sur cinq. Nous pouvons ensuite également déclarer une deuxième variable représentant leur état de santé actuel. Pour simplifier les choses, je suppose que lorsque personnages sont chargés dans la scène, ils ont atteint leur pleine santé, leur santé actuelle étant égale à leur santé maximale. Pendant la phase de préparation, nous pouvons ensuite écrire une méthode publique qui inflige des dégâts au personnage, en prenant le montant des dégâts comme paramètre. Pour l'instant, nous allons simplement réduire la santé actuelle du montant des dégâts, puis imprimer la santé actuelle pour voir le résultat. La plupart des jeux comme celui-ci incluent une brève période d'invincibilité après avoir subi Le moyen le plus simple d' y parvenir serait de désactiver les collisions pendant cette période. Mais le collisionneur du personnage ne se contente pas de subir des dégâts, il entre également en collision avec l'environnement Nous pouvons séparer ces responsabilités en ajoutant un autre nœud enfant à nos personnages, une zone deux D, appelée case Rt. La seule responsabilité de la boîte Rt est d'être détectée par les sources de dégâts et d' être activée ou désactivée sans affecter les autres aspects du personnage. Il aura également besoin d' un nœud enfant en deux D en collision pour déterminer sa forme. Pour le différencier des collisions normales du personnage, nous pouvons changer la couleur de la case Rt en une autre couleur, comme le vert. Il n'est pas nécessaire qu'elle soit identique à la capsule du personnage, mais c'est un bon point de départ avec le nœud hip box sélectionné. Changez la couche de collision en couche dix, faisant de cette couche la couche blessée par le joueur. Tout ce que nous voulons blesser, le joueur doit masquer couche 10 pour rechercher la zone de blessures du joueur. Pour tester cela, nous aurons besoin de quelque chose simple à notre niveau qui puisse blesser le personnage. Nous allons créer une nouvelle scène complète à l'aide de l'actif Spikes. Il s'agira d'un nœud à deux corps statique, car il ne bougera pas et ne sera pas affecté par la physique. Ajoutez un nœud Sprite Two D et remplissez-le d' une ressource sprite Ajoutez-y une forme de collision et transformez-la en rectangle. Il s'agira d'une surface solide praticable que les personnages traiteront comme si elle faisait partie du terrain Il doit couvrir toute la largeur du carreau, mais seulement atteindre environ un quart de la hauteur du carreau. Cela empêchera également le joueur de se blesser s'il touche les pointes par le côté plutôt que par le haut Cela fait partie du niveau, mais pas du terrain ou de l'eau. Passons à la troisième couche, une nouvelle couche pour les dangers. Nous pouvons ensuite ajouter un autre nœud de collision pour infliger des dégâts, qui sera une zone deux D et renommons-le en hip box En fonction de la précision que vous souhaitez utiliser avec votre hanche, vous pouvez utiliser une forme personnalisée ici. Ajoutons un polygone de collision à deux nœuds en D en tant qu'enfant de la boîte à hanches dans l'inspecteur Nous pouvons voir que le polygone est un réseau de deux vecteurs compressés. En cliquant dessus pour le développer, le tableau a une taille de zéro et est actuellement vide. Il suffit de cliquer n'importe où dans l'éditeur pour ajouter un sommet au polygone J'en ajouterai un à chaque pointe de lance et un autre près du bord droit pour lui donner du volume Cliquez ensuite sur le sommet initial pour fermer le polygone. Il s'agit désormais d'une forme de collision personnalisée qui, si le personnage la touche, se blessera. Mais remarquez qu'il est divisé en deux formes plus petites, rouge et violet. En effet, comme la détection des collisions dans jeux vidéo est complexe et nécessite beaucoup de calculs, il est beaucoup plus facile de détecter une collision à l'intérieur d'un polygone convexe qu'à l'intérieur d' un polygone concave Les polygones concaves seront divisés en polygones convexes En faisant correspondre le polygone de collision à la hauteur de ce troisième pic, nous avons doublé le nombre de calculs nécessaires pour détecter les collisions avec ces pointes, car le moteur doit vérifier si le personnage touche le polygone rouge ou le polygone violet Pour simplifier les choses, supprimons le sommet du troisième pic, qui dans notre tableau est l' élément numéro deux Le polygone est désormais convexe et entièrement coloré en rouge. Et nous pouvons encore simplifier cela en supprimant le dernier sommet Cette boîte à hanches doit rechercher la couche 10 blessée par le joueur si vous voulez que les ennemis subissent des dégâts à cause des pointes 2, également de la couche 18 Enregistrez la branche des pointes comme scène à part entière Vous pouvez choisir de le mettre dans son propre dossier intitulé pièges ou dangers, mais comme aucun autre actif n'entre dans ces catégories, je vais simplement l'enregistrer en tant que décoration. Cependant, je vais créer un nouveau dossier de scripts nommé environment, puis y déplacer des éléments tels que le niveau de caméra, la parallaxe et l'eau avant ajouter un nouveau script nommé Hazard Attachez ensuite ce script au nœud racine des pointes. Le but du script sera de réagir lorsque la boîte à blessures d'un personnage entre en collision avec les pointes Appuyez sur case, sélectionnez la case à cocher pour accéder au panneau des nœuds et connectez le signal de la zone saisie en le connectant au nœud racine du pic. Cela changera le nom de la méthode pour qu'il apparaisse sur la zone de saisie, qui est un peu plus descriptif de ce qui se passe. Trouver le parent de la zone nous donne le personnage, puis nous devrions lui dire de subir des dégâts. Comme ce script peut être utilisé pour un certain nombre de dangers ou que vous pouvez ajuster ses dégâts à la volée, fixons le montant des dégâts infligés dans une variable exportée et la valeur par défaut de 1 devrait convenir. Donnez-lui une plage afin qu'il ne puisse pas être réglé sur une valeur négative ou nulle. Ouvrez les paramètres du projet et nommez les couches de collision, Hazard, joueur blessé et ennemi blessé. Placez des pointes quelque part dans votre niveau et essayez de sauter dessus. Vous pouvez voir dans le panneau de sortie qu'il reste désormais quatre points de vie à Roger à chaque collision, ce nombre étant réduit d'un. De plus, le joueur et les autres personnages peuvent être configurés pour marcher sur les pointes ou les traverser en fonction de pointes ou les traverser en fonction leur masquage de collision avec la troisième couche Nous avons désormais un danger de pointe qui inflige des dégâts au Dans la prochaine leçon, nous verrons comment le personnage réagit lorsqu' il subit des dégâts. Je te verrai dans la prochaine leçon. 37. Réaction 4-2: Oh, mes amis. Dans la leçon précédente nous avons créé des pointes qui infligent des dégâts au joueur Dans cette leçon, le personnage réagira en cas de dégâts. Lorsque nous créons des personnages, vous avez probablement remarqué que le pack d'actifs contient des animations à succès . Mettons-les en œuvre dès maintenant. Dans la scène du personnage où le lecteur d'animation est sélectionné, ajoutez une nouvelle animation nommée hit. Remplissez l'animation à succès à partir des pointes du dossier Without Sword Ajoutez également un effet sonore si vous souhaitez sélectionner l'arbre d'animation. Modifiez la machine à états sans épée. Nous pouvons ajouter l'animation à succès ici et y passer. Si le personnage est touché , revenez en arrière lorsqu'il n'est pas touché ouvrant le script du personnage, vous devrez créer la variable « is hit » de type booléen, puis la définir sur true lorsque le personnage subit La valeur doit être redéfinie sur false pour le personnage quitte l' animation sélectionnée pour le remettre en mouvement. L'animation elle-même peut exécuter cette fonction. Mais pour que l' animation puisse y accéder, la variable doit être exportée. Créons pour cela une nouvelle catégorie de santé nommée Combat. Nous pouvons ensuite ajouter une piste de propriétés à l'animation touchée pour remettre la valeur de is hit sur false. À la fin de l'animation, le personnage ne jouera désormais l' animation touchée qu'une seule fois lorsqu'il subira des dégâts. Cela interrompra toutes animations de mouvement qui se produisaient car elles sortent de la couche de mouvement de la machine à états Essayons-le. Ce serait bien si le personnage continue à subir des dégâts sans qu'il soit obligé de quitter le percuteur et d'y entrer à nouveau. S'ils restent sur les pointes, ils continueront à subir des dégâts De plus, il devrait y avoir une brève période après avoir subi des dégâts lorsque le joueur est invincible Nous pouvons résoudre ces deux problèmes avec une seule solution. Désactiver la zone de blessure du joueur , puis la réactiver, en sélectionnant le nœud de la boîte de blessures. Les propriétés situées en haut du panneau d' inspection, intitulées Surveillance et surveillable, peuvent être utilisées pour déterminer si des collisions se produisent ou non Comme il s'agit d'une boîte endommagée, elle est passive et ne cherche rien. La surveillance peut être définie sur false. Son objectif est d'être trouvé par des cases à cocher. Il doit être surveillable. Si le paramètre contrôlable devient faux, vous empêcherez boîtes de frappe d'entrer en collision avec cette boîte blessée et si redéfinissez la valeur vraie, vous déclencherez une nouvelle collision avec les pointes munies d'une boîte à hanches Nous pouvons alors faire le contraire. Réglez-le pour qu'il surveille les couches perchées, mais qu'il ne soit pas contrôlable. Il existe un type de nœud simple dans Godot à des fins de chronométrage, un chronomètre, que nous pouvons ajouter à notre personnage et le nommer Invincible Le délai par défaut est de 1 seconde, ce qui est bien, et nous voulons que cela ne compte qu'une seule fois à la fois. Cochez la case One Shot. Pendant la phase de préparation, nous pouvons définir une référence à la case du personnage et au chronomètre à partir duquel le personnage subit des dégâts. Nous pouvons régler monitorable sur false, démarrer le chronomètre, attendre le signal d'expiration et redéfinir monitorable sur et redéfinir monitorable Mais Godot ne nous laissera pas éteindre le collisionneur lors d'une collision Nous utiliserons set deferred pour indiquer à Godot régler monitorable sur false fois Si vous voulez avoir d'autres éléments dans votre jeu qui rendent le personnage invincible pendant un certain temps, nous pouvons également en faire une méthode publique en prenant un temps de flottement comme paramètre Transmettez-le ensuite dans la méthode de démarrage des minuteries. Désormais, la méthode take damage peut appeler la méthode become invincible, en passant 1 seconde en paramètre Mais je ne veux pas que les ennemis deviennent invincibles, juste le joueur J'ajouterai une variable de combat exportée indiquant la durée pendant laquelle le personnage est invincible après avoir subi des dégâts. valeur par défaut est fixée à zéro dans la méthode de zéro dans prise de dégâts Je vais ensuite vérifier si cette valeur n'est pas nulle avant d'appeler la méthode become invincible, en utilisant ce temps comme paramètre Si les ennemis ne veulent pas utiliser ce nœud chronomètre, ils ne devraient pas l'avoir dans leur arbre de scène. Au lieu de définir la référence au chronomètre en utilisant ready, j'utiliserai plutôt la méthode ready. Vérifiez la valeur de la durée invincible. Et si ce n'est pas zéro, définissez la référence à la minuterie. Désormais, seul le personnage du joueur doit avoir le nœud chronomètre et sa durée sera fixée à une valeur de durée invincible supérieure à zéro Mais les personnages ennemis doivent encore se faire ajouter des boîtes Rt. Sinon, leurs scripts essaieront de définir des références pendant la phase de préparation et provoqueront une erreur car elles n'existent pas. Leurs boîtes à troupeaux appartiendront également à la couche 18 au lieu de dix. Donnez ensuite à Roger une durée d' invincibilité supérieure à 0 seconde En l'essayant, le personnage debout sur les pointes continuera à subir un point de dégâts par seconde alors que nous le voyons compter à rebours sur le panneau de sortie Enfin, j'aimerais que le personnage soit éliminé de la source des dégâts. Modifions la méthode de prise de dégâts pour accepter également la direction de la force sous forme de vecteur deux. Réglez ensuite la vélocité du personnage comme étant cette direction multipliée par cinq tuiles. Le script de danger devra ensuite calculer cette direction et l'envoyer au personnage lorsqu'il le blesse. Il peut s'agir simplement de la position globale du personnage moins la position globale du danger. Pour que le danger connaisse sa position globale, il ne doit pas s'étendre sur deux D. Mais nous ne voulons pas que la distance soit un facteur, mais uniquement la direction. En mettant cela entre crochets, nous pouvons appeler la méthode normalisée Normalisé, nous allons prendre le vecteur et l'allonger ou le raccourcir pour qu'il ait une longueur de un Essayons-le. Le personnage qui touche les pointes est touché par une force arrière, possède une animation et devient invincible pendant 1 seconde avant d'être à nouveau touché Nous avons maintenant des personnages qui réagissent lorsqu'ils sont touchés. Dans la leçon suivante, nous ajouterons la santé du joueur à l'interface utilisateur et lui donnerons une potion pour récupérer de la santé Je te verrai dans la prochaine leçon. 38. 4-3 Récupération: Bonjour, mes amis. Dans la leçon précédente, notre personnage a réagi lorsqu'il subissait des dégâts. Dans cette leçon, nous allons ajouter la santé du joueur à l'interface utilisateur et créer des potions de santé Faisons d'abord une jauge de santé. Les ressources du pack d'actifs sont divisées en trois images distinctes pour la jauge et en une image rouge plate pour le remplissage. La jauge de santé elle-même ne sera qu' un nœud de contrôle de base avec deux enfants, l'un pour l'arrière-plan et l'autre pour le remplissage. Le nœud d'arrière-plan peut être une boîte horizontale trions automatiquement les trois images d' arrière-plan pour nous, qui sont toutes des épaves de texture Remplissez les textures avec les éléments du pack d'actifs Vous pouvez en masquer les autres branches sur votre chemin. Sélectionnez la zone horizontale d'arrière-plan, développez la section de remplacement du thème dans l'inspecteur et réglez séparation sur zéro pixel afin que les images soient dessinées sans aucun espace. Le remplissage n'est qu' un autre texte avec cette couleur rouge plate que nous pouvons redimensionner manuellement et adapter à la jauge Sélection du nœud racine des indicateurs de santé. Multipliquons-le quatre fois pour le rendre plus visible. Je pense que cela irait bien dans le coin inférieur gauche, je vais régler les préréglages d'ancrage en bas à gauche Et réglez le décalage du pivot y pour qu'il soit au bas de la jauge , soit 40 pixels. Réglez ensuite la position x de la jauge à 32 pixels pour ajouter le même rembourrage que la pièce ci-dessus, juste pour mettre en page et vérifier l'apparence pendant que vous jouez au jeu Zoom sur la nouvelle jauge de santé. Sélectionnez le champ Fill Textureect. Pour utiliser le remplissage, nous pouvons définir le mode d'expansion pour ignorer la taille, ce qui nous permet de définir manuellement la taille comme nous le voulons. Cliquez et maintenez sur la valeur de la taille X et déplacez votre souris vers la gauche La réduction de la valeur X, que nous pouvons voir, donne également l'impression que la jauge s'épuise Lorsque la valeur X est nulle, la jauge est vide, et lorsque la valeur x est 75, la jauge est pleine. Nous pouvons l'utiliser pour afficher n'importe quel niveau de santé du joueur en le transformant en un pourcentage de 75 pixels. Création d'un script pour la jauge de santé. Nous l'appellerons Gauge et l'enregistrerons dans le dossier des scripts de l'interface utilisateur. Nous pouvons obtenir une référence au remplissage pendant la phase de préparation. Comme les compteurs, une jauge n'a vraiment besoin que d'une seule méthode pour définir la valeur affichée. Il serait préférable de prendre cette valeur pourcentage avec un type à virgule flottante. Pour afficher ce pourcentage, il suffit de définir la taille du remplissage à 75 multiplié par le pourcentage. Un pourcentage en programmation est généralement représenté par un chiffre de 0 à 1, contrairement aux mathématiques où il est de 0 à 100 Cela simplifie nos calculs pour être plus efficaces Si nous voulons rendre ce script plus flexible, nous pouvons exporter la valeur de 75 pixels sous forme de variable nommée max pixels et définir 75 comme valeur par défaut. passant au script du personnage, nous pouvons créer un nouveau signal lorsque la valeur de santé du personnage change et lui donner un paramètre qui est le pourcentage de la santé restante du personnage. Ensuite, lorsque le personnage subit des dégâts, nous pouvons émettre ce signal. Pour calculer le pourcentage de santé restante du personnage, il suffit de diviser la santé actuelle par la santé maximale Mais ces deux valeurs sont définies comme des entiers, ce qui signifie que le résultat sera toujours zéro ou un Si nous changeons l'un de leurs types en float, le résultat sera alors un float deux. Nous pouvons ensuite connecter le signal de modification de la santé du personnage du joueur à la jauge de santé. Mais nous ne voulons pas appeler une nouvelle méthode. En cliquant sur le bouton de sélection, nous présenterons une liste des méthodes de jauges de santé que nous voulons appeler valeur définie Pour ce faire, le signal et la méthode doivent avoir les mêmes paramètres. Dans notre cas, à flot, pensez à démasquer les Lorsque vous serez prêt à tester, essayons-le. La jauge démarre pleine, mais sauter sur les pointes réduit la jauge d'un cinquième à chaque fois. N'oubliez pas de positionner le fondu en bas de la branche de l'interface utilisateur si vous souhaitez qu'il soit dessiné par-dessus tout le reste. Aidons maintenant le joueur avec une potion de santé pour récupérer sa santé perdue Comme nous l'avons fait dans la section précédente, nous pouvons simplement ajouter un nouveau trésor à l'aide des actifs de la potion rouge et créer un nouveau script pour celui-ci, en héritant du trésor, copiant l'un des autres Renommez-la potion rouge et ouvrez-la. Renommez le nœud racine en , remplacez les sprites d'animation par le rouge puissant et sprites d'effet par l'effet Je vais centrer le sprite et transformer le collider en capsule pour mieux correspondre à l'image J'utilise mon enregistrement Gulp réalisé par Miley Joe Moss, 1 996 ans, pour l' effet sonore de la potion Les différentes couleurs des potions contenteront probablement pas d' ajuster une variable, mais auront plutôt une fonction complètement différente Et nous aurons besoin de leurs propres scripts uniques. Au lieu d'avoir un script de potion générique, je vais appeler cette potion rouge hériter du trésor, puis échanger le script attaché au nœud racine Nous pouvons exporter une variable entière la quantité de points de vie que la potion récupère sous forme de nombre entier Je vais régler le mien à une valeur de trois. Je ne veux pas embêter le game manager en transmettant ces informations de la potion au personnage puisque le personnage entré en collision avec la Je vais plutôt apporter petite modification au script du trésor, stockant le personnage qui est entré en collision avec ce trésor dans une variable Ensuite, après avoir vérifié que le corps est un caractère, enregistrez le corps en tant que variable de caractère. Désormais, le script de potion peut communiquer directement avec le personnage lorsqu'il est collecté Une fois collectée, la potion rouge fera appel une méthode de récupération de santé au personnage qui transmettra le montant récupéré passant au script du personnage, nous pouvons ajouter cette méthode de récupération de santé aux méthodes publiques, en prenant comme paramètre le montant de santé à récupérer, en ajoutant le montant de santé récupéré à la santé actuelle. Nous devons également plafonner la santé actuelle à la santé maximale à l'aide de la fonction min, puis émettre le signal de modification de l'état de santé pour mettre à jour la jauge de santé sur le Y. Nous pouvons combiner ces deux lignes et les exécuter en une seule instruction Placez une potion de santé dans votre niveau, essayez de subir les dégâts causés par les pointes, puis récupérez la potion pour récupérer les points de vie perdus Nous avons désormais un moyen pour le joueur de savoir combien de points de vie il lui reste, et un objet pour l'aider à récupérer les points de vie perdus. Dans la leçon suivante, nous allons ajouter un point de contrôle au niveau. Je te verrai dans la prochaine leçon. 39. 4-4 Checkpoint: Bonjour les amis. Dans la leçon précédente, nous avons ajouté une jauge de santé à l'interface utilisateur et une partie pour aider le joueur à récupérer les points de vie perdus. Dans cette leçon, nous allons définir les endroits où le joueur doit réagir après sa mort. Je vais supprimer l'autre niveau de la scène de jeu. Maintenant que nous allons modifier la structure des niveaux et que tous les niveaux auront besoin cette nouvelle structure pour fonctionner correctement, les autres niveaux devront être modifiés également. Jusqu'à présent, nous avons utilisé l'origine de la scène comme point de départ du joueur, puis nous nous attendions à ce qu'il atteigne la fin sans mourir. Vous préférerez peut-être que vos niveaux soient plus longs et que vous donniez au joueur des points de contrôle où il pourra réagir au lieu de recommencer au début à chaque fois Ajoutons un autre dossier à la hiérarchie des niveaux , nommé checkpoints Nous pouvons ensuite ajouter un nœud biD vide de base à ce dossier nommé start position it où nous voulons que le joueur commence le niveau. Si tu préfères. Vous pouvez également souhaiter que le déclencheur de niveau se trouve dans ce dossier et le renommer en fin pour en faire un point de contrôle Nous allons également créer un nœud en zone 2 D dans ce dossier nommé middle. Donnez à ce point de contrôle un nœud sprite animé. Je vais utiliser les éléments du drapeau pour mon point de contrôle, car le point d'origine du point de contrôle est l'endroit où l'origine du personnage sera définie et origine du personnage se trouve à ses pieds L' origine des points de contrôle doit se situer au sol, là où seront positionnés les pieds du personnage Dans cet esprit, je positionnerai le drapeau manière à ce que la base des mâts se trouve à l'origine En ajoutant une forme de collision, je vais simplement utiliser un segment de ligne recouvrant le mât du drapeau afin que le joueur doive réellement entrer en contact avec le mât du drapeau pour le déclencher. J'ajouterai également un lecteur de flux audio à de node, qui jouera Game Reward by a Yen Ba sur FreeSound.org Enregistrez la branche du point de contrôle comme Je vais mettre le mien dans le dossier racine des scènes puisqu'il sera inclus dans tous les niveaux de mon jeu. ouvrant la nouvelle scène de point de contrôle, je vais modifier l'index z de mon drapeau pour qu'il soit dessiné derrière le personnage tout en ayant comportement très similaire à celui d'un trésor Logiquement, je ne considérerais pas cela comme un trésor et je ne veux pas refactoriser le script du trésor pour l'y intégrer Je vais créer un nouveau script à partir de zéro et placer dans le dossier des scripts d'environnement. Faites référence au nœud en deux D du lecteur de flux audio pendant la phase de préparation et connectez le signal saisi par le corps pour réagir en cas de collision du joueur avec le drapeau Activez l'effet sonore , puis réglez le masque de collision sur zéro pour empêcher toute autre collision de se produire. Ensuite, nous voulons définir une variable dans les données du fichier pour savoir que le joueur a atteint le point de contrôle Vous pouvez choisir un booléen si vous ne voulez avoir qu'un seul point de contrôle, comme dans un jeu Mario classique, ou un entier si vous voulez avoir plusieurs points de contrôle, un peu comme dans un jeu country de Donkey Kong. Un entier est plus flexible et peut également être utilisé pour Ainsi, chaque point de contrôle aura alors besoin d'un entier unique pour l'identifier , que le game manager utilisera pour savoir où répondre le joueur Définissons une variable sous la forme d'un entier pour contenir ce nombre. Définissez ensuite la valeur du point de contrôle déposé comme étant ce numéro d'identification Lorsque le joueur touche le point de contrôle, nous pouvons exporter les variables pour les définir manuellement, mais cela risque d'entraîner des erreurs et d'entraîner davantage de travail pour nous à long terme J'aimerais plutôt déléguer cette responsabilité au script de niveau. abord, nous devons nous assurer que le masque de collision du point de contrôle est configuré pour entrer en collision avec le joueur Et donnez un nom de classe à ce script afin qu'il puisse être identifié par le script de niveau. passant au script de niveau, si nous pouvons supposer avec certitude que tous les niveaux auront ce dossier de points de contrôle, nous pouvons l'utiliser pour définir une variable non pas dans le dossier de points de contrôle lui-même, mais dans un tableau de nœuds Nous pouvons définir la valeur comme étant le dossier des points de contrôle, ce qui nous donne une liste de tous les nœuds du dossier des points de contrôle Ensuite, en utilisant une boucle à quatre, nous pouvons compter de zéro jusqu'à la taille de ce tableau. Si la note est un point de contrôle, définissez son identifiant de point de contrôle sur sa position dans cette Le niveau contient désormais une liste de tous les points de contrôle où le personnage du joueur peut apparaître et chaque point de contrôle connaît sa position dans cette Il sera de la responsabilité du game manager de charger le niveau et de déplacer le joueur vers le point de contrôle approprié avant le début du jeu Ajoutons également une méthode au script de niveau afin que le game manager puisse demander cette information nommée get checkpoint position Prendre l'ID du point de contrôle comme paramètre entier et renvoyer une position vectorielle à deux Je vais commencer par un cas infaillible consistant à renvoyer simplement le vecteur deux zéro. Avant d'utiliser un argument pour indexer un tableau, nous devons vérifier qu'il s' agit d'un index de tableau valide, qu'il est à la fois supérieur ou égal à zéro et inférieur à la taille du tableau. Ensuite, nous renvoyons simplement l'index du tableau de points de contrôle à l'ID du point de contrôle et obtenons sa position globale Passage au script du gestionnaire de jeu. Une fois que toutes les initialisations ont été effectuées, mais avant de passer à autre chose, nous devrions faire apparaître Nous pouvons maintenant définir la position globale du personnage du joueur en demandant au niveau où se trouve le point de contrôle, en passant le point de contrôle classé comme argument Enfin, nous devons ajouter la variable de point de contrôle à la ressource de données avec la valeur par défaut de zéro Le joueur démarrera par le nœud enfant supérieur du dossier des points de contrôle, qui est le nœud de départ vide Comme nous n'utilisons pas le paramètre body transmis à la collision des points de contrôle, Godot préférerait qu'il soit marqué comme facultatif en Godot préférerait qu'il soit marqué comme le faisant précéder d'un trait de soulignement Placez le point de contrôle quelque part au milieu de votre niveau tout en assurant que le point de départ du niveau est le nœud supérieur du dossier des points de contrôle appuyant sur Play, rien n' aura changé, mais nous pouvons désormais déplacer le point de départ du joueur plus facilement. De plus, si nous modifions la valeur par défaut du point de contrôle dans le script de données, nous pouvons plutôt faire apparaître le joueur sur le drapeau Nous avons maintenant mis en place un système de points de contrôle permet au game manager de savoir où faire apparaître le joueur Dans la leçon suivante, nous allons ajouter la mort du joueur et faire réapparaître le joueur au dernier point de contrôle touché Je te verrai dans la prochaine leçon. 40. 4-5 Mort: Bonjour les amis. Dans la leçon précédente, nous avons créé un système de points de contrôle afin que le game manager puisse faire apparaître le joueur à différentes positions Dans cette leçon, nous allons ajouter la mort du personnage et faire réapparaître le joueur lorsqu'il meurt À commencer par le script du personnage. Tout comme nous avons plafonné la santé au maximum en utilisant Min lorsque le joueur se rétablit Nous devons également arrêter leur santé actuelle à zéro lorsqu'ils subissent des dégâts, réglant la santé actuelle au maximum de la santé actuelle moins le montant des dégâts ou de zéro. Nous pouvons ensuite émettre le signal de modification de la santé et régler la vitesse de renversement. Le reste de cette méthode dépendra du fait que ces dégâts les ont tués ou non. Nous devons vérifier si l'état de santé actuel est nul. Si c'est le cas, appelez une nouvelle méthode, mourez. Si le personnage n'est pas mort, la variable is hit sera définie sur true et il peut devenir invincible Avant d'écrire la méthode die, nous devons déclarer une variable booléenne pour savoir si le personnage est mort ou non Créez également un signal à émettre lorsque le personnage meurt afin que le game manager puisse réagir. Dans la méthode die, nous pouvons définir la nouvelle variable booléenne is dead » à vraie pour que nous puissions l'utiliser dans l' animateur. Comme nous l'avons fait avec, elle est touchée et émet un signal indiquant que le personnage Ce serait également une bonne idée de désactiver la boîte à troupeaux du personnage pour qu'il cesse de subir des dégâts. Mais c'est toujours quelque chose qui se produit probablement lors d'une collision. Nous devrons reporter cela jusqu'à la fin de la période en cours. Si vous réglez la couche de collision du personnage à zéro et le masque de collision à un, vous empêcherez toute collision future avec un objet autre que le terrain. Un personnage mort ne collectera pas trésor et ne déclenchera pas de point de contrôle Enfin, mettre la direction à zéro annulera toute saisie de mouvement donnée au moment du décès. Afin de répondre au joueur, nous avons également besoin d'une méthode publique faire revivre après sa mort, mettre à mort, le faire revenir à fausse santé actuelle à une santé maximale. Nous devons ensuite rétablir la collision du personnage définissant la propriété surveillable de la boîte Rt sur true Cela n'est pas déclenché par une collision, c'est probablement la logique du game manager. C'est bien de le configurer directement. Nous pouvons stocker les valeurs de la couche de collision et du masque de collision dans des variables pendant la phase de préparation, puis les restaurer à leurs valeurs d'origine lors de la réanimation du personnage Comme nous allons faire revivre le personnage du joueur après l'avoir repositionné au point de contrôle, il serait également judicieux d' omettre le signal d'atterrissage ici, qui positionnera correctement Nous avons changé celui du personnage, nous devrions également omettre le signal de changement de santé Nous ne voulons pas non plus que le personnage puisse faire quoi que ce soit tant qu'il est mort En commençant par la méthode face gauche, nous devons d'abord vérifier si le personnage est mort et, dans l'affirmative, revenir pour empêcher que cela ne se produise. Et faites-le pour toutes les méthodes qui ne doivent pas être exécutées lorsque le personnage est mort, y compris face right, run jump et stop jump. J'aimerais également ajouter un ajout au script du gestionnaire de jeu. Lorsque nous faisons apparaître le joueur, nous définissons sa position probablement au sol ou près du sol à un endroit du niveau Vous pouvez imaginer qu'il est possible que le personnage du joueur meure et tombe d' une grande hauteur. Au moment où cette méthode de réapparition repositionne le personnage, celui-ci aurait une vélocité très élevée Afin d'éviter que la vitesse persiste et ne mette fin à la collision due à la pluie, nous devons régler leur vitesse à zéro pour le moment En passant au lecteur d'animation, nous pouvons ajouter les animations Dead Hit et Dead Ground. N'oubliez pas d'utiliser les ressources du dossier sans stockage. Dead Hit devrait provoquer un cri de douleur de la part du personnage tandis que Dead Ground émet un son d'impact en touchant le sol. Étant donné la forte probabilité que ces sons se chevauchent, il serait judicieux de séparer les sons vocaux des effets sonores généraux. En ajoutant un second lecteur de flux audio à deux nœuds D, nous pouvons nommer une voix et les autres effets sonores. Nous pouvons alors limiter les sons vocaux à ne pouvoir en jouer qu'un à la fois, tout en permettant aux effets sonores jouer simultanément sans interruption définissez la propriété polyphonique maximale des effets sonores sur une valeur supérieure à un, plusieurs effets sonores pourront également être joués en même temps. Ce format nous permet également de régler les paramètres de volume des voix et des effets sonores indépendamment en sélectionnant l'arbre d'animation. Ajoutez ces nouvelles animations à la machine à états Without Sword. Tout d'abord, jouez à l'animation Dead Hit puis à Dead Ground. Dead Hit est joué lorsque le personnage est mort. Ensuite, Dead Ground sera joué une fois le tir à mort terminé, uniquement si le personnage est au sol. Afin de réanimer le joueur, nous avons besoin que ces animations reprennent également le mouvement. Quand le mot est mort devient faux dans la scène de jeu, sélectionnez le nœud du personnage du joueur et connectez le signal Did au gestionnaire de jeu. Donnons à cette méthode le nom du joueur Did. Lorsque le joueur meurt, deux choses peuvent se produire. Soit ils répondent à leur dernier point de contrôle, soit ils n' ont plus de vies et ont pris le dessus sur l'État Tout d'abord, vérifier si la durée de vie des données du fichier est égale à zéro. Nous appellerons ensuite une méthode game over, en donnant une définition à game over. Pour l'instant, nous pouvons simplement imprimer la fin du jeu. Si le nombre de vies n'est pas nul, nous pouvons le réduire d'un, mettre à jour l'interface utilisateur, puis appeler une autre méthode. Retournez au dernier point de contrôle. Pour revenir au dernier point de contrôle, il faut attendre, disparaître, passer au noir Faites apparaître le personnage au dernier point de contrôle atteint, réanimez-le, puis attendez que Faded passe Dans les deux cas, j'aimerais jouer un petit jingle comme dans la fanfare de la victoire Ajoutons trois variables exportées au script du game manager de type flux audio, qui s'appelleront Victory, Death et Game Over. J'utilise de la musique de fin de scène pour exprimer la mort et les changements de scène tristes ou effrayants. Musique pour game over, toutes deux créées par Dominic Trace de FreeSound.org Nous pouvons ensuite demander au nœud fanfare de diffuser le son approprié à chaque situation Jouez sur le thème de la victoire lorsque le joueur récupère la carte à la fin du niveau. jouent sur le thème de la mort quand ils meurent et sur le thème de la fin du jeu lorsqu'ils n'ont plus de vies. Il serait également prudent désactiver la saisie par le joueur au début du retour au dernier point de contrôle et d'activer la saisie par le joueur à la fin J'ai réglé la durée de vie des joueurs à un et la santé de Mac à un. Pour cette démonstration, le personnage du joueur est désormais capable de mourir et de réagir au dernier point de contrôle atteint Dans la leçon suivante, nous allons donner aux ennemis des attaques pour blesser le joueur. Je te verrai dans la prochaine leçon. 41. 4-6 Ennemis: Bonjour les amis. Dans la leçon précédente, nous avons donné au personnage du joueur une animation de mort et nous l'avons fait réapparaître après sa Dans cette leçon, nous allons ajouter aux personnages ennemis des attaques susceptibles de blesser le joueur. Je vais utiliser Fierce Tooth comme exemple pour cette leçon. Mais tous les personnages devront avoir leurs structures de nœuds modifiées pour qu' correspondent avant de lancer des tests. En sélectionnant le nœud du lecteur d'animation, nous pouvons commencer par ajouter les mêmes animations de tir, de mort et de terrain mort pour les ennemis que nous l'avons fait pour Roger. Ajoutez également de l'anticipation et de l'attaque. Dans la machine à états des arbres d'animation, nous pouvons recréer les mêmes animations de hit and death qu'avec Roger Structurer la machine à états en couches. Cela permet à l'ennemi blessé ou tué d' interrompre ses attaques. éditant la couche d'attaque, nous pouvons ensuite ajouter les animations d'anticipation et d'attaque. Ajoutez ici une transition du mouvement à l'anticipation, anticipation à l'attaque et de l'attaque au mouvement. La transition de l'anticipation à l'attaque se fera à la fin, tout comme la transition de l'attaque au mouvement. Mais le passage du mouvement à l'anticipation, qui déclenche la chaîne d'animations, se produit lorsque le personnage veut attaquer dans le script du personnage. Ajoutons le désir d' attaquer Bolin aux variables de combat Ajoutez ensuite une méthode publique nommée attack qui définit sa valeur sur true. Chaque fois que cette méthode est appelée, l'ennemi voudra attaquer une seule fois, comme si la variable is hit devait être remise à false, sinon l' animation tournerait en boucle. Nous devons également redéfinir la variable wants to attack sur false pendant l'animation. La variable wants to attack devra être exportée pour que le lecteur d'animation puisse y accéder. En revenant au lecteur d'animation pendant l' animation d'anticipation, nous pouvons redéfinir la valeur de wants to attack sur false. Cela suffit pour déclencher la séquence d'animation permettant à cet ennemi d'attaquer. Mais comme pour les pointes, il doit également y avoir une zone de frappe à la recherche de la zone de blessures du joueur. Sélectionnez l'animation d'attaque avec la première image sélectionnée. C'est ce qui apparaît dans l'éditeur avec une bonne vue du personnage. Ajoutons une autre zone au nœud D de l'arbre de scène nommée hit box et donnons-lui une forme de collision. Pour distinguer ce collisionneur du collisionneur environnemental bleu et de la case verte Rt, nous pouvons donner à la zone de frappe une autre couleur, comme Sélectionnez la forme qui, selon vous, convient le mieux à la zone ciblée par l'attaque. J'utiliserai une capsule, puis redimensionnerai pour l'adapter à la taille et à la forme de la zone ciblée. Assurez-vous de laisser la zone des hanches centrée sur le personnage et de déplacer uniquement la forme de collision vers le centre. Il existe également une animation à effets. Ajoutons un nœud animé contenant des sprites en tant qu' enfant de la boîte à hanches Créez une ressource de cadres de sprites et remplissez-la avec les sprites à effets d'attaque Contrairement aux autres animations à effets, nous ne voulons pas qu'elle soit jouée automatiquement Et aussi à la fréquence d'images habituelle de dix images par seconde, elle ne devrait pas non plus tourner en boucle. Ajoutez également un cadre vide à la fin, repositionnez le nœud sprite pour qu'il donne l' impression que l'effet émane Lorsque vous avez terminé, définissez le cadre par défaut comme étant le dernier cadre vide, afin qu'il soit initialement chargé dans la scène comme ne montrant rien. Mais ensuite, lorsque nous lui disons de jouer, il joue l'animation une fois et disparaît à nouveau. Nous pouvons définir la couche de collision des boîtes à succès comme étant la couche 19, qui sera la couche touchée par l' ennemi, et faire en sorte qu'elle masque la couche 10 de la couche blessée par le joueur. Comme il s'agit d'une entité active, elle surveille les boîtes endommagées. Rien ne cherche de boîtes à succès. Ils ne sont généralement pas surveillables. Cependant, nous ne voulons pas que cela soit une surveillance jusqu'à ce que l' ennemi attaque réellement. La valeur par défaut de la surveillance sera également fausse. Dans le script du personnage. Ce serait une bonne idée prendre une référence à la boîte à hanches pendant la phase de préparation. Nous devons ajouter un nœud de zone de frappe à chaque personnage pour répondre aux exigences des scripts de caractères avant tester et de définir la propriété de surveillance sur false. Juste au cas où nous reviendrions dans l'animation de l'attaque, nous pouvons ajouter la propriété de surveillance des boîtes à succès à l'animation, en lui attribuant la valeur true pendant la première image, remettre à false pendant la deuxième image. Ajoutez ensuite une piste de méthode d' appel pour l'animation de l'effet, lui indiquant de jouer pendant la première image de l'attaque. Bien que les animations soient divisées en trois phases : anticipation et attaque, une attaque, un contact et une récupération se déroulent en trois phases lorsque vous affrontez des ennemis. La phase d'anticipation est la façon dont l'ennemi télégraphie qu'il va attaquer, laissant au joueur le temps de réagir Suivi d'un contact, c'est-à-dire le moment exact où le collisionneur est allumé et l'ennemi blesse réellement le joueur Enfin, la récupération, qui donne au joueur le temps de réagir s'il est touché ou de riposter. Connectez le signal de la case de frappe à la zone saisie au script du personnage. La seule zone que nous autoriserons à entrer en collision avec une case est une case Rt. Grâce à la superposition des collisions, il suffit de demander à la zone Rt de trouver son parent, qui sera un personnage, et lui demander de subir des dégâts Pour l'instant, il suffit d'infliger un point de dégâts dans le sens de la position globale du joueur moins la position globale de cet ennemi. Une fois normalisé, nous devrions exporter le montant des dégâts sous forme de variable de combat afin de pouvoir le modifier pour chaque personnage la scène de niveau Trouvez votre ennemi et attachez-lui un nœud chronométré. Et réglez le chronomètre pour qu'il soit un peu plus long, exemple deux ou trois secondes. Et réglez-le sur autos, commencez. Connectez le signal de temporisation de ce chronomètre à la méthode d'attaque de l'ennemi Désormais, cet ennemi recevra l'ordre d' attaquer une fois chaque fois que le chronomètre atteindra zéro, et cela se répétera indéfiniment. Lorsque vous êtes prêt, appuyez sur jouer pour voir le personnage attaquer automatiquement et essayez de le laisser vous toucher. Cela fonctionne tant que le personnage ennemi ne fait pas demi-tour. Réglons la propriété flip H des nœuds sprites sur true pour simuler l'ennemi tourné vers la droite L'animation de l'attaque sera désormais orientée vers la droite, mais la zone des hanches et l' animation des effets sont toujours orientées vers la gauche. En sélectionnant la case hip dans la section de transformation, cliquez sur l' icône en forme de chaîne pour dissocier les valeurs x et y afin qu'elles puissent être modifiées séparément. Cliquez ensuite sur la propriété scale x et faites-la glisser en déplaçant votre souris vers la gauche. Lorsque la valeur approche de zéro, la boîte à hanches est si fine qu'elle disparaît. Mais lorsqu'il devient négatif, il est reflété autour de l'axe y. Nous pouvons l'utiliser dans le script des personnages pour inverser la tendance. En même temps, nous retournons le sprite dans la méthode face gauche Réglez l'échelle de la boîte à hanches x sur un si le sprite est naturellement orienté vers la gauche, sur l moins un et vice versa. Dans la méthode face droite, nous pouvons inverser la direction initiale de notre ennemi avec la variable exportée. Pour tester cela, nous avons maintenant nos personnages ennemis qui attaquent le joueur. Dans la leçon suivante, nous allons ajouter un surécran de jeu. Je te verrai dans la prochaine leçon. 42. 4-7 Game Over: Bonjour les amis. Dans la leçon précédente, nous avons donné les attaques de l'ennemi pour blesser le joueur. Dans cette leçon, nous allons ajouter un jeu à l'écran. Il s'agira d'une note de contrôle sur le canevas de l'interface utilisateur, probablement dessinée par-dessus tout le reste, mais toujours en dessous du fondu, intitulée Game Over Menu. J'utiliserai une case verticale pour tout trier facilement, commençant par une étiquette indiquant Game Over afin que le joueur comprenne rapidement ce qui se passe lorsqu'il a plus de vies. Je vais simplement leur présenter trois options : réessayer depuis le début du niveau, revenir au menu de sélection des niveaux ou quitter le jeu Je vais ajouter trois boutons pour chacune de mes trois options : Sélectionner et quitter. Je vais agrandir le tout quatre fois et repositionner pour qu'il soit au centre de l' écran. À l'aide d'ancres, en sélectionnant chacun des boutons, connectez le signal pressé au script du game manager, créant ainsi trois nouvelles méthodes qui seront appelées lorsque le joueur appuiera sur les boutons Tout d'abord, nous aurons besoin d'une référence au menu game over défini pendant la phase de préparation. Et définissez sa propriété visible sur Falls pour la masquer. Ensuite, lorsque l'état game over est atteint, nous pouvons définir sa propriété visible sur true. Appuyez ensuite sur l'un de ces boutons pour masquer le menu de l'écran de jeu en redéfinissant sa propriété visible sur false Si le joueur souhaite recommencer depuis le début du niveau, nous devrons réinitialiser un tas de variables, répondre à tous les trésors ennemis, aux points de contrôle, etc. Nous pouvons simplifier cela en déchargeant et en rechargeant simplement le même niveau déchargement est facile puisque nous avons une référence au nœud de niveau Nous pouvons simplement appeler Underscore Level gratuitement. Afin de recharger le niveau. Cependant, nous devons savoir quel niveau a été chargé. En ouvrant le script de données, nous pouvons ajouter deux nouvelles variables, l'une pour le monde et l'autre pour le niveau, toutes deux avec une valeur initiale de un. Si vous ne voulez pas organiser vos niveaux en mondes, vous pouvez ignorer cette variable pendant que nous sommes ici. Nous devrons également réinitialiser ces autres valeurs lorsque le joueur recommencera depuis le début du niveau en ajoutant une méthode de réessai publique Nous pouvons définir les pièces à zéro, vies à trois, le point de contrôle à zéro et la clé à faux De retour dans le script du gestionnaire de jeu, nous pouvons appeler les données des fichiers pour réinitialiser la progression des joueurs. Ensuite, nous pouvons définir la valeur du niveau comme étant load, ce qui prend un argument de chaîne représentant le chemin du fichier vers la ressource que nous voulons charger. recherche dans l'onglet du système de fichiers, trouvez votre niveau, cliquez avec le bouton droit de la souris et sélectionnez le chemin de copie. Collez ensuite ce chemin entre guillemets. Et suivez l'appel de chargement qui renvoie une ressource avec instanciation pour transformer cette ressource en nœud Ajoutez ensuite ce nœud à l'arborescence de la scène avec add child, mais cela ne chargera que le nœud de niveau 1. Nous pouvons remplacer celles du nom du fichier par les variables de nos données de fichier, mais les variables sont des entiers Et il s'agit d'une chaîne qui transforme les entiers en chaînes en utilisant le crochet STR. Tant que chaque niveau se trouve dans le dossier levels et porte le même nom, il sera chargé en définissant simplement les variables de monde et de niveau dans les données du fichier. Nous pouvons ensuite faire apparaître le joueur, désactiver les commandes du joueur et le ranimer. Mais nous ne voulons pas que le joueur voie tout cela se produire. Nous devrions commencer par passer au noir. Puis, à la fin, attendez que le fondu disparaisse et réactivez les commandes du joueur. Le joueur sera au début du niveau qui a été complètement rechargé et il réessaiera avec Pour l'instant, si le joueur souhaite revenir au menu de sélection des niveaux, il peut simplement passer au noir et réinitialiser les données de son fichier, car nous n'avons pas encore créé cette scène Mais laissez un commentaire ou une déclaration imprimée ici afin que nous sachions à l'avenir implémenter cette fonctionnalité S'ils appuient sur le bouton ex It, nous pouvons attendre, passer au noir. Appelez ensuite get tree quit pour fermer le jeu. Vous pouvez également souhaiter que cela revienne à l'écran titre du jeu lorsque nous en aurons un. À des fins de test, je vais simplement afficher l' écran du jeu Par défaut, le bouton Quitter fonctionne. Le bouton de sélection du niveau ne fait pas encore grand-chose, mais c'est intentionnel. Le bouton Réessayer fonctionne également. Mais ce menu est mauvais et ne correspond pas à l' esthétique du jeu. Utilisons le pack d'actifs pour l'améliorer. Je vais commencer par remplacer l'étiquette un nœud de contrôle de base nommé Banner, et je vais le remplir avec des épaves de texture, remplir avec les lettres et les images pour épeler game over et les trier à over et les trier l'aide de deux cases horizontales Réinitialisation de la taille et modification de la séparation à deux pixels entre chaque lettre J'ajouterai cinq autres T de texture et j'utiliserai les petites images de bannière pour assembler une bannière, réarrangeant pour qu'elles soient centrées sur le point d'origine de la bannière et que les mots soient écrits sur la bannière Je vais ensuite demander à la bannière de se centrer dans la case verticale parent, en sélectionnant le jeu sur le nœud de menu. Développez la section des thèmes et sélectionnez Nouveau thème dans le menu déroulant. Cliquez ensuite sur la ressource thématique pour l'ouvrir dans le panneau inférieur. Cet affichage nous montre plusieurs éléments d'interface utilisateur différents et leur apparence en utilisant cette ressource thématique, que nous pouvons modifier. Ajoutons un bouton au thème. Dans l'onglet de la boîte de style, il existe cinq options pour différents états des boutons. En les ajoutant tous au thème. Nous pouvons ensuite modifier l'apparence du bouton dans chaque état. En commençant par le mode normal, ajoutez une nouvelle texture de boîte de style, cliquez sur la zone de style pour l'ouvrir, puis remplissez-la avec le bouton vert Une seule image. Les boutons de l'aperçu sont désormais verts, tout comme les boutons de notre jeu. Mais ils sont étirés et laids. Développez ensuite la section de marge de texture en ajoutant quelques pixels d'espace de marge. L'image est désormais meilleure. Les images de ce pack de ressources ont une marge inférieure plus grande que celle des autres côtés. Puisque le menu Game Over utilise cette ressource thématique. Le même thème est également appliqué à tous ses enfants lorsque vous survolez ou que vous vous concentrez sur un bouton Je vais échanger sa texture avec le bouton jaune. Nous pouvons voir comment cela se comporte en survolant et en cliquant sur les boutons dans l'aperçu Lorsque cette option est désactivée, j'utilise la même texture de bouton vert, mais je module la couleur multipliant les valeurs RGB et alpha par deux pour qu'elle devienne plus grise et plus pâle Lorsque j'appuie dessus, j'utilise la même texture de bouton jaune, mais je fais la même chose, en modulant avec des valeurs RVB grises Mais laissez l'alpha à pleine opacité, en supprimant le texte des boutons Je vais plutôt les remplacer par des icônes. Placez ensuite chaque bouton une case horizontale associée à une autre case horizontale pour servir d'étiquette au bouton. Chaque case horizontale d'étiquette comportera plusieurs recs de texture pour chaque lettre du mot que je veux épeler, indiquant à la case horizontale de se indiquant à la case horizontale rétrécir et de se centrer verticalement Pour sélectionner le niveau, je vais simplement utiliser un texte vide directement comme espace. J'aimerais qu'il y ait plus d'espace entre les boutons et leurs étiquettes. Je vais donc regrouper les cases horizontales et modifier leurs valeurs de séparation pour qu'elles soient de 14 pixels. Ensuite, je vais placer les trois boutons dans une autre boîte verticale et les placer dans un nœud de conteneur appelé wood. Et ajoutez également un nœud de panneau au conteneur de panneau nommé paper, Reopening the theme Dans le panneau inférieur, nous pouvons apporter d'autres modifications aux panneaux et aux conteneurs de panneaux. En ajoutant le conteneur de panneaux au thème, nous pouvons également lui donner une boîte de style, en utilisant le préfabriqué Three comme image Je veux des marges plus larges sur ce panneau afin que les boutons ne semblent pas trop encombrés sur les bords. Les nœuds de conteneur sont automatiquement redimensionnés pour s'adapter à leur contenu Ajoutons également le panneau au thème. Les panneaux ressemblent à une texture détruite, mais présentent également des marges de texture, comme les boutons Et je vais utiliser le préfabriqué neuf comme texture. Cela a des marges assez larges de 20 pixels. Et contrairement aux images des boutons où l'intérieur était simplement d'une couleur plate, le papier et le bois ont une texture étirée. élargissant la section d' étirement de l'axe, nous pouvons définir les textures sur des carreaux au lieu de les étirer pour espacer davantage les éléments . Je vais donner au panneau de bois une largeur minimale de 160 pixels et au papier une taille personnalisée de 120 x 100 pixels. Positionner le papier sur le côté droit du bois et les boutons au centre vertical. Les mots semblent être écrits sur le papier. Et supprimez la hauteur minimale personnalisée de la bannière. Nous avons maintenant un jeu thématique à l'écran. Dans la section suivante, nous donnerons au joueur une épée pour qu'il puisse riposter. Je vous verrai dans la section suivante. 43. Épée 5-1: Bonjour les amis. Dans la section précédente, nous avons autorisé le personnage du joueur à subir des dégâts et à mourir. Dans cette section, nous donnerons au joueur une épée et ses propres attaques afin qu'il puisse riposter si vous avez terminé la mission. Tous vos niveaux auront désormais le dossier des points de contrôle. Et tous vos ennemis auront des animations de mort et d'attaque. Tous vos ennemis pourront attaquer. Le joueur subira des dégâts et mourra si vous avez relevé les défis. Il se peut également que votre interface utilisateur et menu Game Over s'interconnectent depuis le mode hors écran Ainsi que des potions vertes et bleues qui ont un effet unique sur le personnage. Commençons par un peu de ménage. J'aimerais trier les scripts des personnages et des joueurs dans un nouveau dossier de scripts nommé characters. Cette scène de jeu principale sera utilisée pour tous les niveaux, pas seulement pour le premier niveau. Nous pouvons donc supprimer le nœud de niveau dans le script du gestionnaire de jeu. Nous ne définirons pas la valeur du niveau en utilisant at on ready. Dans la méthode prête à l'emploi. Après avoir réglé le fondu pour qu'il soit visible, nous devons alors charger le niveau actuel. Écrire une nouvelle méthode privée. Niveau de charge : nous pouvons utiliser le même code que celui que nous avons écrit dans la méthode « Réessayer » en appuyant sur le bouton « Réessayer » pour charger le niveau et remplacer par un appel de méthode Ensuite, déplacez également ses limites et son interface utilisateur au niveau de charge. Elles seront mises à jour pour correspondre aux nouvelles valeurs. Ajoutez également une ligne à l'interface utilisateur pour définir la propriété visible de l'icône de la clé selon que le joueur possède ou non la touche. Maintenant, quel que soit le monde dans lequel un niveau est défini dans les données du fichier, ce niveau sera chargé au début du jeu. Si le niveau est rechargé ou modifié, les limites et l'interface utilisateur seront mises à jour pour correspondre Jusqu'à présent, tout ce que nous avons fait dans notre script de personnage a été applicable, ou du moins suffisamment flexible, pour être appliqué à n'importe quel personnage. Cependant, seul l'humain porte l'épée dans le pack d'actifs . Pour séparer ces comportements du script du personnage, nous pouvons créer un nouveau script qui hérite du personnage, qui contiendra des comportements qui ne peuvent être appliqués qu'au héros de notre jeu enregistré dans le nouveau dossier des scripts de personnage, et en remplaçant le script du personnage sur la note racine de Roger Ce script aura besoin d'une variable booléenne exportée pour nous indiquer si le héros tient actuellement une épée Nous pouvons également donner un nom de classe à ce script afin que d'autres scripts puissent facilement vérifier s'il s' agit d'un personnage ou d'un héros. J'aurai également une référence privée à l'épée qui en est équipée. Ajoutez ensuite une nouvelle méthode publique que d'autres scripts peuvent utiliser pour demander à Roger de s'équiper d'une épée. prenant l'épée comme paramètre, en définissant la variable privée locale et en réglant son épée une autre méthode publique, disant à notre héros de lâcher l'épée. S'ils n'ont pas d'épée à lâcher, nous pouvons les ignorer et revenir. Sinon, le décor fait tomber l'épée, ordonnant à l'épée de tomber. En faisant passer la position globale du héros comme argument, l'épée sait où elle doit être. Comme le héros n'a plus d'épée, la variable épée sera nulle, ce qui signifie vide. Lorsque le héros meurt, nous annulons le comportement du personnage consiste à mourir pour vérifier s'il possède une épée. Dans l' affirmative, nous voulons que le reste du code du dé soit également exécuté Au lieu de copier-coller, nous pouvons utiliser super die pour appeler la définition héritée de die. En suivant le même processus, nous avons créé tous nos trésors de collection. Fabriquons une épée équivoque pour le personnage du joueur. Je veux que la physique soit appliquée à mon épée. Parfois, j'en fais un corps rigide, deux D, comme les pièces, mais mon épée est plus complexe que les trésors classiques avec plusieurs états et plus de choses à changer que le sprite, coffre au trésor En lui donnant un nœud Sprite Two D. Je vais définir son sprite par défaut sur sword, idle, zero one. En ajoutant un lecteur d'animation et l'arbre d'animation, je peux créer l'animation inactive pour que l'épée tourne. Ajoutez ensuite une forme de collision à la branche, en lui donnant une taille de capsule adaptée au sprite de l'épée Je vais le placer sur la couche 26 pour séparer des autres objets et pour qu'il n' entre en collision avec le train ou le joueur que comme les pièces Je vais l'empêcher de pivoter figé par défaut, son mode de gel étant réglé sur cinématique, de sorte qu'il ne bouge pas, mais qu'il peut tout de même avoir des collisions Et signalez les collisions au contact d' un maximum de deux personnes à la fois en sélectionnant le traitement d'animation. Je vais définir la propriété du lecteur Anim comme étant ce lecteur d'animation et créer une nouvelle machine à états pour le moment L' animation inactive sera alors jouée par défaut. Et ajoutez également un lecteur de flux audio au nœud, que je remplirai avec l'effet sonore dégainé, enregistrant cette branche comme Vous voudrez peut-être le placer dans un dossier d'armes ou d'équipements, mais comme il n'existe aucun autre actif de ce type, je vais simplement le conserver dans le dossier Scenes. J'ai retiré l'épée de la scène d'origine Je vais donc réinitialiser son transfert et sa propriété pour y entrer à nouveau Nous devons maintenant créer un script pour l'épée. Bien que cela se comporte de la même manière qu'un trésor, il est suffisamment différent pour que je préfère ne pas refactoriser le code et simplement hériter du corps rigide en deux D, connecter le corps du signal saisi au script En raison des couches de collision, on peut supposer sans risque de se tromper que Roger est la seule personne capable de coder avec l'épée. Mais je vais vérifier si le corps est celui d'un héros et s'il peut être équipé d'une épée. Nous devons définir cette méthode et lui faire renvoyer une valeur booléenne Ensuite, nous pouvons demander au héros de s'équiper de cette épée, en se faisant passer pour argument, et de devenir invisible afin que le joueur ne puisse plus voir l'épée. Puisque le sprite du personnage dessine pour faciliter la physique de lâcher l'épée Je vais également dégeler le corps de la crête avec un réglage différé. Vous devez saisir une référence au lecteur de flux audio pendant la phase de préparation Nous pouvons également jouer l'effet sonore. Lorsque cela se produit dans le script du héros, nous devons écrire la méthode de l' épée équipée en renvoyant un booléen Il suffit de dire si le héros n'a pas d'épée et n'est pas mort. Dans ces conditions, le héros devrait être capable de s' équiper de l'épée. Ensuite, lorsque le héros laisse tomber l'épée, il appelle une méthode abandonnée. écrivant cette définition, nous pouvons prendre la position d'où l'épée a été lâchée comme paramètre du vecteur de type 2. J'aurai besoin d'un générateur de nombres aléatoires lancé pendant la phase de préparation pour donner un flottant aléatoire entre moins un et un positif. Je vais définir la position globale de l'épée comme étant cette position plus une demi-tuile vers le haut. Appliquez une force d'impulsion allant jusqu'à huit tuiles, plus la droite multipliée par un nombre aléatoire similaire à l' effet des pièces. Et enfin, définissez visible sur true pour que le joueur puisse le voir. Nous pouvons désormais dupliquer nos animations pour créer de nouvelles où le héros tient l'épée, en commençant par l'idole, puis en courant, en sautant, en tombant au sol et en frappant. Nous pouvons maintenant connecter nos héros sans machine à états à épée à la machine à états à épée en largeur en fonction de la valeur de has sword ouvrant la machine à états stockée en largeur. Cette couche supérieure contiendra la machine d'état d'attaque connectée à l'animation de l' épée à succès, car lorsque le joueur meurt, il laisse tomber l'épée dans la machine d'état d'attaque. Pour l'instant, il suffit d'ajouter la machine à états de mouvement et de la connecter dès le départ, en ajoutant les animations de saut, de chute et de sol, ainsi que la machine d' état de locomotion, en les connectant entre elles la même manière que tout le reste Enfin, terminez la deuxième machine de locomotion, en plaçant l'épée quelque part dans votre niveau Le héros pourra désormais le récupérer et toutes les animations fonctionneront toujours de la même manière, sauf si l'épée est équipée. Et quand ils meurent, l'épée tombe. Nous avons maintenant une épée que le joueur peut récupérer et équiper. Dans la prochaine leçon, nous ajouterons les attaques à l'épée. Je te verrai dans la prochaine leçon. 44. Attaque 5-2: Bonjour les amis. Dans la leçon précédente nous avons ajouté une épée que le joueur peut équiper et lâcher. Dans cette leçon, nous allons ajouter un bouton d'attaque et les animations d'attaque pour le joueur. Commençons par ouvrir les paramètres du projet dans l'onglet de saisie de la carte et ajouter un bouton d'attaque. J'utiliserai le bouton gauche de la souris sur le bouton J du clavier et le bouton gauche de la souris pour la manette de jeu Adapté à une variété de styles de jeu dans deux noms de couches physiques J'ajouterai également les noms des joueurs touchés, des ennemis touchés et des couches d' épée. Ensuite, dans le script du joueur, lors de l'événement d'entrée, si le bouton d'attaque est enfoncé, nous devons indiquer au personnage du joueur d'attaquer. Le script du personnage a déjà été configuré pour traiter ce paramètre de saisie qui veut que l'attaque devienne vraie, mais les joueurs peuvent et vont écraser les boutons même lorsque l' action souhaitée est impossible. définissez Wants to Attack sur true, une attaque sera déclenchée lorsque cela sera possible grâce à l'arbre d'animation. Mais cela se produira même si un certain temps s'est écoulé depuis que le bouton a été enfoncé. Nous devons fixer une limite de temps pendant laquelle l'attaque est considérée comme valide avant de l'ignorer. Si le personnage ne peut pas exécuter l'attaque pendant cette période, ajoutons un nœud de temporisation à la zone de frappe nommé tampon d'entrée et réglons le temps sur une demi-seconde et un tir sur vrai. Ensuite, dans le script du héros, nous pouvons récupérer une référence à ce nœud pendant la phase de préparation. remplaçant la définition d'attaque, nous pouvons définir want to attack sur true, démarrer le temporisateur de la mémoire tampon d'entrée, En remplaçant la définition d'attaque, nous pouvons définir want to attack sur true, démarrer le temporisateur de la mémoire tampon d'entrée, attendre son signal Ensuite, set veut revenir à la valeur false. Si aucune attaque n'a été déclenchée une demi-seconde après avoir appuyé sur le bouton, celui-ci sera ignoré. La durée peut être facilement ajustée dans les propriétés des nœuds de temporisation. Lorsque j'attaque, j'aimerais empêcher les personnages d'effectuer d'autres actions dans le script du personnage. J'ai besoin d'une autre variable d'investissement pour savoir si le personnage attaque actuellement ou non Ce que je vais définir pendant les animations et définir sa valeur sur false lors du premier chargement de la scène, juste au cas où, comme nous l'avons fait pour la surveillance des hit-box. Ensuite, de la même manière que je vérifie si le personnage est mort avant d' effectuer d'autres actions, j'ajouterai également la condition qu'il ne doit pas attaquer. Cependant, je changerai de point sorte que s'ils sont morts ou attaquent, au lieu de simplement revenir, je mettrai la valeur de direction à zéro. Sinon, comportez-vous normalement. Les personnages devront terminer leurs attaques avant de passer à autre chose. J'ajouterai également la condition à la collision avec la boîte de frappe selon laquelle ce personnage ne doit pas être mort et doit attaquer pour pouvoir infliger des dégâts Dans la vue bidimensionnelle de Rogers, je n'ai pas encore donné de forme au nœud Hip Box de Rogers, mais je n'ai pas encore connecté le signal ou défini la couche et le masque de collision. Nous pouvons facilement relier le signal du nœud de la zone saisie à la méthode déjà définie dans le script de caractères. Configurez ensuite cette case à hanche pour qu'elle soit désactivée par défaut lorsque le joueur atteint la couche de collision 11 et masque la couche T ennemie couche 18 En sélectionnant le lecteur d'animation Rogers, nous pouvons ajouter une animation d'attaque remplie des sprites appropriés et définir sa longueur que pour que l'attaque soit fausse pendant la première image Nous devons définir la valeur de is attack sur true pendant que l'animation joue. Mais revenons à faux. Une fois que c'est fait, le personnage sait qu'il ne doit ni bouger ni sauter. Définissez ensuite la propriété de surveillance de la boîte à hanches sur true pendant la deuxième image et sur false pendant la troisième. Détecter la collision qui blessera les ennemis. En utilisant la deuxième image de l'animation comme guide visuel, créez une nouvelle forme pour la collision. J'utiliserai une capsule et je mettrai sa couleur en rouge pour qu'elle corresponde à celle de mes autres boîtes à hanches. Définissez ensuite sa forme, sa position et sa rotation en fonction de la zone affectée par l'attaque. Ajout de pistes à l' animation pour la collision. Formez les nœuds, leur forme, leur position et leur rotation. Nous pouvons ajouter des images clés pour chacune d'elles lors de la première image de l'animation. Ajoutez un so animé à la case à hanches pour créer les animations à effet. Et créez une animation pour chacun des trois effets d'attaque avec une image vide à la fin comme valeur par défaut. Tout comme nous l'avons fait avec les attaques ennemies. Positionnez le nœud devant le personnage de manière à ce que l' animation du sprite ressemble à celle de l'attaque. Dans l'animation Attack One, nous pouvons ajouter une piste qui joue l'animation à effet, faisant passer l'attaque 1 comme en faisant passer l'attaque 1 comme premier argument de la méthode de jeu Appelez l'inspecteur. Et aussi une piste de lecture audio pour émettre un effet sonore de balayage, dupliquant ainsi l'animation Attack One Nous pouvons créer l'attaque deux et attaquer trois animations, remplaçant les textures du sprite, en remplaçant la passe d'argument par le sprite animé et en ajoutant un nouvel effet sonore à la lecture audio un nouvel effet sonore à la lecture Créez ensuite une nouvelle forme de collision pour les différentes animations d'attaque. Réajustement de sa position, de sa rotation et de sa forme en fonction de la zone affectée par l' attaque Selon la version de Godot que vous utilisez. peut que l'éditeur n'affiche pas correctement le collider pendant que vous effectuez cette opération, mais vous pouvez toujours saisir des valeurs manuellement dans l'inspecteur mais vous pouvez toujours saisir des valeurs manuellement dans l'inspecteur et répéter l'ensemble du processus pour lancer l'attaque 3 Assurez-vous de créer une nouvelle ressource en forme de collision pour chaque animation. Oh, en sélectionnant l'arbre d'animation. En plongeant dans la couche d'épée de largeur, la couche d' attaque, nous voulons ajouter nos trois animations d'attaque. J'aimerais passer d'une animation d'attaque à l' dans l'ordre tant que le joueur continue d'appuyer sur le bouton d' attaque, mais revenir au mouvement depuis n'importe laquelle d'entre elles s'il arrête d' appuyer sur le bouton d'attaque. Commencez par quitter le mouvement pour attaquer un personnage, si le personnage veut attaquer et qu'il est au sol Suivez ensuite les mêmes conditions les deux autres attaques, ne changeant qu'à la fin de l'animation précédente. Les attaques 2 et 3 reprendront leur cours à la fin de l'animation. Mais le passage de l'attaque deux à l'attaque trois sera prioritaire. Si ses conditions sont remplies, l' attaque 1 reprendra le mouvement si le personnage ne veut pas attaquer ou s'il n'est plus au sol. Avant de tester, il serait utile de pouvoir voir le collisionneur s'animer dans le menu de débogage Sélectionnez Visible Collision Shapes pour afficher les formes de collision pendant le jeu. Maintenant, si nous prenons l' épée dans notre jeu, le joueur pourra effectuer des attaques combinées avec celle-ci, chacune avec des animations, des formes de collision et des effets sonores différents . Et les attaques blesseront et tueront également les ennemis. Le personnage du joueur est désormais capable d'effectuer une attaque combinée à trois coups avec une épée pour se défendre contre ses ennemis. Dans la prochaine leçon, nous allons ajouter deux attaques aériennes. Je te verrai dans la prochaine leçon. 45. 5-3 Attaque aérienne: Bonjour les amis. Dans la leçon précédente, nous avons ajouté des animations d'attaque pour le joueur. Dans cette leçon, nous allons ajouter d'autres attaques que le joueur peut utiliser lorsqu'il saute. À partir de la scène de Rogers, en sélectionnant le nœud du lecteur d'animation de Roger. Nous pouvons dupliquer l'animation d'attaque 1 pour créer une animation d' attaque aérienne et remplacer les sprites par cette animation Remplacer l' effet sonore de balayage par un autre. Nous devons également créer une nouvelle forme de collision pour cette animation. Ajustement de sa forme, de sa position et de sa rotation en fonction de la zone affectée. Lorsque vous ajustez ces formes de collision à l'aide d'une animation, il est utile de créer un nouveau nœud en forme de collision et de l' ajuster à la place. Copiez ensuite les valeurs dans les images clés de l'animation et supprimez le nouveau nœud. Lorsque vous aurez terminé, renommons les deux nœuds du sprite animé pour créer des effets d'attaque Dupliquez-le ensuite pour créer des effets d'attaque aérienne. Assurez-vous de créer une nouvelle ressource de sprites pour ce nouveau nœud et de créer les deux animations d' effets d'attaque aérienne Les effets d'attaque aérienne ne sont pas positionnés de la même manière que les effets d'attaque au sol. Nous devrons donc repositionner le nœud, supprimant la trace pour l'effet d'attaque Nous pouvons plutôt ajouter une nouvelle piste pour les effets d'attaque aérienne, puis dupliquer cette animation Pour créer Air Attack Two, nous pouvons répéter le processus remplaçant les sprites, en remplaçant l'argument par l'animation de l'effet et en changeant l'effet sonore Ajustez ensuite la forme de la collision pour qu'elle corresponde à l'attaque. En ajoutant ces deux nouvelles animations à l'arbre d'animation, elles se comporteront à peu près de la même manière que les attaques au sol, seule condition que la seule condition que le personnage ne soit pas au sol pour passer de l'attaque aérienne 1 à l'attaque aérienne 2 à la fin de l'animation, dans les mêmes conditions Et revenez au mouvement à la fin de la deuxième attaque, passez de la première attaque aérienne au mouvement Si le joueur ne veut plus attaquer ou s'il est au sol, j'aimerais créer la sensation d'être suspendu en l'air pendant que le joueur effectue ces attaques aériennes Nous allons remplacer la définition de la physique de l'air dans le script du héros Si le héros attaque et sa vitesse y est supérieure à zéro, ce qui signifie qu' il tombe, je mettrai sa vitesse y à zéro, au lieu de le garder en l'air pendant toute la durée de son attaque. Sinon, nous pouvons utiliser delta de Super Air Physics pour reproduire les comportements hérités du script du personnage. Mais comme le joueur peut choisir continuer à attaquer à l'infini, il peut également choisir de rester en l'air pour toujours. Nous pouvons corriger cela avec un autre mécanisme de jeu, un temps de recharge. Ajout d'un autre nœud de temporisation à la boîte à puces nommé Cool Down. Je vais laisser son réglage de temps à 1 seconde par défaut, mais régler one shot sur true. Saisir une référence à ce nœud pendant la phase de préparation dans le script du héros afin que nous puissions référencer dans l'arbre d'animation Plus loin dans les animations d'attaque, nous pouvons ajouter une piste d' appel de méthode à chaque fois que le temps de recharge démarre à la fin de chaque animation. Les appels démarrent sur le chronomètre de refroidissement. Encore une fois, à chaque attaque, il suffira de remettre sa valeur temporelle à 1 seconde et de recommencer le compte à rebours. Dans l'arbre d'animation, nous n'autoriserons pas la transition vers la première attaque de la séquence à moins que le temps de recharge ne soit arrêté. De cette façon, le joueur sera obligé d'arrêter d'attaquer après un maximum de trois attaques au sol ou deux attaques en l'air. La durée du refroidissement peut être facilement ajustée dans les propriétés des nœuds du temporisateur. J'aimerais aussi attaquer un ennemi par le haut pour faire rebondir le joueur Ajout d'une dérogation au script héros de la méthode saisie dans la zone de frappe Je dois d'abord vérifier si ce héros est mort ou s'il n' attaque pas, puis revenir s'il n'est pas par terre. Et la position Y globale de la zone touchée par l'attaque est supérieure la position Y globale du héros, sorte que l'ennemi touché se trouve en dessous. Ensuite, je définirai leur vitesse y comme une force de saut divisée par deux, pour créer un rebond inférieur à celui d'un saut complet Enfin, appelez la définition héritée pour infliger des dégâts Eh bien, lors de la création des animations d' attaque des joueurs, j'ai ajouté la nouvelle variable « is attack », mais cette variable n'était pas incluse dans les animations d'attaque ennemie. Ajoutons donc cela. Alors que l' arbre d'animation indique l'état de la machine allégement de la machine permet de garder les choses organisées Cela introduit également le risque d'interruption des animations, laissant les variables définies comme elles ne devraient pas l'être. Par exemple, si Roger attaque sa variable d'attaque et la surveillance des hanches sont toutes deux réglées sur true. Mais il est touché avant la fin de l'animation et ces variables ne sont pas remises à false. Roger ne peut plus bouger et tous les ennemis qui s'approcheront de lui seront endommagés par des boîtes à hanches fantômes Nous pouvons réinitialiser ces variables lorsque le personnage subit des dégâts ou meurt. Pour éviter que cela ne se produise, créons une méthode d' interruption d'attaque. Remettez à faux la valeur de l'attaque et de la surveillance de la boîte aux hanches, et appelez cette méthode lorsque le personnage subit des dégâts s'il attaque Le personnage du joueur est désormais capable d'exécuter des attaques en l'air, suspendre la gravité et de générer une force de rebond lors Dans la leçon suivante, nous allons ajouter scripts d' intelligence artificielle pour permettre à l' ennemi de patrouiller dans la zone. Je te verrai dans la prochaine leçon. 46. 5-4 Patrol: Bonjour, mes amis. Dans la leçon précédente, nous avons ajouté des attaques aériennes pour le joueur. Dans cette leçon, nous allons écrire un script d'IA obliger les ennemis à patrouiller dans une zone. J'ai déplacé les autres ennemis et positionné Fierce Tooth entre deux obstacles de mon niveau. Et j'ai désactivé le chronomètre d'attaque automatique pour le comportement le plus élémentaire de l'ennemi. J'aimerais qu'ils avancent simplement jusqu'à ce qu'ils heurtent un mur et qu'ils fassent demi-tour. Tout comme nous avons créé le nœud joueur pour contrôler le personnage du joueur, nous pouvons créer un nœud enfant pour les ennemis afin de contrôler leur comportement. Avec l'IA, ce nœud nécessitera un positionnement en deux D. Je vais donc en faire un nœud deux D et le nommer Patrol. Donner à ce nœud un nom de script à patrouiller. Je vais le mettre dans le dossier des scripts de personnages et utiliser le modèle par défaut pour un nœud deux D. Pendant la phase de préparation, je vais récupérer une référence au nœud parent, qui est le personnage contrôlé. Déclarons également une variable afin de savoir dans quelle direction nous voulons nous déplacer en tant que type flottant. Dans la méthode ready, nous pouvons initialiser la valeur de la direction selon que le personnage parent est orienté vers la gauche ou non Mais la variable orientée vers la gauche a été marquée comme privée. Nous devrions ajouter une méthode publique qui renvoie sa valeur au script de personnage, afin que nous puissions y accéder de manière incorrecte Ensuite, nous pouvons définir la valeur de la direction du trait de soulignement en fonction la valeur de retour des caractères parents. Méthode public orienté vers la gauche, cela nous permet de lire la valeur de is facing left mais de ne pas la modifier. Dans la méthode de traitement, nous n'avons pas besoin de delta. Nous devrions mettre un trait de soulignement devant pour que le moteur puisse l'ignorer Le comportement par défaut sera simplement de dire au personnage de courir dans la direction souhaitée. Mais avant cela, nous devons vérifier si le personnage a heurté un mur, ce qui est commodément inclus dans le corps du personnage à deux nœuds. Si le personnage est sur un mur, nous devons changer la valeur de direction. Nous pouvons obtenir le vecteur normal des murs, qui est un vecteur perpendiculaire et pointant à l'opposé de la surface des murs. Nous ne nous intéressons qu' à la partie x de ce vecteur pour savoir si le mur est orienté vers la gauche ou vers la droite. Nous pouvons également y appliquer un signe. Le rendement sera soit négatif, soit positif. Cela n'aura pas d'importance dans mon jeu, puisque chaque mur est parfaitement plat. Leurs vecteurs normaux seront toute façon exactement à gauche ou à droite. Mais ce code fonctionnera avec des murs inclinés. Maintenant, deuxièmement, essayons-le. Fierce Tooth fait maintenant des allers-retours entre les deux obstacles. Ils détectent même le joueur comme un obstacle. Deuxièmement, tout ce qui entre le corps du personnage et le nœud D entre en collision qui empêche le mouvement horizontal sera détecté par la méthode is on wall Et si on plaçait Fierce Tooth sur le dessus de la plateforme ? Ils vont simplement courir sur le côté et répéter le même comportement qu'avant. Bien que je sois parfois favorable à ce comportement, je ne veux probablement pas que cela se produise tout le temps et je voudrais peut-être que les ennemis fassent demi-tour s'ils sont présumés. C'est un peu plus compliqué car la détection des corniches n'est pas prévue pour nous Ajout d'un nœud enfant au nœud de patrouille. Nous pouvons utiliser un nœud Ray Cast Two D pour détecter la présence ou l'absence de terrain devant un personnage. Je positionnerai le rayon de manière à ce qu'il se trouve dans l'espace vide devant le personnage et qu'il pointe vers le sol. Nous voulons que le comportement de cet ennemi change en fonction du fait que cette flèche touche le sol ou non. Lorsqu'ils se retournent, repositionnez la flèche de l'autre côté. De retour dans le script de patrouille, nous pouvons saisir une référence au casting pendant la phase de préparation et l'appeler Floor Re , puis définir sa position à une demi-tuile d'avance sur le personnage dans la méthode prête. Vous pouvez également exporter une variable si vos ennemis ont des tailles différentes et doivent positionner le rayon différemment. Il s'agit d'une division entière, mais je le fais exprès, donc je vais ignorer l'avertissement. Dans la méthode du processus. Chaque fois que le personnage est sur le sol et que le rayon n' entre en collision avec rien, cela signifie que le personnage fait face à un rebord Nous pouvons donc appeler méthode ledge detected. Si un rebord est détecté, nous pouvons facilement échanger la valeur de direction entre un et positif un en la multipliant par moins un. Réinitialisez ensuite la position du rayon pour qu'il soit en face de la nouvelle direction du personnage. Au lieu de dupliquer le code, nous pouvons transformer le code de la méthode prête en une nouvelle méthode et l'appeler que nous voulons qu'ils changent de direction. Fierce Tooth peut désormais faire des allers-retours sans quitter les bords de la plateforme. activation des formes de collision visibles dans le menu de débogage nous permettra également de voir le rayon du sol à l'œuvre pendant que cela se produit Mais que se passerait-il si je voulais faire une exception et faire sortir des ennemis des corniches ? Nous pouvons ajouter un nouveau type de variable à notre script, une énumération souvent abrégée en enum, qui n'est qu'une Nommez-le, comportement des corniches, puis complétez cette liste avec toutes les options que nous souhaitons avoir Je vais juste ajouter deux options. La valeur par défaut en haut de la liste sera de faire demi-tour, mais je veux aussi avoir la possibilité quitter les rebords deux Vous voudrez peut-être aussi faire des choses comme arrêter ou sauter, etc. La convention pour les énumérations consiste à utiliser un trait de soulignement supérieur Vous vous souvenez peut-être d'avoir déjà utilisé une énumération définie dans le nœud à deux D à corps rigide, lors de la définition de sa propriété de mode de gel fois l'énumération définie, nous pouvons exporter une variable en utilisant l'énumération comme Ensuite, lorsqu'un rebord est détecté, nous pouvons faire correspondre la valeur de cette variable et fournir un bloc de code à exécuter pour chacune Si le comportement présumé est réglé pour changer, nous devons exécuter le même code qu'avant. Mais s'il est réglé pour partir, nous pouvons simplement passer ou revenir. Avec cette méthode, vous pouvez imaginer comment ce format peut être utilisé pour fournir un certain nombre de comportements alternatifs. Sélection du nœud de patrouille. L'inspecteur contient désormais une liste déroulante intitulée « comportement du rebord » dans laquelle nous pouvons sélectionner le comportement que nous voulons décrire dans des termes faciles à comprendre pour tous Je vais également déplacer la position de départ des joueurs pour avoir une meilleure vue. Disons à Fierce Tooth de descendre des rebords et de voir ce qui se passe Enregistrez le nœud de patrouille en tant que scène à part entière dans le dossier du personnage. Nous pouvons désormais appliquer le même script de comportement à tous les ennemis de base de notre jeu. Ajuster la façon dont ils réagissent aux différents obstacles du terrain, l'aide du casting et des énumérations Dans la leçon suivante, nous allons donner un comportement agressif à la détection des joueurs ennemis. Je te verrai dans la prochaine leçon. 47. 5-5 Agression: Bonjour les amis. Dans la leçon précédente, nous avons créé un script d'intelligence artificielle qui peut être utilisé pour obliger n'importe quel ennemi de notre jeu à patrouiller dans une zone et même à modifier son comportement. Dans cette leçon, nous allons écrire un autre script qui permettra aux ennemis de percevoir le joueur et d' essayer de l'attaquer. Commençons par une scène de dents féroces. La première étape sera de savoir si un ennemi peut voir le joueur ou non. Ce sera un comportement unique uniquement pour les personnages que nous voulons voir ennemis. Nous devrions créer un nouveau script pour les ennemis héritant du personnage Nous pouvons ensuite remplacer le script du personnage par le script ennemi sur le nœud racine de Fierce Tooth. Ajoutons une variable booléenne pour savoir si l'ennemi peut voir le joueur ou non Mais comment savoir si l' ennemi peut voir le joueur ? Tout comme nous l'avons fait pour l'attaque, nous pouvons ajouter une autre zone au nœud pour représenter la vision de l'ennemi. Et donnez-lui une forme de collision. A Utilisez une couleur neutre, comme le blanc pour la vision. Et faites-en une grande zone circulaire qui couvre plusieurs carreaux devant eux et légèrement autour d' eux de tous les côtés. Cela représente l'ensemble de leur champ de vision. Nous devons savoir si le personnage du joueur entre dans cette zone. Ajustons la superposition des collisions. En le plaçant sur la couche 20, une nouvelle couche pour la vision de l'ennemi, et en masquant la couche 9, qu' il ne puisse voir que le joueur Cette zone sera surveillée, mais ne pourra pas être surveillée. Et toujours activé par défaut. Mais il peut y avoir des obstacles qui bloquent leur vision. Nous pouvons également utiliser un nœud cast pour vérifier leur ligne de visée. Peu importe où se trouve la cible en ce moment, je vais juste la placer au milieu. Mais le point d'origine du Raycast devrait venir des yeux de l'ennemi Nous pouvons distinguer ces deux nœuds en les renommant pour Clarity Field Division ne recherchera que le joueur. La ligne de visée sera masquée par le terrain et le joueur, ainsi que par tout autre élément susceptible de masquer sa vision Ensuite, nous pouvons connecter les signaux entrants et sortants du nœud D de la zone 2 au script ennemi Ils portent bien leur nom pour nous permettre de visualiser le corps qui entre et sort. Stockons le héros dans une variable lorsqu' il entre et sort du champ de vision de l' ennemi. Grâce aux couches de collision, seul le héros devrait déclencher cette méthode. Mais il est toujours plus prudent de vérifier d'abord, stockant une référence au héros lorsqu'il entre dans le champ de vision et en réglant cette référence zéro lorsqu'il sort du champ de vision. Pour vérifier la ligne de visée, nous avons besoin d'une référence aux nœuds de ligne de visée définis pendant la phase de préparation. Ensuite, pendant le processus , nous n'avons pas besoin de delta. Si le héros se trouve dans notre champ de vision, nous allons faire quelques calculs, mais s'il n'est pas dans notre division de terrain, nous ne pouvons pas voir le joueur le définir sur false Nous pouvons définir la position cible de la ligne de visée comme étant la différence entre la position du héros et celle de l'ennemi en pointant la ligne de visée directement sur le personnage du joueur. Si la ligne de visée touche quelque chose et que c'est le héros, alors nous pouvons voir le joueur. Sinon, il ne doit heurter rien ou quelque chose d'autre, comme un terrain ou un obstacle. Nous ne voyons pas le joueur activer les formes de collision visibles dans le menu de débogage et appuyer sur Play De retour dans l'éditeur, nous pouvons passer à l'arbre des scènes distantes et sélectionner Fierce Tooth pour observer leurs variables dans l' inspecteur en temps réel. Nous pouvons maintenant voir que lorsque le joueur entre dans le champ de vision, la ligne de visée commence à suivre sa position. La variable can C player est définie sur true uniquement lorsqu'ils se trouvent dans le champ de vision et pas obstrués par le terrain depuis la ligne de visée Nous avons également besoin que le champ de vision change comme tout le reste lorsque l' ennemi fait face à gauche ou à droite. Saisir une référence au nœud de vision pendant la phase de préparation et remplacer les définitions de face gauche et face droite Nous pouvons commencer par appeler leurs super méthodes. Ajoutez ensuite le réglage de l' échelle X de vision à un lorsque vous faites face à la gauche ou à une valeur négative lorsque vous faites face à la droite. Puisque les ennemis sont tous tournés vers la gauche par défaut. Comme les moulages n'utilisent pas la propriété scale, nous devrons ajouter une condition supplémentaire lors du calcul de la position cible. Si le personnage ennemi n' est pas orienté vers la gauche, multipliez le X de la position cible par moins un pour le refléter. Une fois que l'ennemi a vu le joueur, nous voulons suspendre son comportement de patrouille et lui demander de poursuivre le joueur à la place Dans le script de patrouille, nous pouvons ajouter une variable booléenne privée pour contrôler si ce personnage patrouille ou non Et définissez sa valeur sur true par défaut. Fournissez ensuite des méthodes publiques pour suspendre et reprendre Le réglage de la valeur de revient à patrouiller dans chaque cas lorsque vous êtes en pause. Appelez également character run zero pour le forcer à arrêter de s' exécuter dans la méthode de traitement Si ce personnage ne patrouille pas, nous devons revenir et ne pas exécuter ce code Dans le script ennemi, nous pouvons obtenir une référence au nœud de patrouille pendant la phase de préparation, même s'il existe ou non, en utilisant une méthode nommée get node ou null en passant le nom du nœud que nous recherchons en argument. Remplacez ensuite chacune de ces trois lignes par un appel de méthode, indiquant à cet ennemi s'il peut voir le héros écrire ce nouveau héros de méthode privée. Il faudra un paramètre booléen savoir s' ils peuvent désormais voir le héros si l'ennemi ne peut pas le voir, ce qui signifie que la valeur jusqu'à présent était fausse, mais qu'ils peuvent maintenant voir le héros qui signifie que la valeur jusqu'à présent était fausse, mais qu'ils peuvent maintenant voir le C'est le moment exact où le joueur entré à la fois dans son champ de vision et dans sa ligne de visée. Ensuite, nous devrions définir Can See Hero sur vrai. Si la note de patrouille existe, demandez-lui de suspendre son comportement. Inversement, si l'ennemi pouvait voir le héros mais qu' il ne le peut pas maintenant, nous pouvons indiquer au comportement de patrouille de reprendre au cas où le héros se trouverait derrière l' Nous pouvons également forcer l'ennemi à faire face à la direction du joueur à ce moment-là en comparant ses positions globales et la méthode de traitement de l'ennemi. Si nous pouvons voir le héros, nous devrions courir vers lui en utilisant la différence l'exposition globale du héros et celle de l'ennemi pour connaître la direction et y apposer un signe. Ce n'est donc que moins un, positif un ou zéro que s'ils sont directement au-dessus ou en dessous. De retour à la vue, nous pouvons ajouter une autre zone au nœud pour gagner du temps. Faisons-en un enfant du nœud hip box et nommons-en une cible. Je vais le faire en jaune pour indiquer danger et je vais donner à cette forme la forme que vous jugerez logique, mais probablement similaire ou juste un peu plus grande que la zone de frappe rouge. Placez-le sur une autre nouvelle couche de collision, couche 21, la couche de ciblage ennemie et le masque. Pour la case Rt du joueur, couche dix. Il s'agira d'une surveillance et non d'un contrôle. Nous pouvons connecter le signal de la zone saisie au script de l'ennemi. Nous n'avons pas besoin de la zone deux D, nous pouvons donc la signaler par un trait de soulignement Ensuite, lorsque la boîte T du joueur entre dans la zone ciblée par l'ennemi, celui-ci attaque. Essayons-le. Quand Fierce Tooth voit Roger, ils le poursuivent. Et s'ils ne peuvent pas voir Roger, ils reprendront leurs comportements de patrouille habituels S'ils attrapent Roger, ils attaqueront. Nos ennemis peuvent désormais voir le joueur, le poursuivre et l' attaquer agressivement Dans la leçon suivante, nous allons créer un ennemi capable de tirer des projectiles Je te verrai dans la prochaine leçon. 48. Projectile 5-6: Bonjour les amis. Dans la leçon précédente, nous avons autorisé nos ennemis à percevoir le personnage du joueur et à l'attaquer. Dans cette leçon, nous allons créer un nouvel ennemi avec des attaques à distance. J'ai déjà commencé à créer un nouvel ennemi pour cette leçon, le coquillage. Jusqu'à présent, la structure de l'arborescence des nœuds est la même. La racine est un corps de personnage, deux D sur la couche de collision ennemie, masquant la couche de terrain avec le sprite, deux D, lecteur d'animation et un arbre d'animation Un nœud en forme de collision avec une ressource en forme de capsule, une boîte Rt, une boîte à hanches, une boîte cible et une vision correspondantes . Assurez-vous que chacune d'entre elles est réglée sur la couche de collision appropriée, masquant les bonnes couches et sont surveillables ou contrôlables Je vais commencer par ajouter un nœud en deux D nommé d'après l'origine du projectile, qui marquera l'emplacement exact où les projectiles seront tirés Et un nœud chronomètre qui indiquera à cet ennemi de tirer. Un projectile réglé pour démarrer automatiquement et se déclenchera toutes les 3 secondes Les animations ont toutes été remplies avec les sprites appropriés Inactif, touché, incendié et détruit. Une seule image est détruite. Ensuite, la deuxième image définit la propriété visible du sprite pour qu'il tombe pour le masquer. La machine à états de l'arbre d'animation fait passer les animations touchées et détruites sur la couche supérieure en fonction du coup et devient une variable morte du script du personnage à l'intérieur de la machine à état d'attaque Par défaut, le Seashell est inactif, puis passe au mode feu lorsqu'il souhaite revenir au mode inactif à la fin de l'animation et qu'il ne veut pas Créons un nouveau dossier de scripts de personnages pour les ennemis et ajoutons-y des scripts d'ennemis et de patrouille. Comme nous avons créé le script ennemi en héritant du personnage, nous pouvons donner au script ennemi un nom de classe enemy, puis créer un nouveau script nommé So Inheriting Maintenant, ce script possède tous les comportements et attributs d'un personnage, d'un ennemi, et tout ce que nous avons inclus dans le script du tireur pour faire apparaître un projectile, comme nous l'avons fait pour les pièces, nous pouvons exporter une variable de scène compressée, puis également exporter des variables pour décrire le comportement du projectile, comme sa vitesse, que j'aimerais et attributs d'un personnage, d'un ennemi, et tout ce que nous avons inclus dans le script du tireur pour faire apparaître un projectile, comme nous l'avons fait pour les pièces, nous pouvons exporter une variable de scène compressée, puis également exporter des variables pour décrire le comportement du projectile, comme sa vitesse, que j'aimerais décrire dans tuiles par seconde. Je le mettrai à dix par défaut. De même, les dégâts infligés par le projectile lorsqu'il touche le joueur, un entier compris entre 1 et 100 avec une valeur par défaut de un Pendant la durée maximale, j' autoriserai le projectile à exister avant de se détruire lui-même sous forme de flotteur, la valeur par défaut étant de 10 secondes. Pendant la période de préparation. Après avoir appliqué toutes les méthodes prêtes héritées, je multiplierai ma vitesse mesurée en tuiles par seconde par Cobolpt pour la convertir en pixels par Saisissez également une référence au nœud d'origine du projectile. En utilisant at on ready, nous pouvons écrire une méthode pour faire apparaître le projectile, qui sera appelée par l'animation de tir de l'ennemi au moment exact où le projectile Création d'une variable temporaire pour contenir le projectile nouvellement instancié. Nous pouvons le positionner à son point d'origine et l' ajouter à l'arbre des scènes en tant que frère de l'ennemi Si l'ennemi peut se déplacer, le projectile ne sera pas affecté par le mouvement du parent Elle existera en tant qu' entité indépendante du monde. Nous pouvons alors demander au projectile de tirer, lui donnant les informations dont il a besoin pour accomplir sa tâche, sa vitesse, ses dégâts et sa durée Cet ennemi ne tirera que des projectiles vers la gauche ou vers la droite, selon la direction dans laquelle il se trouve pour déclencher l'animation du feu Tout comme pour les animations d' attaque, nous allons avoir une variable booléenne wants to fire qui est définie sur true par une méthode publique fire dans le lecteur d'animation Sea Shell Pendant l' animation du feu, nous pouvons définir, vouloir riposter pour faire le apparaître projectile pendant l' image, au moment où il semble le plus correct Pour ce faire, dans la scène du coquillage, je vais également créer le projectile qui sera un nœud D de zone 2 Je ne veux pas que la physique soit appliquée à mes projectiles et je préfère calculer mathématiquement leurs comportements Si vous voulez que vos projectiles utilisent la physique, ils doivent utiliser un corps rigide en deux D comme nœud racine Le projectile tiré par l'obus ennemi est une perle que vous placez sur la couche ennemie touchée, masquant ainsi le terrain et la couche du joueur T. Puisque ce sont les seules choses que je veux que le projectile puisse toucher Et il aura besoin d' un sprite pour dessiner. Et une forme de collision, qui est le cercle. Je vais colorier le rouge. Positionner le projectile là où il doit provenir, dans le coquillage Vous souhaiterez peut-être repositionner le nœud d'origine du projectile en fonction apparence par rapport à l'ennemi tireur J'ajouterai également un nœud de temporisation, qui sera principalement utilisé pour limiter la durée d'existence de ce projectile Je vais régler le problème d'un coup quand la perle touche quelque chose que je voulais casser. Je vais ajouter un nœud en deux D nommé debris. Je vais masquer le sprite en forme de coquillage pour une meilleure vue pendant que je fabrique les débris perlés en utilisant les débris comme dossier. Je peux ensuite ajouter des nœuds enfants pour chaque morceau de perle cassée sous forme de corps rigide, deux nœuds en D. Depuis lors, j'aimerais appliquer la physique. Les débris auront leurs propres sprites et leurs propres formes de collision Je vais placer la moitié supérieure de la perle là où elle correspond au sprite perlé d'origine et lui donner la forme de collision correspondante Placez-les sur une nouvelle couche, quatrième couche pour les débris et masquez uniquement le terrain, empêchez-les de pivoter et bloquez-les avec le mode gel réglé sur Cinématique Dupliquez-le ensuite pour créer le sprite inférieur en le remplaçant et en le repositionnant pour qu'il corresponde au bas de la perle intacte Les débris du haut et du bas seront masqués par défaut. fois la structure du nœud terminée, nous pouvons enregistrer la branche du projectile en tant que scène propre dans un nouveau dossier Projectiles et l'ouvrir pour Nous pouvons maintenant supprimer la perle de la scène du coquillage et réinitialiser sa position pour qu'elle soit centrée sur l'origine Ajoutez ensuite un script au nœud racine de la perle nommé Projectile, enregistré dans le dossier des scripts ennemis Pendant la phase de préparation, je vais récupérer les références aux nœuds enfants. Je sais que j'aurai besoin d'y accéder, comme le sprite, les débris et le chronomètre Ayant déjà écrit l'appel à la méthode Fire dans le script du jeu de tir, nous pouvons lui donner une définition. Accepter une direction comme vecteur, deux vitesses comme valeur flottante, les dégâts comme nombre entier et la durée comme valeur flottante. Nous devrons stocker toutes ces valeurs dans des variables locales privées, à l' exception de la durée. La durée que nous pouvons simplement utiliser pour régler le chronomètre. Si la durée donnée était supérieure à zéro, une valeur inférieure ou égale à zéro serait considérée comme une durée illimitée. J'aurai également besoin d'une variable locale privée pour savoir si ce projectile a été détruit ou non. Dans la méthode de traitement, si ce projectile n'a pas été détruit, ajoutez à sa position la direction multipliée par la vitesse par Cela permettra au projectile de se déplacer en ligne droite à une vitesse constante Quel est le comportement attendu des projectiles dans la plupart des jeux vidéo Connecter la zone saisie dans le corps des signaux envoyés au script. Le seul corps avec lequel ce projectile doit percuter est le terrain Si cela se produit, il indiquera au projectile de se briser s'il entre dans une zone qui devrait être la zone de blessures du joueur. Je vais d'abord essayer de trouver le parent de la zone, qui devrait être le personnage du joueur. Après avoir vérifié qu'il s'agit bien du héros, je leur dirai de subir des dégâts, transmettant le montant et la direction des dégâts normalisés sous forme d'arguments, puis de casser le projectile En ajoutant la méthode break, je vais la connecter au signal de temporisation du chronomètre Il sera appelé automatiquement 10 secondes après le tir du projectile S'il n'a rien touché lorsque le projectile se brise, j'aimerais que différentes choses se produisent au fil du temps, ce qui pourrait être fait avec un lecteur d'animation, mais je préfère le faire avec un code relativement simple Tout d'abord, je vais ajouter une variable exportée pour la texture deux D, qui montre le projectile en cours de destruction Et remplacez le sprake par cette variable D est détruite par true Le projectile cesse de bouger et son masque de collision est à zéro, il ne déclenchera donc plus de collisions Ensuite, je souhaite réutiliser le nœud de temporisation, qui est actuellement utilisé pour déclencher la méthode d'interruption sur le signal de temporisation Comme il s'agit de la méthode de rupture, le projectile a heurté quelque chose et ce comportement n'est plus nécessaire Je vais obtenir le signal de temporisation du chronomètre et le déconnecter de la méthode d'arrêt Redémarrez ensuite le chronomètre avec une nouvelle durée, 0,1 seconde, soit la fréquence d'images que j'ai utilisée pour toutes mes animations. En attendant que le signal de temporisation soit écoulé 0,1 seconde plus tard, je vais définir la propriété visible des sprites sur False, puis je vais demander aux débris de se disperser Attendez ensuite dix secondes de plus avant de dire au moteur que ce projectile n'est plus pertinent et qu'il peut être retiré de l'arbre des scènes Nous pouvons maintenant créer un nouveau script pour disperser les débris en les attachant au nœud de débris, que je vais placer dans le dossier d' environnement Ce script n' a besoin que d'une seule variable, un tableau de nœuds qui sont ses enfants. Lorsqu'on nous demande de disperser, nous pouvons itérer dans ce tableau avec une boucle for en suivant le format utilisé dans d'autres langues pour l'écrire Pour chaque boucle, nous pouvons désigner chaque membre du réseau de pièces comme une pièce, puis lui dire de devenir visible, dégeler et de lui appliquer une force d' impulsion Comme les débris sont déjà répartis dans leur position initiale par rapport au trou intact, nous pouvons simplement utiliser leur position comme direction de la force d'impulsion, puis la multiplier par une tuile Bien entendu, vous pouvez expérimenter différentes forces appliquées pour disperser les débris est peut-être en train de normaliser la direction, sorte que leur distance par rapport à l' origine n'est pas un facteur Lorsque le coquillage est détruit, nous pouvons faire la même chose qu'avec la perle qui crée les débris. Nœud 2 D, cette fois avec quatre enfants. Pour chacun des quatre sprites en forme de coque cassée copiant et collant les nœuds , les paramètres seront déjà corrects Positionnez chacun à l' endroit exact où il correspondra au sprite ininterrompu de la coque et ajustez également leurs formes de collision Attachez ensuite le script de débris au nœud de débris. Enfin, connectez le signal d'expiration de la minuterie pour indiquer au coquillage de tirer toutes les 3 secondes En sélectionnant le nœud racine des coquillages, nous devons remplir la scène pleine contenant le projectile et placer le sprite face à gauche et face à gauche pour qu'il soit Oui Ajoutez ensuite une piste d'appel de méthode à l'animation détruite pour que les débris soient dispersés. Au même moment où le sprite des coquillages devient invisible, essayons-le. La carapace projette des perles toutes les 3 secondes qui entrent en collision avec le terrain et se brisent, générant des débris, qui sont automatiquement retirés Au bout de 10 secondes, ces perles peuvent toucher et blesser le joueur. Et le joueur peut également détruire le coquillage en l'attaquant avec l'épée. Nous avons maintenant un ennemi capable tirer des projectiles sur le joueur Dans la prochaine leçon, nous allons ajouter un boss ennemi à notre jeu. Je te verrai dans la prochaine leçon. 49. 5-7 Boss: Bonjour, mes amis. Dans la leçon précédente, nous avons ajouté un nouveau type d'ennemi capable de tirer des projectiles Dans cette leçon, nous allons ajouter une rencontre avec un boss ennemi à notre jeu. Je suis allée de l'avant et j'ai créé un nouveau niveau pour la rencontre avec le boss, un gouffre dans lequel le joueur ne pourra pas sortir du niveau une fois qu'il aura sauté ne pourra pas sortir du niveau une fois qu' Le point de contrôle est juste avant le boss et l'épée est là, donc ils l'ont déjà fait Le totem est composé de trois ennemis tireurs, qui sont presque exactement des seaux de coquillages de la leçon précédente Sauf qu'ils masquent la couche de collision ennemie des fins de cumul. Le totem bleu possède un polygone de collision personnalisé ce qui rend difficile pour le joueur de se tenir debout dessus, tout en étant capable de sauter par-dessus Dans leur projectile se trouve une pointe en bois qui est une copie de la perle, seuls les sprites et les formes de collision étant modifiés Contrairement aux sprites perlés, la pointe en bois n'est pas symétrique dans le script du projectile Ajoutons une nouvelle variable exportée, inversons selon la direction. Ensuite, lorsque vous tirez le projectile, si le retournement avec direction x est supérieur à zéro, nous devons régler l'échelle x deux moins un pour inverser le sprite, la forme de collision et les débris et régler la valeur des pointes en bois de cette variable sur true, laissant les Malheureusement, ces sprites totémiques ne sont pas centrés. Pour que les totems individuels puissent être orientés vers gauche ou vers la droite tout en restant centrés sur le mât totémique, ils auront besoin d'un décalage sprite x. Ensuite, en remplaçant les définitions de face gauche et face droite, je définirai le décalage des sprites comme étant ce nombre multiplié par un s'il y a des sprites face gauche un et vice versa pour Je définirai ensuite la valeur de cette variable pendant la phase prête, avant la phase super prête. Comme Super Ready indique au personnage de faire face à gauche ou à droite, j'ai découvert un problème lors du réglage de la position des projectiles avant de les ajouter à l'arbre des scènes Nous pouvons donc résoudre ce problème en l'ajoutant d'abord à l'arbre. De plus, je ne veux pas que la vitesse de renversement de cet ennemi soit augmentée lorsqu'il subit des dégâts. Dans le script du personnage, nous pouvons ajouter une autre variable de combat nommée stagger sous forme de float avec une valeur par défaut de cinq Les autres ennemis auront toujours le même comportement qu'avant. Ensuite, lorsqu'un personnage subit des dégâts, nous pouvons multiplier la vélocité de renversement par cette nouvelle variable et fixer sa valeur à zéro pour le boss, supprimant ainsi l'effet Comment créer une rencontre avec un boss ? Commençons par ajouter un nœud de zone à ce niveau. Lorsque le joueur entrera, nous commencerons à affronter Lorsque le joueur entrera, le boss, puis le configurerons pour qu'il surveille la couche joueur Je vais lui donner une forme rectangulaire et le faire remplir toute l'arène. J'aimerais que la caméra reste immobile et centrée pendant le combat contre le boss. Je vais donc ajouter un nouveau nœud de type A (marqueur deux nœuds en D) et le nommer Caméra Un nœud en deux D est presque exactement le même qu'un nœud deux D, sauf qu'il dessine un gadget en forme de croix dans l'éditeur afin que nous puissions facilement voir Si nous voulons que la caméra reste en place pendant le bosphte, nous devons être en mesure de modifier son comportement par défaut lorsqu' une variable booléenne suit le sujet par la valeur par défaut true dans la méthode de traitement true Si l'appareil photo ne suit pas le sujet, nous pouvons revenir pour éviter de changer la position de l'appareil photo. Créons une nouvelle variable de panoramique pour appliquer ce comportement de panoramique à l'aide d'une interpolation Ensuite, une nouvelle méthode publique, pan to marker, qui prendra un marqueur deux D comme paramètre ainsi que la durée du panoramique avec une valeur par défaut de 1 seconde. Si la poêle existe et fonctionne, nous devons la tuer. Créez-en un nouveau et demandez-lui de déplacer la position de la caméra vers la position globale du marqueur. Lorsque nous appelons cette méthode, nous voulons remplacer le comportement par défaut suivant en définissant is following subject to false Ensuite, nous pouvons ajouter une autre méthode pour reprendre en suivant le réglage du sujet sous réserve de vrai. Mais si nous en restons là, l'appareil photo s'adaptera fermement à la position du sujet. Tout d'abord, nous devons vérifier si la caméra est actuellement panoramique et supprimer ce comportement Si tel est le cas, nous pouvons alors inverser les calculs de position de la caméra à la méthode de traitement pour calculer plutôt les valeurs de distance de projection et de hauteur du sol à la position actuelle de la caméra. Émettez ensuite à la fois le signal de changement de direction et le signal d'atterrissage, ce qui ramènera doucement l'appareil photo au sujet De retour dans la scène des niveaux, nous pouvons également ajouter une couche de canevas au niveau. Contrairement à la couche de toile de la scène de jeu, qui sera dessinée sur tous les niveaux, cette couche de toile ne sera dessinée que dans les niveaux le boss copie la jauge de santé du joueur. Nous pouvons le coller dans le canevas des rencontres avec le boss, puis le repositionner pour qu'il soit en haut au centre de l'écran Et remplacez le cœur par le crâne, en le cachant. Par défaut, je vais m' assurer de ne l'afficher que pendant la bataille. Une fois la bataille terminée, je veux que le trésor de fin de niveau se dévoile. Je vais placer le trésor dans une zone impossible à atteindre et invisible dans le script du trésor. J'ajouterai une méthode publique simple nommée To Reveal, qui prendra une nouvelle position en tant que paramètre vectoriel à deux. Cette méthode déplacera le trésor vers la position souhaitée, rendez-le visible. Jouez l' animation de l'effet à l'envers. Attendez que l' animation soit terminée. Lancez ensuite l'animation par défaut en sélectionnant le nœud de rencontre avec le boss. Créons le script de rencontre avec le boss, enregistrant dans le dossier des scripts de l' ennemi. Ce script aura besoin d'une référence au marqueur de caméra et aux nœuds de jauge de santé définis pendant la phase de préparation. Mais aussi une référence à la caméra elle-même, laquelle nous pouvons accéder en commençant notre chemin depuis le nœud racine. Je vais également obtenir une référence au trésor du niveau en accédant d' abord au parent de ce nœud, qui sera le niveau. Obtenez ensuite les points de contrôle des nœuds. Vous pouvez également l'exporter sous forme de variable reliant le corps du signal saisi au script. Cela sera déclenché lorsque le joueur entrera dans la zone de l'arène du boss. C'est à ce moment que nous devons commencer la rencontre avec le boss. Stockons également une référence au héros dans une variable locale. Lorsque cela se produit pour faciliter le suivi de la position et du comportement . Pour démarrer la rencontre, je vais d'abord déplacer la caméra vers le marqueur de caméra, puis afficher la jauge de santé sur le canevas de l'interface utilisateur. Inversement, pour mettre fin à la rencontre, nous devrions demander à la caméra de recommencer à suivre le joueur et de masquer la jauge de santé. La fin de la rencontre peut se produire si le joueur meurt ou si le boss est vaincu Si le boss est vaincu, la rencontre doit prendre fin mais aussi révéler la récompense. Réutiliser le marqueur de la caméra comme lieu de récompense. Nous pouvons déclencher automatiquement la méthode de la rencontre finale en y connectant le signal sortant du corps Comme le joueur répondra en dehors de l'arène, ce script devra savoir quel est le boss ennemi. Dans l'exemple que j'utilise, le boss affronte en fait trois ennemis. Je vais exporter une série d'ennemis. Je ne veux qu' une seule jauge de santé pour suivre la santé combinée des trois ennemis. Je vais demander au script de rencontre avec le boss gérer la logique supplémentaire, créant deux nouvelles variables pour la santé actuelle et maximale. Ensuite, dans la méthode prête à l'emploi, je peux parcourir mon éventail de boss ennemis, en additionnant leur santé maximale pour obtenir un total combiné Réglez ensuite le courant pour qu'il soit égal au maximum. J'écrirai également ici une nouvelle méthode qui met à jour la jauge de santé. Démarrer l'état actuel à zéro et itérer dans le tableau Additionnez les points de vie actuels de tous les boss ennemis. Pour obtenir un total combiné, nous pouvons ensuite calculer le pourcentage de santé totale restant à injecter du courant sous forme flottante et le diviser par le maximum. Définissez ensuite la valeur des indicateurs de santé en utilisant ce pourcentage combiné Si le total des points de vie combinés est nul, le boss a été vaincu. Nous pouvons utiliser le signal de modification de l'état émis par le script de caractères pour appeler cette méthode. Mais le signal de modification de l'état de santé transmet un argument flottant, ajoutant en tant que paramètre à notre méthode. Nous pouvons l'ignorer en le faisant précéder d'un trait de soulignement et connecter les signaux pendant la méthode prête lorsque nous calculons la santé maximale Un mécanisme courant dans les jeux consiste à faire changer le comportement du boss à certains pourcentages de santé Si le boss n'est pas encore mort, appelons une méthode de vérification de phase, en passant le pourcentage comme argument. Comme ce comportement varie d'un boss à l'autre, laissez le corps vide avec une autre méthode vide. Décidez de la prochaine attaque. Nous avons maintenant toutes les structures génériques de combat contre les boss en place. Donnons à ce script un nom de classe afin qu'il puisse être hérité pour fournir des comportements spécifiques aux rencontres. Suppression du script de rencontre avec le boss du nœud. Nous pouvons plutôt le remplacer par un script hérité, décrivant spécifiquement les comportements du totem Dans ce script, nous pouvons définir comment il décide de ses prochaines attaques, ainsi que comment et quand il change entre les phases de combat. Je vais simplifier les choses en joignant simplement une note de chronomètre à la rencontre avec le boss, à laquelle je vais me référer dès que possible. Commencez au début de la rencontre avec le boss et arrêtez-vous à la fin de la rencontre avec le boss. Connectez ensuite son signal de temporisation pour décider de la prochaine attaque. Le totem décidera de ce qu'il faut faire toutes les 1 seconde. Ajouter un générateur de nombres aléatoires et un entier pour stocker un entier aléatoire. Je vais d'abord parcourir chaque boss du tableau des boss, puis générer un nombre aléatoire de puis générer un nombre aléatoire 0 à 2 pour que je puisse faire correspondre les résultats J'ignorerai zéro, ce qui signifie que l'ennemi ne fera rien. Si c'est un, ils feront face à gauche et tireront. Ou si c'est deux, ils feront face à droite et tireront. Pour augmenter la difficulté. Au fur et à mesure que la santé du boss ralentit, je vais vérifier quand le pourcentage atteint moins d'un tiers et moins des deux tiers lorsque ces seuils sont franchis. Je vais régler le temps d' attente des chronomètres pour qu'il soit légèrement plus court afin que les totems attaquent plus souvent Mais je vais m'assurer que le temps reste plus long que celui de l'animation, afin que vous puissiez terminer et revenir au ralenti entre chaque attaque. Je n'oublierai pas de remplir le tableau du boss avec les ennemis du boss. Essayons-le. La rencontre avec le boss est déclenchée lorsque le joueur entre dans l'arène. La caméra se déplace et se verrouille, et la jauge de santé du boss s'affiche, qui permet de suivre la santé combinée des trois ennemis. Si le joueur meurt, il reçoit réponse au point de contrôle et la rencontre avec le boss est interrompue jusqu'à ce que le joueur rentre dans l'arène Lorsque les ennemis sont tous morts, la jauge de santé disparaît, la caméra recommence à suivre le joueur et la récompense est révélée Nous avons maintenant un boss ennemi qui serait approprié pour terminer un monde de niveaux dans notre jeu. Dans la section suivante, nous allons nous concentrer sur les menus et la progression. Je vous verrai dans la section suivante. 50. 6-1 Pause: Bonjour les amis. Dans la section précédente, nous avons ajouté le combat à notre jeu. Dans cette section, nous ajouterons des menus et la progression. Si vous avez terminé la mission, tous vos ennemis auront désormais des comportements uniques. Permettez-leur de patrouiller dans une zone de votre niveau, rechercher le joueur, puis de le poursuivre et d'attaquer. Vous devez également avoir un canon capable de tirer un boulet de canon qui explose Si vous avez terminé les défis, vos ennemis peuvent également laisser tomber des trésors en cas de défaite. Le canon peut être utilisé par le joueur ou par un ennemi, et le coquillage peut également être mordu. Dans cette leçon, le joueur pourra mettre le jeu en pause et ouvrir un menu de pause. Commençons par ouvrir les paramètres du projet et ajouter un bouton de pause à la carte en entrée. J'utiliserai la touche d'échappement, le bouton de démarrage de ma manette de jeu. Toute notre gestion des entrées est actuellement traitée par le script du joueur. Mais mettre le jeu en pause n'a rien à voir avec le contrôle d'un personnage N'importe quel nœud de notre arbre de scène peut remplacer la méthode de saisie. mise en pause du jeu doit être de la responsabilité du game manager Dans le script Game Manager, nous pouvons ajouter une méthode de saisie qui prend un événement d'entrée comme paramètre. Si le bouton pause a été enfoncé, nous devrions suspendre le jeu. La méthode pause peut prendre un paramètre bulling, je vais l'appeler, qui doit être suspendu de cette façon Il peut être utilisé pour faire une pause si l'argument est vrai ou pour annuler une pause s'il est faux voit dans Godot, la pause est très simple, juste que la valeur de get tree paused, ou dans ce cas deux, doit être Ensuite, lorsque le bouton pause est enfoncé, nous pouvons transmettre la valeur de get tree pause avec un opérateur de nœud pour changer sa valeur en argument Mais si nous interrompons l' ensemble de l'arborescence des scènes, y compris le gestionnaire de jeu, celui-ci ne pourra rien faire , y compris recevoir des informations et suspendre le jeu Sélection du nœud racine des scènes. Je regarde l'inspecteur. Sous le nœud, nous pouvons étendre la section des processus et définir son mode de traitement pour qu'il fonctionne toujours, même lorsque le jeu est en pause même lorsque le jeu est en Tout ce que vous souhaitez mettre en pause dans votre jeu, sélectionnez le nœud et définissez sa propriété de mode de traitement pour qu'elle soit empilée. La valeur par défaut de inherit indiquera tous les nœuds enfants d'hériter du mode de traitement de leurs nœuds parents. La pause du nœud Rogers mettra également le nœud joueur en pause Les nœuds de niveau en pause mettront en pause tous les trésors de leurs ennemis et tout ce qu'ils contiennent. Les commandes de l'interface utilisateur, comme les boutons, continueront de fonctionner pendant que le jeu est en pause. Mais si vous utilisez des préadolescents pour les afficher ou les masquer, ils devront être configurés pour toujours en traiter deux. Essayons-le. Lorsque le bouton de pause est enfoncé, le jeu s'arrête. Lorsque le bouton de pause est à nouveau enfoncé, il se met en pause. Cela fonctionne, mais j'aimerais présenter au lecteur un menu de pause et quelques options Nous pouvons commencer par dupliquer le menu Game Over et le renommer Menu Pause, saisissant une référence au Pendant la phase de préparation, nous pouvons définir sa propriété visible lors de la pause ou de la remise en pause du jeu Je vais rapidement modifier la bannière en haut du menu de pause pour indiquer pause au lieu de terminer la partie. Modifiez ensuite le bouton Réessayer pour reprendre. Je ne veux plus que le bouton de reprise appelle la méthode en cas de nouvelle tentative Je vais modifier la connexion du signal. Nous pouvons en fait faire en sorte que cela appelle directement la méthode pause. Mais la méthode pause nécessite qu' un paramètre clique sur l'objectif avancé pour ajouter des arguments d'appel supplémentaires. L'argument que nous devons transmettre à la méthode pause est un booléen Nous pouvons l'ajouter à la liste et sa valeur par défaut est false, qui est exactement ce que nous voulons. Cliquez sur Connecter et sur le bouton Reprendre pour indiquer au jeu de se remettre en pause Les boutons de sélection et de sortie des niveaux peuvent rester exactement les mêmes que dans le menu Game Over. Mais je voudrais ajouter une autre option pour redémarrer ce niveau depuis le début, dupliquant le bouton de reprise Je vais remplacer celui-ci par Redémarrer et modifier le libellé du bouton pour qu'il s' adapte mieux à l'écran. Avec un bouton supplémentaire, je vais modifier la zone de style du panneau dans l'éditeur de thème. Cette image papier mesure 128 pixels, mais est entourée d'une bordure vide d'environ 12 pixels sur tous les côtés. Je peux dire à Godot de n'utiliser que la sous-région de cette image, en définissant les coordonnées de départ x et y, la largeur et la hauteur de la sous-région à Ensuite, je devrai ajuster les menus individuels pour que les mots apparaissent sur le papier. Le bouton Réessayer du menu Game Over et ce bouton de redémarrage ont un comportement très similaire Essayons de les combiner en une seule méthode. Le seul véritable changement que je souhaite apporter ici n'est pas de réinitialiser les vies et les pièces du joueur Nous pouvons la renommer en appuyant sur une nouvelle tentative pour redémarrer et lui faire prendre un paramètre booléen indiquant s'il s'agit ou non d' une partie terminée avec une valeur par défaut Passez ensuite cela à la méthode de nouvelle tentative des données du fichier, que je vais changer pour qu'elle s'appelle reset Le niveau sera déchargé, rechargé et le joueur retournera au début du Tout comme avant. Mais si le joueur a appuyé le bouton de redémarrage depuis le menu pause, nous devons également remettre le jeu en pause Nous pouvons le faire lors du chargement du niveau dans le script de données. Nous pouvons modifier la méthode de nouvelle tentative, renommer reset et remplacer le paramètre booléen par le jeu Maintenant, ce n'est que si cela est appelé depuis un état de jeu terminé que les vies et les pièces peuvent être réinitialisées. Dans le menu de pause, le bouton de redémarrage peut être connecté à la méthode de redémarrage. Comme la valeur par défaut du paramètre est false, n'est pas nécessaire de spécifier d'argument ici. Mais dans le menu Game Over, le bouton Réessayer peut être connecté à la même méthode de redémarrage Cette fois, en spécifiant vrai comme argument. Désormais, ces deux boutons utiliseront les mêmes comportements , la seule différence étant de réinitialiser vies et les pièces des joueurs s'ils n' en ont plus. Essayons-le. Maintenant. Lorsque le jeu est en pause, le menu de pause s' affiche et appuyer sur Reprendre masque le menu de pause qui met le jeu en pause Le bouton de redémarrage ramènera le joueur au début du niveau, rétablissant ainsi tous les composants du niveau à leur état d'origine Le bouton de sélection de niveau ne fait encore rien, puisque nous n'avons pas encore de menu de sélection de niveau et que le bouton de sortie quitte le jeu Nous pouvons maintenant suspendre notre jeu et proposer au joueur un menu d'options pendant que le jeu est en pause. Dans la leçon suivante, nous allons ajouter un écran titre pour démarrer le jeu. Je te verrai dans la prochaine leçon. 51. Title 6-2: Bonjour les amis. Dans la leçon précédente, nous avons ajouté un bouton de pause et un menu de pause à notre jeu. Dans cette leçon, nous allons ajouter une scène de titre et un menu principal. Commençons par créer une nouvelle scène en deux D nommée title enregistrée dans le dossier Scenes. Nous pouvons copier de nombreux composants d'autres scènes pour les intégrer à la scène titre. Comme pour l'arrière-plan, je vais définir la propriété d'échelle du nœud racine des scènes de titre sur trois, en fonction du zoom des scènes de jeu. caméra repositionne ensuite l'arrière-plan, remplit l'écran et capture les sprites animés de la surface de l'eau depuis ma scène de niveau Ajouter un nœud en deux D pour les maintenir en un seul groupe. J'ajouterai également un nouveau sprite animé à deux nœuds D contenant le navire marchand Remplir chacune d'entre elles avec les sprites du pack d'actifs. Nous pouvons configurer leurs animations pour qu'elles se jouent automatiquement à la fréquence d'images souhaitée. Je vais mettre le navire à l'eau en réorganisant leurs nœuds, un autre pour la voile et un pour Roger. Ensuite, ajoutez également un nœud Sprite à deux D pour l'ancre. Ensuite, ajoutez également un nœud Sprite à deux D pour l'ancre En ajoutant un nœud de couche de toile, nous pouvons ajouter des notes de contrôle à la scène de titre. J'utiliserai une case verticale pour contenir le titre et une autre pour maintenir les boutons. La zone de titre contiendra deux cases horizontales, une pour chaque mot, Jolly et Roger, remplies chacune de cinq lignes de texte directes J'utiliserai les grandes lettres du pack de ressources pour le titre épelant Jolly Roger Je veux que les lettres conservent toujours leurs proportions. Je vais augmenter la taille du titre huit fois pour qu'il domine la scène Puis dupliquez et répétez pour créer l'autre mot. Je vais déplacer le pivot pour qu'il soit au centre du titre. Utilisez ensuite des ancres personnalisées pour le centrer horizontalement sur l'écran et un tiers à partir du haut de l'écran Pour l'instant, mon écran titre ne comportera que deux boutons, Nouveau jeu et Continuer. J'aimerais que ces boutons aient le même aspect que ceux de mon autre scène. utilisons le même thème, mais le thème que nous avons créé est propre à la scène du jeu. Pour passer à la scène de jeu, sélectionnez n'importe quel nœud auquel le thème est appliqué. Comme le menu Game Over. élargissant le menu déroulant, nous pouvons enregistrer le thème en tant que fichier de ressources, rendant disponible pour l'ensemble du projet. Je vais l'enregistrer dans le dossier racine, le nommant bois et papier dans la scène de titre, en sélectionnant le nœud de commande des boutons. Le thème du papier en bois est désormais disponible dans le menu de chargement rapide et ses enfants héritent du thème Je vais agrandir les boutons quatre fois et les repositionner dans le coin inférieur gauche Je vais ensuite remplir chaque bouton avec cases horizontales remplies de recs de texture pour épeler leurs étiquettes, en gardant le rapport hauteur/largeur des lettres espaçant chaque lettre de deux pixels Et donnez aux boutons une taille minimale adaptée à leur contenu. réinitialiser la taille de l'étiquette, je vais l'ancrer au centre du bouton, puis je la dupliquerai pour créer l'étiquette continue Réinitialisation de son ancre. Je vais agrandir un peu les boutons et les repositionner. Le bouton Continuer sera désactivé par défaut, car cela n'aurait aucun sens d'autoriser le joueur à appuyer dessus. S'il n'y a pas encore de fichier Say, nous pouvons également glisser-déposer dans le fondu, puisque nous l'avons enregistré en tant que scène de zone. Voyons à quoi cela ressemble dans le script de fichier. Ajoutons une nouvelle méthode pour vérifier si le fichier sécurisé existe. Je ramène un taureau. Pour l'instant, il peut simplement renvoyer false. Tout comme les scènes de jeu nœud racine contient un script de gestionnaire de jeu. Cette scène de titre aura également besoin d'un script de gestionnaire de titres. Ce script va commencer par rendre le fondu visible. Je vais récupérer une référence au bouton Continuer en utilisant at on ready. Demandez ensuite au fichier de se charger automatiquement s'il existe un fichier à charger. Si un fichier say existe, nous devons définir la propriété désactivée du bouton de poursuite sur false, afin permettre au joueur d'appuyer dessus. Puis réglez le fondu pour démarrer le jeu. de connecter le bouton enfoncé envoie des signaux au gestionnaire de titres. Nous pouvons ajouter des méthodes pour gérer les deux boutons. Si le joueur appuie sur le nouveau bouton de jeu, je demanderai au fichier de se charger automatiquement pour créer une nouvelle ressource de données. Après avoir attendu fade, fade to black, je vais charger la scène de jeu, qui chargera le premier niveau de mon jeu en utilisant get tree change scene to file, qui prend un argument de chaîne représentant le chemin du fichier vers la scène que nous voulons charger. En explorant le système de fichiers, nous pouvons trouver la scène du jeu avec le bouton droit de la souris et copier son chemin. Ensuite, collez-le entre guillemets. S'ils appuient sur le bouton Continuer, je demanderai au fichier de se charger. Pour charger la ressource de données. J'aimerais ensuite passer au noir et changer de scène comme sur le nouveau bouton de jeu, mais charger la scène de sélection des niveaux à la place. Faisons des scènes changeantes une méthode distincte. Changez de scène en utilisant un paramètre de chaîne du chemin du fichier de scènes. Ensuite, appuyer sur les boutons « Nouveau jeu » et « Continuer » permet de changer de scène, mais de passer à une autre scène. ce jour, vous avez probablement appuyé le bouton Exécuter le projet par accident au lieu du bouton Exécuter la scène actuelle au moins une fois et vous avez été invité à définir une scène par défaut pour votre projet. Si vous n'avez pas encore défini de scène principale, vous pouvez cliquer sur Sélectionner Current pour définir cette scène titre comme scène principale. Vous pouvez également ouvrir les paramètres du projet, consulter section de l'application et définir la scène principale ici à l'aide du navigateur de fichiers. Si nous examinons la section Environnement de rendu, nous pouvons modifier la couleur par défaut qui s' affiche lorsque Cade n'a rien d'autre à afficher, en la réglant sur le noir pour couvrir tout écart entre la décoloration et la décoloration interne Maintenant, si nous appuyons sur le bouton Exécuter le projet, la scène du titre passe du noir Comme aucun fichier de validation n'existe, le bouton Continuer reste désactivé, mais nous pouvons cliquer sur le nouveau bouton de jeu. Cela passe au noir et charge le premier niveau, permettant au joueur de commencer à jouer à une nouvelle partie Notre jeu possède désormais une scène de titre qui permet d'accéder à la scène par défaut de notre projet. Dans la leçon suivante, nous ajouterons la scène de sélection des niveaux. Je te verrai dans la prochaine leçon. 52. Sélectionner le niveau 6-3: Bonjour les amis. Dans la leçon précédente, nous avons ajouté un écran titre et un menu principal à notre jeu. Dans cette leçon, nous allons ajouter une scène de sélection de niveaux. Je suis allé de l'avant et j'ai créé une scène de base, peu comme la scène titre avec juste un arrière-plan animé représentant Roger et la barre du navire, une couche de toile de fond et le fondu Comme nous l'avons fait avec la ressource thématique, nous pouvons ouvrir n'importe quel niveau, sélectionner le nœud de la carte de tuiles et enregistrer le jeu de tuiles en tant que ressource afin qu'il puisse être partagé par l'ensemble du projet. Dans la scène de sélection des niveaux, j'ajouterai un nœud de carte de tuiles et je le chargerai avec la ressource du jeu de tuiles. Utilisez ensuite la carte à carreaux pour dessiner le pont arrière d'un navire avec Roger à la barre. implique pour le joueur qu'entre chaque niveau, Roger navigue sur son navire entre les îles Voyons à quoi cela ressemble jusqu'à présent. C'est sympa d'afficher les niveaux. Je vais ajouter un conteneur de panneaux au canevas. Agrandissez-le pour qu'il corresponde à tout le reste et définissez son thème sur le bois et le papier. Ce conteneur contiendra une boîte verticale, qui contiendra une boîte horizontale pour le titre. Je vais placer quatre T de texture dans la case horizontale pour épeler les cartes de mots, en veillant à ce qu'elles conservent leurs proportions et restent centrées. Je vais également centrer le titre dans son ensemble et réduire la séparation entre les lettres. Sous le titre, je vais ajouter un conteneur quadrillé. Cela fonctionne un peu comme une boîte verticale ou horizontale, mais organise son contenu dans une simple grille. Comme les cartes mesurent chacune un quart, je vais en faire une grille deux par deux en réglant les colonnes à deux. Chaque cellule de la grille contiendra autre case verticale contenant un bouton et un panneau, dont le thème a été configuré pour ressembler à du papier. Je vais définir sa taille minimale à 36 x 32 pixels, afin qu'elle soit suffisamment grande pour contenir le nom du niveau. En utilisant une autre case horizontale pour écrire un trait d'union, je vais m'assurer que l'étiquette est ancrée au centre du papier N'hésitez pas à donner à vos niveaux le nom que vous voulez pour les boutons. Je ne veux pas utiliser le bouton vert. Je peux le supprimer en cliquant sur le bouton plat. Au lieu d'utiliser ces boutons verts et jaunes, je vais définir la propriété de l'icône des boutons comme étant la petite carte, une texture. Je vais m'assurer que le bouton reste centré dans sa cellule de grille. Under Theme remplace l' extension de la section de style. Je vais également définir le style de focus comme une zone de style vide afin que le bouton reste invisible. Je vais dupliquer le niveau 113 fois pour créer les autres boutons de la grille, en changeant les étiquettes de nom de chacun pour qu'elles correspondent aux niveaux. Vous pouvez concevoir cette interface comme vous le souhaitez, en vous adaptant au nombre de mondes de niveaux que vous souhaitez avoir dans votre jeu Mais cela suffit pour régler maintenant le pivot des conteneurs à panneaux de manière à ce qu'il soit en son centre. Je vais l'ancrer aux deux tiers du côté gauche de l'écran et à un ou deux du haut. Et modifiez les icônes des boutons pour qu'elles correspondent aux différents segments de la carte. Pour animer ces icônes de boutons, nous pouvons sélectionner une nouvelle texture animée dans le menu déroulant. Comme l'animation de la petite carte comporte huit images , je vais ajouter huit images à cette texture animée, puis définir chaque image en conséquence. Les valeurs par défaut indiquent à cette animation de jouer une image par seconde. Nous pouvons soit modifier la longueur de chaque image à 0,1 seconde, soit régler l'échelle de vitesse globale de l'ensemble de la texture à dix. Le bouton ne s'affiche pas, je vais donc modifier une propriété pour le forcer à être mis à jour. En répétant ce processus, je vais définir chacun des quatre segments de carte comme des textures animées pour les icônes de boutons respectives. Je vais supprimer l'espace excédentaire au bas du conteneur du panneau en redéfinissant sa taille et en donnant plus d'espace au titre avec une taille minimale personnalisée Création d'un nouveau script pour le gestionnaire de sélection de niveaux. Je vais d'abord faire référence au fondu en utilisant at on. Prêt. Une fois prêt, je réglerai le fondu pour qu'il soit visible, puis je lui demanderai de s'estomper pour qu'il soit clair. Je vais écrire une méthode personnalisée pour connecter les boutons à On level selected, qui prendra le monde et le niveau comme paramètres, tous deux représentés par des entiers Connectez le signal appuyé sur le bouton du premier niveau au gestionnaire de sélection de niveau et choisissez cette nouvelle méthode. Ensuite, en développant Advanced, nous pouvons ajouter deux arguments entiers à la connexion du signal, le monde et le niveau, tous deux avec une valeur de un. Définir les valeurs des données par points du fichier, du monde des points et du niveau comme leurs nouvelles valeurs. Nous pouvons ensuite attendre, passer au noir et charger la scène de jeu. La scène de jeu gérera automatiquement le chargement du niveau correct en fonction des données du fichier. N'oubliez pas que pour un niveau soit chargé à l'aide de cette méthode, il doit se trouver dans le dossier des scènes de niveau et nommé selon le format correct pour être détecté. Nous pouvons ensuite connecter les autres boutons à la même méthode, en modifiant les valeurs des arguments en fonction du monde et du niveau qui seront chargés, en nous assurant que le destin passe avant tout le reste. le positionnant au bas de la liste des nœuds, je réduirai la séparation des cases verticales pour qu'elles prennent moins de place. Réinitialisez ensuite la taille et la position du menu pour la dernière fois. Essayons-le en exécutant la scène actuelle. Une fois que la scène s'est estompée, cliquer sur le bouton du niveau 1 revient à zéro et le premier niveau est chargé Si nous recommençons, le fait de cliquer sur un autre bouton chargera un niveau différent. Notre jeu dispose désormais d'une scène de sélection de niveau, qui permet au joueur de charger n'importe quel niveau de notre jeu. Dans la leçon suivante, nous autoriserons le jeu à enregistrer et à charger les données des joueurs. Je te verrai dans la prochaine leçon. 53. 6-4 Save: Bonjour les amis. Dans la leçon précédente, nous avons ajouté une scène de sélection de niveaux qui permet de charger n'importe quel niveau de notre jeu. Dans cette leçon, nous allons enregistrer et charger les données de progression des joueurs enregistrer et charger les données de progression dans le script du fichier Nous avons déjà configuré de nombreuses méthodes que nous devrons suivre pour cette leçon. Dans d'autres moteurs et lorsqu'il s'agit de sauvegarder des consoles, chargement est une chose difficile à apprendre. Mais pour les besoins de notre jeu, le moteur Godot fournit des moyens simples pour accomplir exactement ce dont nous avons besoin Tout d'abord, nous devons savoir où stocker le fichier. Déclarons une variable nommée path de type chaîne. En commençant le chemin par deux points, Godot trouvera automatiquement l' endroit approprié pour stocker notre fichier, disons Sur la plupart des plateformes, nous pouvons donner un nom au fichier. Appelons-le sauvegarde automatique. L'extension de notre ressource textuelle est RS. Comme il s'agit d'une valeur qui ne doit jamais être modifiée, je déclarerai la constante au lieu d'une variable. Il s'agit d'un moyen plus efficace de stocker des valeurs dont vous savez qu'elles ne changeront pas. Contrairement aux variables conçues pour changer, l'objectif principal étant de réutiliser la même valeur à plusieurs endroits dans votre script sans la réécrire à chaque fois Le T signifie texte, ce qui signifie que le fichier créé peut être ouvert, lu et même modifié dans importe quel éditeur de texte qui n'est pas très sécurisé. Mais le chiffrement est très inefficace et ne vaut généralement pas l'effort supplémentaire, peu importe le nombre de mesures que vous prenez. Si quelqu'un veut tricher, il le fera. Je recommanderais uniquement de vous soucier de la sécurité des jeux multijoueurs en ligne Pour vérifier si ce fichier existe, il suffit d'appeler la méthode exists du chargeur de ressources en passant l'argument de chaîne de chemin. Pour enregistrer le jeu, il suffit d' appeler la méthode de sauvegarde de l'économiseur de ressources en transmettant les données à enregistrer et le chemin de leur emplacement Chaque fois que nous appelons save, cela remplace les données de sauvegarde existantes De même, lors du chargement, il suffit de définir la valeur des données comme étant le chargement du chargeur de ressources, en leur donnant le même chemin vers le fichier. Il s'agit d'une implémentation simple de l'enregistrement automatique d'un seul fichier Vous pouvez facilement associer les commandes de sauvegarde et de chargement aux boutons de menu. Et vous pouvez même créer plusieurs fichiers Say en utilisant le même processus. Le gestionnaire de titres est déjà configuré pour charger les données des joueurs lorsque le bouton Continuer est enfoncé. La question est de savoir quand devons-nous le sauvegarder ? Nous pouvons commencer par enregistrer les données au moment de leur création. N'oubliez pas que ce système de sauvegarde automatique ne stocke qu'un seul fichier, par exemple démarrage d'une nouvelle partie remplacera tout fichier sécurisé existant Ainsi, lorsque vous appuyez sur le nouveau bouton de jeu, s'il n' existe aucun fichier sécurisé, nous pouvons appeler une nouvelle méthode pour démarrer un nouveau jeu, créer le nouveau fichier de sauvegarde, l'enregistrer et passer à la scène du jeu Si un fichier say existe, nous devons demander l'accord du joueur avant de remplacer son fichier say existant Je vais rapidement créer un conteneur de base avec la question remplacer, enregistrer le fichier et deux boutons pour oui et non Et définissez les valeurs par défaut des propriétés par défaut, saisissant une référence à la confirmation en utilisant Add on Je le rendrai visible lorsque le joueur appuiera sur le nouveau bouton de jeu, mais un fichier sécurisé existe déjà. Connectez ensuite les touches « oui » et « non » au script. Tout ce que N a à faire est de masquer cette confirmation alors que oui, nous allons commencer une nouvelle partie. cause du format de mon jeu, je ne me soucie pas vraiment de ce qui se passe au cours d'un niveau en particulier. Pour suivre la progression des joueurs dans mon jeu, me suffit de savoir quand ils terminent ou quittent un niveau. Pour simplifier les choses, je peux enregistrer automatiquement le jeu chaque fois que le joueur entre dans la scène de sélection des niveaux. Dans le script du gestionnaire de jeu, certains boutons du menu de pause ne fonctionnent toujours pas. Ajoutons les transitions entre le menu pause du jeu et la scène de sélection des niveaux. Lorsqu'ils appuient sur exit, ils retournent à la scène titre. Ces méthodes sont accessibles depuis le menu de pause. L'arbre des scènes est suspendu lorsque ces transitions se produisent, lorsqu'une nouvelle scène est chargée, l'arbre reste suspendu Nous devrons remettre en pause l'arborescence des scènes lorsque les autres scènes seront chargées en utilisant les méthodes prêtes à l'emploi de leur gestionnaire Comme le menu de pause ne revient désormais qu'à la scène titre, celle-ci doit comporter un bouton de sortie pour fermer le jeu. Je vais le mettre dans le coin supérieur droit. Connectez le signal pressé au script du gestionnaire et laissez-le attendre de passer au noir avant d'appeler Get copy the exit button node Nous pouvons le coller dans la scène de sélection de niveau et modifier son signal pour le connecter au script du gestionnaire de sélection de niveaux. Et laissez-le attendre de passer au noir avant de passer à la scène titre. Essayons-le. Après avoir récupéré une pièce, je peux quitter le niveau revenant à la scène de sélection des niveaux, où la progression a été automatiquement enregistrée, fermant le jeu et en le relançant. Le bouton Continuer est activé car le fichier de sauvegarde existe pour être chargé. Appuyez sur Continuer pour accéder à la scène de sélection des niveaux, où n'importe quel niveau est chargé. Nous pouvons voir que le compteur de pièces a été enregistré et chargé entre les sessions, fermant le jeu et le relançant. Nous pouvons essayer de remplacer le fichier de sauvegarde et obtenir une confirmation avant de commencer une nouvelle partie avec zéro pièce Notre jeu enregistre et charge désormais les données des joueurs chaque fois que le joueur quitte ou termine un niveau Dans la leçon suivante, nous bloquerons l'accès aux niveaux et les débloquerons lorsque le joueur aura terminé un niveau. Je te verrai dans la prochaine leçon. 54. 6-5 Débloquer: Bonjour les amis. Dans la leçon précédente nous avons enregistré et chargé la progression du joueur. Dans cette leçon, nous bloquerons l' accès aux niveaux jusqu'à ce que le joueur termine le niveau précédent. Pour le débloquer dans notre ressource de données, nous voulons suivre les informations sur chaque niveau de notre jeu, qui sont organisés en mondes. Nous pouvons déclarer une variable nommée Progress comme un ensemble de mondes contenant un ensemble de niveaux, un tableau bidimensionnel, un rasoir vide Par défaut, nous devrons l'initialiser pour qu'il soit de la bonne taille pour nos besoins et le remplir avec des valeurs de départ Nous aurons besoin d'un tableau pour chaque monde et d'une valeur pour chaque niveau de chaque monde. Si j'avais deux mondes, le réseau ressemblerait à ceci, mais je n'en ai qu'un. Je vais supprimer le deuxième sous-réseau. Nous voulons que le premier niveau du jeu soit débloqué. Par défaut, je modifierai la valeur 0 à 1 en fonction du nombre de marqueurs de progression différents que vous souhaitez suivre par niveau Il peut être difficile de se souvenir de leurs codes numériques. Nous pouvons définir une énumération pour décrire les différents marqueurs de progression, commençant par le niveau verrouillé, puis déverrouillé , puis terminé Initialisez ensuite le premier niveau à débloquer par progression. Ajout d'une méthode publique pour définir un marqueur de progression. Nous pouvons prendre le marqueur de progression comme paramètre avec un identifiant mondial et un identifiant de niveau. Définissez ensuite la valeur de la progression indexée au monde moins un, au niveau moins un Puisque les tableaux commencent à zéro, mais nos numéros de monde et de niveau commencent à un en utilisant l'opérateur R equals avec le marqueur de progression, leur donnant une valeur par défaut En supposant que la plupart des marqueurs de progression seront définis pour le niveau auquel le joueur joue actuellement. Tout en nous permettant de définir des marqueurs pour d'autres niveaux si nous le voulons. Étant donné que ces nombres sont utilisés pour indexer un tableau, nous devons les valider pour éviter les pannes Pour que ces nombres soient considérés comme des indices de tableau valides, ils doivent être supérieurs à zéro et inférieurs à la taille du tableau. Puisque nous en soustrayons un à ces nombres. Si les indices du tableau ne sont pas valides, nous devons revenir. Mais nous pouvons également envoyer un message pour nous informer ou informer tout autre développeur de cette erreur, avec un avertissement indiquant que l' index des marqueurs de progression n'était pas valide et afficher le monde des identifiants de niveau utilisés. s'agit d'une opération binaire, ce qui signifie qu'elle ne traite pas ce nombre comme un entier, mais comme une série de bits, de uns et de zéros. Si nous considérons chaque bit comme un marqueur de progression, alors le premier marqueur de progression, le premier bit, verrouille le niveau, s'il est égal à zéro, et déverrouille le niveau s'il en est un Le bit suivant nous indique si le niveau est terminé, en commençant par zéro, ce qui signifie qu'il n'est pas terminé, puis en passant à un pour être terminé. Si le niveau commence avec une valeur de 0000, si vous le déverrouillez, il devient 0001, puis si vous le marquez comme terminé, il est 0011 Comme il est à la fois déverrouillé et terminé, nous pouvons modifier des bits individuels à l'aide d'opérateurs de bits, ce qui nous permet de coder une grande quantité d'informations en une seule variable Cet opérateur ou définira la valeur du bit marqué par le marqueur de progression à un. Nous pouvons également mettre le bit à zéro en utilisant le marqueur de progression inversé et égal à l'opérateur ajoutant un paramètre supplémentaire à la définition de la méthode Nous pouvons activer ou désactiver le marqueur de progression. J'utiliserai le comportement par défaut pour régler le bit sur un ou sur activé, car je n'ai pas l'intention de verrouiller un jour tout ce qui a été débloqué par le joueur dans mon jeu Comme une seule variable contient 32 bits, nous pouvons suivre jusqu'à 32 bits d'informations différents par niveau. De cette façon, vous pouvez ajouter des marqueurs de progression à l'énumération. Une énumération n'est qu'une liste numérotée. L'entrée en haut de la liste a une valeur par défaut de zéro. Le suivant, puis 234, et cetera. Nous pouvons modifier ces assignations numériques si nous le voulons, en bloquant une valeur de zéro, débloquant une et en complétant deux Mais je veux aussi savoir si le joueur ouvre un coffre au trésor dans mes niveaux. Le prochain indicateur de progression, au lieu de trois, sera quatre. Nous pourrions avoir jusqu'à 32 valeurs différentes dans cette énumération, doublant à chaque fois la valeur à huit, 16, etc. Si une valeur binaire est 0012, est 0104, est 100 Chaque marqueur de progression sera composé de zéros, un seul bit ayant la valeur un, qui est le bit qui sera défini ou dédéfini par la méthode du marqueur de progression défini Nous devons supprimer les niveaux verrouillés égaux à zéro, car la bonne façon de verrouiller un niveau serait de désactiver le marqueur de progression déverrouillé Nous devrons également vérifier les valeurs de nos marqueurs de progression, acceptant le marqueur de progression, les numéros d'identification du monde et du niveau. Identique à la méthode set, mais en renvoyant un booléen, nous pouvons renvoyer la valeur de la progression indexée par le monde sous forme de numéros d'identification de niveau moins Appliquez ensuite l'opérateur de fin de bit avec le marqueur de progression. Nous devons également vérifier que les indices du tableau sont valides avant de les utiliser, comme ci-dessus, et clarifier le message d'avertissement pour qu'il soit plus utile. Cela retournera vrai si le marqueur de progression est activé ou faux s'il est désactivé, ou si les indices n'étaient pas valides dans la scène de sélection des niveaux. Nous pouvons facilement contrôler le niveau auquel le joueur a accès en activant la visibilité des boutons de niveau, le conteneur de la grille triera automatiquement le contenu visible Dans le script Level Select Manager, nous pouvons obtenir un tableau des enfants des conteneurs de la grille en utilisant add on ready déclarant une nouvelle variable entière comme index dans le tableau des boutons de niveau. Ensuite, parcourez les mondes du tableau de progression. Encore une fois, parcourez les niveaux de chaque monde. Nous pouvons définir la propriété visible de chaque bouton du conteneur de la grille pour qu' elle corresponde au fait que ce niveau ait été débloqué ou non Nous devrons en ajouter un au monde et au niveau pour obtenir les numéros d'identification appropriés à partir de leurs index matriciels et incrémenter l' index des boutons à chaque fois Dans le script de niveau, nous pouvons exporter des variables pour savoir quel niveau est débloqué en terminant ce niveau et en définissant leurs valeurs par défaut sur un Le comportement par défaut sera de déverrouiller le premier niveau, accomplissant essentiellement rien mais ne provoquant aucune erreur Ensuite, dans le script du gestionnaire de jeu, lorsque la carte est collectée, nous pouvons définir le marqueur de progression du niveau en cours comme terminé. Et définissez également le marqueur de progression débloqué du niveau qui doit être débloqué en terminant ce Passez ensuite à la scène de sélection de niveaux du premier niveau. Je vais définir ses valeurs exportées pour déverrouiller le deuxième niveau. De retour dans le script de niveau, nous pouvons savoir si le joueur a ouvert le coffre, en obtenant une référence à la clé et au coffre s'ils existent. En utilisant at on ready get node ou null. Ensuite, lorsque le niveau est chargé pour la première fois, s'ils existent et le joueur a ouvert le coffre pour ce niveau, nous pouvons retirer la clé et indiquer au coffre qu' il a déjà été ouvert dans le script du coffre. Ajoutons une méthode publique déjà ouverte, en effaçant le tableau booty Ensuite, le réglage est bloqué sur faux et devient vrai lorsque le coffre est pillé. Définissez le marqueur de progression pour le niveau auquel le coffre a été ouvert vrai lorsque le coffre est pillé Définissez le marqueur de progression pour le niveau auquel le coffre a été Essayons-le. En démarrant une nouvelle partie, je peux quitter le premier niveau pour passer à la scène de sélection des niveaux, et seul le premier niveau est débloqué En revenant au premier niveau, je peux le terminer et je reviendrai à la scène de sélection des niveaux, où le deuxième niveau a été débloqué Revenir au premier niveau. Cette fois, je vais ouvrir le coffre et revenir à la scène de sélection des niveaux. Entrer une dernière fois dans le premier niveau pour voir que la clé n'est pas là et que le coffre est déjà ouvert. Désormais, la progression des joueurs dans le jeu est suivie par le biais, par exemple, d'un fichier, ce qui leur permet d'accéder à de nouveaux niveaux au fur Dans la leçon suivante, nous allons ajouter une musique de fond à notre jeu. Je te verrai dans la prochaine leçon. 55. 6-6 Musique: Bonjour les amis. Dans la leçon précédente, nous avons bloqué l'accès aux niveaux jusqu'à ce que le joueur ait terminé le niveau précédent. Dans cette leçon, nous allons ajouter une musique de fond. Commençons par la scène titre et ajoutons un nœud de lecteur de flux audio à la scène. Nous pourrions définir une piste audio ici, lui demander de se lancer automatiquement et régler le volume Procédez ensuite pour chaque scène du niveau. Mais les transitions entre les scènes nuiraient à nos morceaux de musique et seraient donc assez choquantes Tout comme l' écran passe au noir, la musique de transition devrait également être estompée pour offrir une Je vais laisser la lecture automatique activée pour le moment et le volume sera réduit au minimum. En gros, en sourdine. La plupart des développeurs de jeux qui ne sont pas également ingénieurs du son ont tendance à considérer le volume comme un flottant, 0-1, zéro étant muet et un étant le volume maximal. Mais le volume est en fait mesuré en décibels, qui ne s'échelonnent pas Doubler les décibels ne double pas le volume. L'échelle de volume ici va de moins 80 à 24 décibels Heureusement, nous n'avons pas besoin de savoir comment cela fonctionne pour pouvoir l'utiliser efficacement. Attachons un nouveau script à ce nœud musical. Lorsque le jeu démarre pour la première fois, le son joue automatiquement avec le volume coupé Nous pouvons commencer par faire passer doucement le volume de zéro au niveau souhaité, déclarant une variable pour stocker le volume souhaité. En termes plus simples et faciles à comprendre, un float de 0 à 1 avec une mise à l'échelle linéaire, la propriété de volume des nœuds du lecteur de flux audio est nommée volume DB pour les décibels Nous pouvons donc déclarer une autre nouvelle variable, le volume L, pour linear, afin de représenter le volume actuel sur une échelle linéaire et lui donner une valeur par défaut nulle ou mute. Dans la méthode prête à l'emploi, nous pouvons nous assurer que le volume reste atténué en réglant le volume en décibels pour qu' il corresponde au volume linéaire Convertissez-le avec une formule de conversion pratique fournie par Gade linear en décibels, en lui donnant le volume linéaire comme argument Définition d'une méthode privée pour atténuer le volume. Nous pouvons prendre le volume linéaire cible comme paramètre. En plus de la durée de l'effet du destin, la valeur par défaut étant de 1 seconde. Bien que le volume linéaire ne soit pas égal au volume linéaire cible, nous devons déplacer légèrement le volume linéaire vers le volume linéaire cible. Pour cela, nous pouvons obtenir le temps delta du processus et le diviser par la durée. Réglez ensuite les indécibels de volume pour qu' ils correspondent au volume linéaire et attendez la prochaine trame du processus pour recommencer Lorsque tout cela est fait, nous pouvons émettre le signal pour faire savoir à tous ceux qui l'écoutent que le volume est terminé. La façon dont ce code est écrit, il est évident que la valeur de la durée est censée être un nombre positif. Pour éviter d'éventuelles erreurs ou boucles infinies, nous devons vérifier si la valeur de la durée est inférieure ou égale à zéro. Dans ce cas, nous pouvons régler le volume, omettre immédiatement le signal et revenir Comme la musique sera probablement incluse dans chaque scène du jeu, il serait plus facile d'en faire un script de chargement automatique. Déplacer le script dans le dossier des chargements automatiques. Ouverture de l'onglet de chargement automatique des paramètres du projet. Nous pouvons l'ajouter à la liste des nœuds chargés automatiquement. Supprimez ensuite le nœud du lecteur de flux audio de notre scène titre. Pour qu'un gestionnaire de scène puisse contrôler la musique de fond avec une seule ligne de code, la musique de fond avec une seule ligne de code, il suffit de définir deux méthodes publiques, l'une pour démarrer une piste et l'autre pour l'arrêter. En commençant par stop track, nous allons prendre un temps de fondu comme paramètre, un float, avec une valeur par défaut de 1 seconde. Cela peut simplement s'appeler Fade. Le volume linéaire cible est égal à zéro, atténué, le dépassement du temps de fondu est l'argument utilisé pour déterminer la durée Attendez ensuite le signal de fin du volume avant d'arrêter le flux audio. Nœud joueur Pour jouer un morceau, nous pouvons prendre le morceau en question comme paramètre ainsi que le temps de fondu. Réglez le stream en cours de lecture sur cette nouvelle piste, demandez-lui de jouer, puis réduisez le volume au volume souhaité pendant la durée du fondu. Mais que se passe-t-il si un morceau est déjà en cours de lecture ? Nous pouvons ajouter quelques chèques supplémentaires. Tout d'abord pour vérifier si de la musique est déjà jouée, puis aussi pour vérifier si la piste en cours lecture est la même que celle que nous voulons écouter. Si tel est le cas, nous n'avons rien à faire et nous pouvons revenir. Nous pouvons également profiter de cette opportunité pour ignorer les pistes nulles. Sinon, le nœud musical joue actuellement une autre piste. Nous devrions effacer cette piste avant de passer à la nouvelle appelant le fondu avec un volume linéaire cible égal à zéro et en attendant le signal de fin du fondu du volume, le reste de la méthode permet d'obtenir le même fondu sur la nouvelle piste, évitant ainsi toute coupure dans chacun des scripts du gestionnaire de scène Nous pouvons exporter une variable pour contenir la piste de musique de fond de cette scène. Ensuite, dans la méthode prête à l'emploi, avant de passer à effacer, nous pouvons demander à la musique de jouer le morceau de musique Je remplis cette variable avec un morceau de musique provenant de la scène de sélection du niveau de mes actifs importés J'exporterai également une variable pour la musique de fond et jouerai le morceau pendant la méthode d'écriture. J'utiliserai la même musique de fond que la scène titre pour la scène de sélection des niveaux dans le script du gestionnaire de jeu. Lors du chargement d'un niveau, je demanderai la piste musicale du niveau. Ainsi, chaque niveau peut définir sa propre musique de fond dans le script de niveau, exporter une variable musicale et définir une piste différente de celle des autres scènes. Et j'ajouterai également des morceaux de musique à mes autres niveaux. Enfin, je vais également ajouter de la musique au script de rencontre avec le boss, mais aussi déclarer une deuxième variable pour enregistrer le morceau joué depuis le niveau au début de l'affrontement avec le boss. Je peux enregistrer la musique de fond normale des niveaux dans la deuxième variable, puis jouer le boss. Musique À la fin de la rencontre avec le boss, je reviendrai au niveau normal La musique qui animait la rencontre avec le boss était plus intense qu'au niveau normal Musique Lorsque vous quittez le jeu, nous pouvons également effacer la musique de fond. Lorsque vous importez de la musique de fond, il est important qu' elle soit conçue pour être en boucle en fonction de l' endroit où vous la trouvez boucle peut être encodée dans les fichiers eux-mêmes et être déjà capable de tourner en boucle pour ces fichiers Je dois ouvrir les paramètres d'importation et configurer leur mode de boucle pour avancer. Cliquez ensuite sur Réimporter pour les faire tourner en boucle. Essayons-le. L'écran titre s'estompe avec une presse musicale sur le thème des pirates et continue La musique continue de jouer pendant la transition de scène puisque la piste musicale est la même pour les deux scènes. Au début du niveau du boss, la musique s'estompe et s'estompe avec un nouveau morceau qui entre dans l'arène du boss La musique de fond par défaut du niveau est remplacée par une piste musicale plus intense. Lorsque le boss est vaincu, la musique redevient normale. retour à la scène de sélection des niveaux change à nouveau la musique et la sortie du jeu fait disparaître la musique avant de fermer la fenêtre Notre jeu diffuse désormais une musique de fond propre à chaque scène et à chaque niveau, permettant même de modifier temporairement les pistes. Dans la leçon suivante, nous allons exporter le jeu à jouer et à tester. Je te verrai dans la prochaine leçon. 56. 6-7 Export: Bonjour les amis. Dans la leçon précédente, nous avons ajouté une musique de fond à notre jeu. Dans cette leçon, nous allons exporter le jeu pour le distribuer et le tester. Avant de pouvoir exporter, Godot devra télécharger les modèles d'exportation depuis le menu de l'éditeur Sélectionnez Gérer les modèles d'exportation. Sélectionnez un miroir dans le menu déroulant, puis cliquez sur Télécharger et installer. Ces modèles permettent à votre projet Godot d'être exporté vers une grande variété de formats à des fins de distribution Une fois le processus terminé, vous pouvez fermer le gestionnaire de modèles d'exportation. Dans les paramètres du projet, nous avons déjà donné un nom à notre projet. Vous pouvez également ajouter une description, un numéro de version et une icône pour de meilleurs résultats. Essayez d'utiliser une image de 256 x 256 pixels, ou du moins de dimensions carrées. Nous avons déjà préparé la première scène. Si vous travaillez pour un studio ou un éditeur, vous pouvez également ajouter une image ici pour cela. Vous souhaiterez peut-être apporter des modifications aux paramètres d'affichage afin de mieux les adapter au projet exporté, exemple en mode plein écran plutôt qu'en mode fenêtré Si vous modifiez les paramètres d'affichage, assurez-vous de tester le jeu pour vous assurer que le jeu vendu s'affiche correctement avant de l'exporter. Pour modifier l'icône du jeu lors de l' exportation pour Windows, vous devez télécharger un exécutable d'édition RC depuis Github Je recommande de placer ce fichier dans le dossier Gio Projects, car vous aurez probablement besoin de l'utiliser dans la plupart, sinon la totalité, de vos projets. Dans le menu de l'éditeur, ouvrez les paramètres de l'éditeur sous Exporter Windows Il existe une option permettant d' ajouter le chemin vers le paramètre exécutable RC Edit Cado pourra désormais modifier les icônes des projets Windows exportés si vous possédez un certificat de signature de package C'est également à cet endroit que vous pouvez fournir ces informations Une fois tous les paramètres configurés, nous pouvons maintenant accéder au menu du projet et cliquer sur Exporter. Cliquez sur le bouton Ajouter et sélectionnez la plateforme sur laquelle vous souhaitez exporter votre projet. Deuxièmement, je vais choisir Web First. Nous n'avons pas besoin de faire grand-chose pour ajuster les paramètres ici. Exploration de la voie d'exportation. Nous devrions créer un nouveau dossier nommé Export, ou builds, si vous préférez. Ensuite, dans ce dossier, créez un nouveau dossier pour chaque plateforme. Dans ce cas, Web. chose la plus importante lors de l' exportation vers le Web est que le projet doit être nommé index HTML. Il s'agit du nom de fichier que les plateformes Web rechercheront lors de l'intégration de votre jeu Si ce n'est pas le cas, cela ne fonctionnera pas. En cliquant sur Exporter le projet, décochez la case Exporter avec débogage pour supprimer des éléments tels que Cliquez ensuite sur Enregistrer. Quand c'est fait, nous pouvons fermer la fenêtre. Une fois le projet exporté, retrouvez-le dans votre navigateur de fichiers. Sélectionnez tous les fichiers créés par Godot et compressez-les dans un fichier zip nommé index zip Il s'agit du fichier que vous allez télécharger pour intégrer votre jeu sur des plateformes d'hébergement Web, comme Itch dans les options d'intégration de ces plateformes charge de la mémoire tampon partagée peut être requise pour que le jeu fonctionne C'est l'un des moyens les plus simples de distribuer les premières versions de vos jeux. Des plateformes comme celle-ci vous permettent également de vendre vos jeux. Mais que se passe-t-il si votre jeu est vraiment bon et que vous souhaitez le vendre de manière professionnelle sur des plateformes comme Steam ? De retour dans la fenêtre d'exportation du projet, nous pouvons ajouter une autre plateforme, cette fois, Windows. Ici, vous souhaiterez peut-être ajuster certains paramètres, tels que la manière dont l'icône du jeu est redimensionnée dans un jeu de pixel art. La mise à l'échelle en utilisant le plus proche voisin permet de maintenir la pixellisation Vous pouvez également ajouter le nom de votre entreprise si vous avez un seul nom et une seule description. Copyright, marques de commerce, etc. Nous allons l'exporter dans un dossier distinct de celui de l'exportation Web, créer un nouveau dossier pour Windows et renommer le fichier exécutable pour qu'il corresponde au nom du jeu Si vous le distribuez en interne à des fins de test alpha, vous souhaiterez peut-être exporter une version de débogage pour les tests bêta, accès anticipé ou les versions de lancement Vous devez également désactiver le débogage dans les paramètres de débogage, en supprimant le wrapper de console Exportez ensuite le projet et enregistrez-le. Une fois le processus d'exportation terminé, vous pouvez trouver les fichiers exportés créés par Godot et votre explorateur de fichiers, sélectionner les fichiers, les compresser dans un fichier zip et télécharger le zip compressé sur les plateformes de distribution pour Le même processus peut également être utilisé pour le développement sur les plateformes Mac, Linux, IOS et Android. Les modèles d'exportation pour d'autres plateformes telles que Nintendo ou Playstation ne sont pas fournis par défaut. Vous devez être approuvé par la plateforme avant qu'elle ne vous autorise à utiliser son SDK pour créer des jeux Notre jeu est maintenant exporté et téléchargé sur des sites de distribution comme It ou Steam pour être joué par tout le monde. Vous avez désormais toutes les compétences nécessaires pour créer une plateforme et un jeu de pixels complets. Vous pouvez créer plus de niveaux, modifier et ajuster les éléments à votre guise et implémenter davantage d'actifs à partir de ce pack d'actifs Vous pouvez également télécharger d'autres packs de ressources ou créer vos propres ressources pour continuer à ajouter du nouveau contenu. Dans ce projet, tout est structuré manière à être édité de manière isolée. Vous pouvez modifier leurs scènes et scripts individuels si vous le souhaitez. Chaque implémentation n'est qu'un modèle de base sur lequel vous pouvez vous appuyer ou recréer le vôtre à partir de zéro et intégrer au jeu Tout changement, qu'il s' agisse du comportement de l'appareil photo ou de la gestion des fichiers de sauvegarde, doit être facile à modifier Grâce à la structure que nous avons construite, allez-y et créez votre jeu comme vous le souhaitez. Partagez-le ensuite avec la classe en téléchargeant le projet ou en partageant un lien vers votre page Ch Lisez les projets soumis par vos collègues et laissez des commentaires constructifs sur leur travail. Merci d'avoir suivi le cours et n'oubliez pas de consulter mes autres cours pour continuer à apprendre.