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.