Transcription
1. Promo: Êtes-vous prêt à commencer à créer votre tout premier jeu dans
le moteur de jeu Gudo ? Ou souhaitez-vous en savoir
plus sur l'utilisation des nœuds de contrôle de l' interface utilisateur
graphique de GDO Ou voulez-vous vous lancer le défi
de créer un jeu complet en une seule scène en utilisant uniquement des nœuds de contrôle ? Dans ce cours, nous
explorerons tout ce que nœuds de contrôle
Godo Gui ont à offrir en créant un jeu
complet à partir de zéro Il est recommandé de
concevoir votre propre jeu
pour ce projet. Votre jeu ne doit comporter
qu'une seule scène et utiliser uniquement les notes de
contrôle de Gooey Nous allons commencer par
créer un écran titre, contenant un titre,
une image d'arrière-plan, un bouton de démarrage et des liens vers les réseaux
sociaux, explorant la grande variété d' options disponibles
pour chaque type de nœud. Ensuite, passez
au jeu principal, ajoutez une barre de menu avec de nombreux
styles d'
options de menu, notamment des icônes, touches de
raccourci et des sous-menus, rédigez des scripts permettant de
créer et de gérer les données
et les paramètres des joueurs dans le langage de
script natif de Godo , Passons au développement de mécanismes de
jeu spécifiques à ma conception Nous explorerons les autres nœuds
de contrôle de Gudo'Guy en
détail au fur et à mesure afin que vous puissiez déterminer comment
les appliquer à Si vous êtes bloqué,
notre serveur Discord regorge d'autres étudiants, amateurs et
développeurs de jeux professionnels qui peuvent vous aider Cliquez sur le lien du site Web dans
mon profil d'enseignant pour m'inscrire. Commençons à
créer notre jeu.
2. Bonjour le monde: 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 Gado. 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
, 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
la leçon montre
qu'un nœud racine possède une icône et
la leçon montre
qu'un nœud racine possède une icône de
script qui nous
indique le nom du script lorsque nous le survolons indique le nom du script lorsque nous le 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. 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 ce problème en initialisant
aujourd'hui pour qu'il soit 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 une nouvelle valeur le 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. Instructions et conditions If: 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é s
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, connu sous le nom d'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 voir, selon que le voyant est allumé
ou pas
voir, selon que le voyant est allumé
ou non. 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 rien, 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 avant 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 pouvoir 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 connaissez
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 la valeur de deux yeux. 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 attribuer 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 pour 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
permet de 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. Boucles de temps 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 est assigné
à ne pas m'aimer, en 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é WOW, 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 de
la boucle WoW 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 observez 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 Au lieu de cela, il renvoie 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 donc être
simplifié comme suit : si le nombre de pétales module
deux est égal à un, alors la dame est heureuse Sinon, elle est triste. Et 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 Et 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 en apprendre davantage sur les ensembles de variables
associées. Je te verrai dans la prochaine leçon.
6. Tableaux et 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 nombre de résidents que les agents
du recensement devraient enregistrer ? 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 obtenir
une moyenne du nombre total d'
occupants de toutes
les maisons de Main Street ? 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 de l'enregistrer sous forme 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 souhaitions commercialiser
en tant que 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 déduire 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. 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 donc
tous les nombres de 1 à 13, et nous pouvons voir que cela est
imprimé 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, le verso de la
carte étant vierge, nous pouvons également imaginer
le jeu de cartes face vers le bas. 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 donc 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 donc cela
dans une variable sous forme d'entier et donnons-lui
une valeur initiale de un. En remplaçant celle de notre
index matriciel 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 effectuer une itération 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 pour réinitialiser
la boucle de Wile Si les quatre boucles terminent sans trouver de
paire correspondante, paire
trouvée sera fausse
et la boucle Wa 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 à leur ancienne
partie de Mad Dans la leçon suivante, nous
utiliserons une autre forme
de contrôle de flux. Je te verrai dans la prochaine leçon.
8. Correspondance 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 signe plus grand, une flèche,
suivis du nom du type 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éviation de 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 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
à 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. Dans le cas d'un plus grand nombre de cas, il
peut s'afficher hors 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é. Dans un bloc de correspondance, nous pouvons spécifier un nombre quelconque de cas
spécifiques pour la
valeur de la variable. Commençons par 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. 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 pourrions donc 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 avec 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 représente 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 de un à deux en février 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. 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. Cliquez avec le bouton droit sur le nœud racine, puis sélectionnez 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 des scènes 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 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 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 donc 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 l'opérateur 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 en séquence, 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 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 Ban 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. À présent,
nous pouvons voir chacun de nos employés
se déclarer 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
de 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. Nous souhaiterons peut-être 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 Comme notre
script de manager étend le champ « employé », tout ce qui est écrit dans
le script d'employé s'
appliquera toujours à celui-ci. Mais nous pouvons en ajouter d'autres
ou apporter des modifications. Un manager reste 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 GADOEngine, à 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
gestionnaire des opérations et l'arborescence des scènes, il existe désormais un champ dans
le panneau de l'inspecteur dans lequel 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. En regardant la scène, nous pouvons constater
que les nœuds auxquels attaché
le script du 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 autre
chose. 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. 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 de 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 car. 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'une fonction intégrée, Get node, 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 le 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 GD Script 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 GDScript n'
applique pas réellement ces règles de confidentialité Cependant, GDScript 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 en utilisant
le mot clé et 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 le
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: 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
comment 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. Ainsi, 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, appelons-la animaux, consiste à utiliser 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: 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 les
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 nous avons une variable
qui décrit 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 Bien qu'il 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. Débogage: 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 GADO, 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, que Gadot utilise pour la 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 Maintenir la
touche Ctrl ou Commande enfoncée et cliquer sur
le nom de la fonction globale nous
permettra d'accéder
à la référence
de cette fonction, ainsi qu'à sa description
et à son mode d'utilisation. Ils sont tous contenus dans
la classe de portée globale. OK, 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ène dans l'onglet local que
nous avons créé pour définir la scène, peu 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 son 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 GoDo, 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 l' de mes
cours de projet de jeu, bonne chance.
14. Configuration: Bonjour les amis. Si ce
n'est pas déjà fait, vous devrez télécharger
le GDOGameEngine depuis Extrayez ensuite le contenu
du dossier zippé. Assurez-vous de placer ce dossier
décompressé dans un endroit sûr de votre ordinateur Ouvrez Gudo lorsque vous êtes prêt. J'espère que vous avez terminé la série d'introduction à la programmation Vous avez
donc une
compréhension
de base de l'éditeur et de la manière
d'écrire des scripts Cliquez sur le bouton plus Créer
pour créer un nouveau projet. Notre objectif dans ce
cours est de créer un jeu complet en utilisant uniquement les
nœuds de l'interface utilisateur dans une seule scène. Vous pouvez donner à votre projet
le nom que vous voulez, par
exemple un cours d'interface utilisateur, jeu d'interface utilisateur
anonyme, ou si vous avez un nom pour votre
jeu, vous pouvez l'utiliser ici Godot créera automatiquement un nouveau dossier pour votre
projet dans les documents, ou vous pouvez cliquer sur Parcourir
pour modifier l'emplacement J'aime avoir tous
mes GdObjects dans un sous-dossier Ce projet n'impliquera
aucun rendu complexe, donc le moteur de rendu n'aura pas d'importance, mais je vais utiliser la compatibilité pour
pouvoir exporter vers Et GODO fournit un support de contrôle
de
version par défaut, ce qui est très
utile, et je
vous recommande vivement d'apprendre à
l'utiliser pour vos projets Comme notre jeu ne doit contenir qu'une seule scène utilisant des nœuds
d'interface utilisateur, commençons par créer notre nœud
racine comme interface utilisateur. Les nœuds de l'interface utilisateur sont tous dotés d'icônes
vertes pour les rendre facilement identifiables
dans l'arborescence des scènes. Nous pouvons renommer nos nœuds
en cliquant dessus une fois qu'ils sont déjà sélectionnés ou en cliquant dessus avec le
bouton droit de la souris et en sélectionnant Renommer Nommons l'écran de titre de ce
nœud. Enregistrez ensuite cette scène dans notre projet soit via
le menu principal, enregistrant la scène, soit en utilisant le
raccourci Control S ou Command S. Bien que le nœud racine soit
nommé écran titre, nous avons l'intention de créer
l'ensemble du jeu en une seule scène Un nom courant utilisé dans ce cas pour la
scène serait main, c'est
donc ainsi que je vais m'appeler Mcene Et avec une seule scène, nous pouvons simplement la laisser dans le dossier de ressources du
projet. Si vous n'êtes pas sûr de ce
que j'entends par nœuds d'interface utilisateur, sélectionnez le nœud racine
du projet. Examinez ensuite ses
propriétés dans l'inspecteur,
développez la section du thème, cliquez sur la
flèche vers le bas à côté du thème, puis sélectionnez un nouveau thème. Cette scène possède désormais
un thème qui
changera la façon dont tous ses nœuds de
contrôle sont affichés. Cliquez sur le nouveau thème pour l'
ouvrir dans le panneau inférieur. En élargissant ce panneau pour avoir une meilleure vue de
tout son contenu, nous pouvons voir une grande variété de
nœuds d'interface utilisateur prévisualisés Étiquetez des boutons de différents types, texte
modifiable, des chiffres
et des curseurs, des séparateurs, une barre de progression, des onglets, une arborescence et une barre de
défilement, le tout contenu dans un panneau et plusieurs conteneurs utilisés pour Certains nœuds de contrôle
ne sont pas inclus ici, dont un qui peut être utilisé pour afficher deux textures en D. Si vous n'avez pas encore choisi de
jeu pour votre projet,
essayez de trouver un jeu que
vous pourriez essayer de créer en utilisant uniquement
ces composants. Nous sommes maintenant prêts à démarrer
notre nouveau projet de jeu. Dans la section suivante,
nous allons créer un écran de titre de base
pour notre jeu. Je vous verrai dans
la section suivante.
15. Étiquette A: Bonjour, mes amis.
Notre projet étant lancé, nous allons commencer notre jeu
avec un écran titre de base. chose la plus élémentaire dont nous avons besoin pour l'écran titre de notre
jeu serait le titre. Commençons par
ajouter un nouveau nœud à l'arborescence des scènes
en cliquant sur le bouton plus, en cliquant avec le bouton
droit sur le
nœud racine et en sélectionnant Ajouter un
enfant ou en utilisant le raccourci
Contrôle A ou Commande A. Pour relever le défi consistant utiliser uniquement les nœuds de l'interface utilisateur, nous n'utiliserons que
les nœuds triés sous contrôle. Ce contrôle est
également du même type que le nœud racine de la scène. Nous pouvons voir dans la
description que le contrôle est la classe de base de tous les contrôles de
l'interface utilisateur graphique. Ces nœuds
adapteront leur position et leur taille en fonction de leurs nœuds de contrôle
parents. Le contrôle le plus souvent
utilisé pour afficher du texte est nommé étiquette indiquée
par une icône de balise. Nous pouvons également voir l'héritage
de la classe d'étiquette car chaque type de nœud est indenté dessous du type dont il hérite Tout nœud ou classe qui hérite d'un autre
aura
les mêmes propriétés héritées ainsi que ses propres propriétés supplémentaires Le nœud d'étiquette est donc un nœud, mais il s'agit également d'un élément de canevas, d'un nœud de contrôle et d'une étiquette. Chacun d'entre eux a ses propres propriétés et comportements. Nous pouvons voir que le nœud d'
étiquette est indenté sous le nœud racine car
il en est un enfant Le nœud racine étant
le parent de l'étiquette, celle-ci ajustera sa position et sa taille
en fonction du nœud parent. Nous verrons bientôt ce que cela signifie. Renommons le nœud d'étiquette en titre et examinons ses
propriétés dans l'inspecteur La première propriété est le texte que l'
étiquette affichera. Nous pouvons donc saisir le titre du
jeu ici. Il existe également
plusieurs options pour contrôler l'
alignement du texte, l'habillage, la
justification, la
séparation des paragraphes, le découpage, ellipses et les taquets de tabulation Rien de tout cela n'est vraiment
applicable à notre titre, sauf peut-être
en majuscules
si vous préférez
remplacer toutes les lettres minuscules par des majuscules Les propriétés situées sous le texte
affiché ne s'appliquent que
dans les situations où le texte est trop volumineux pour l'afficher
en une seule fois. Et les options BD sont disponibles pour les langues affichées droite à gauche au lieu
de gauche à droite. Rien de tout cela n'est important
pour le titre de notre jeu. Appuyons sur Play et voyons
notre titre s'afficher. Aucune scène n'ayant été sélectionnée pour la
scène principale de ce projet, nous sommes invités à la configurer. Appuyez sur Select current pour définir cette scène comme scène principale du
jeu, et nous pouvons voir notre jeu se dérouler, affichant le titre dans le coin supérieur gauche
de la fenêtre. Appuyez sur le bouton
d'arrêt pour terminer cette simulation. Cela fonctionne, mais ce
n'est pas très bon. Nous voulons probablement déplacer le
titre et augmenter sa taille. En examinant de plus près les
propriétés du nœud d'étiquette, agit de toutes les propriétés
du nœud d'étiquette lui-même, mais il existe d'autres sections de propriétés si nous faisons défiler la page vers le bas. La section suivante contient
toutes les propriétés
que le nœud d'étiquette
hérite du contrôle Si nous développons la section de mise en page, puis la section de transformation, nous pouvons voir les propriétés
de taille et de
position du nœud d'étiquette. Si vous ne voyez pas ce
rectangle dans votre vue en deux D, ajustez-le jusqu'à ce que vous puissiez utiliser la molette de la souris pour vous déplacer et zoomer. Ce rectangle bleu
est la zone d'affichage du jeu tel qu'il sera
affiché lorsque nous lancerons le jeu. Remarquez comment l'
axe X rouge chevauche le haut du rectangle bleu,
le faisant apparaître en magenta L'axe Y vert
chevauche le côté gauche, rendant cyan, et le point d'origine de la scène
se trouve dans le coin supérieur gauche Si nous cliquons et faisons glisser le titre hors
du coin supérieur gauche, ses valeurs de position X et Y dans l'inspecteur sont mises à jour pour
refléter sa nouvelle position. Remarquez que le fait de déplacer l'
étiquette vers
le bas augmente la position Y alors que la
déplacer vers le haut la diminue. Mettons le titre
quelque part au centre de l'écran. Appuyez ensuite sur le
bouton Play pour voir le changement. Le titre est désormais affiché
au centre de l'écran. Mais que se passe-t-il si
nous redimensionnons la fenêtre ? La position du
titre est déterminée par sa distance par rapport au coin supérieur
gauche de la fenêtre. Donc, si nous l'
agrandissons ou
le réduisons, le titre n'est plus
au centre de la fenêtre. Appuyez sur le bouton de réinitialisation pour ramener l'étiquette à
son origine, position 00. Vous avez probablement remarqué le X vert à l'origine lors de la
sélection du nœud d'étiquette. Il s'agit de quatre ancres, toutes pointant vers
la même position Passons du mode de mise en page
du nœud d'étiquette de la
position aux ancres. Cela ajoute une autre propriété nommée préréglages
d'ancrage,
que nous pouvons modifier Si nous changeons les
préréglages d'ancrage sur Full Wreck, c'est la même chose
que le nœud racine avec une ancre à chaque coin Si nous sélectionnons le nœud racine, les ancres pointent toutes
vers différents coins
de l'écran R sélectionnez le nœud d'étiquette. Les autres
options permettent d'ancrer l'étiquette à différents
endroits de l'écran dans les coins centrés ou étirés sur un axe
le long de l'écran. Ancrons le titre
au centre de l'écran. Maintenant, si nous appuyons sur Play, puis que nous redimensionnons la fenêtre, le titre reste centré même si la taille de
l'écran change Vous pouvez également personnaliser la façon dont
ces ancrages affectent le nœud en remplaçant les préréglages
d'ancrage par Cela nous permet de modifier
les points d'ancrage, les
définissant comme
des pourcentages de la largeur ou de la hauteur de l'écran Comme les ancres sont affichées
pointant vers les coins, chacun de ces paramètres de
point d'ancrage affectera deux ancres Je suis d'accord avec le fait de garder le
titre centré horizontalement, mais je
préférerais qu'il soit
légèrement déplacé vers le haut jusqu' à environ un
tiers de l'écran. ajustant le
point d'ancrage supérieur à un tiers, les ancrages en haut à gauche et en haut
à droite se déplacent vers le haut. Je vais également régler le point
d'ancrage inférieur à un tiers, afin que tous les points d'ancrage pointent
vers la même position Et les décalages d'ancrage peuvent être utilisés pour décaler la position du nœud par rapport au point
d'ancrage d'une quantité définie Cela peut entraîner une taille du nœud supérieure à celle du texte. La propriété
d' alignement de l'étiquette
affectera donc l'endroit où elle est dessinée. Je suis d'accord avec le fait que l'étiquette centrée sur le point d'ancrage Je vais
donc remettre tous mes décalages
d'ancrage à zéro La direction de croissance
affectera la façon dont le nœud est repositionné par rapport
au point d'ancrage
en fonction de sa taille Si on nous demande de croître vers la gauche
ou la droite, vers le haut ou vers le bas, nous pouvons voir comment le nœud est redimensionné et repositionné pour
s'adapter au texte Un titre de jeu aura souvent une police et une taille
de police uniques par rapport à tout autre
élément du projet. Dans de tels cas,
nous pouvons ignorer le thème que nous avons créé
dans la première leçon et développer la section
de remplacement du
thème des propriétés de contrôle Avant de pouvoir modifier la police, nous devons importer une
police dans le projet. J'ai téléchargé cette police
depuis Google Fonts. Nous pouvons importer des fichiers
dans le projet les
faisant glisser dans
la fenêtre de l'éditeur Godot Nous pouvons maintenant définir cette police comme
police pour le titre. Nous pouvons également modifier
la taille de la police. Je vais mettre le mien à 49. Les styles ne sont pas souvent utilisés pour les
étiquettes, mais pour le montrer, nous pouvons ajouter une boîte de style plate pour ajouter une
couleur d'arrière-plan à la police. En cliquant sur la case de
style, nous pouvons changer la couleur parmi
de nombreuses autres options. Comme je l'ai déjà dit, ce n'est pas vraiment quelque chose qui est
souvent utilisé pour les étiquettes, et nous passerons bientôt en revue les
boîtes de style plus en détail. Je vais supprimer la zone de style de mon étiquette de titre en cliquant
sur le bouton de réinitialisation. J'ajouterai plutôt des remplacements de thème pour la couleur de police, la couleur des
ombres et la couleur du contour, afin de rendre la police blanche et l'
ombre transparente Ajoutez ensuite des constantes pour
les décalages d'ombre, taille du
contour et la taille du contour des
ombres Comme le titre ne
comporte qu'une seule
ligne, l'interligne n'
aura aucun effet Comme indiqué précédemment, les nœuds de contrôle des
parents incidence sur la taille et la
position de leurs enfants. Comme nous l'avons vu précédemment, le nœud de l'écran
titre est ancré dans le rectangle complet
de la zone d'affichage. Mais si nous le redimensionnons, ses
enfants recalculeront leur position en fonction de la taille et de la position Dans ce cas, le
titre reste centré horizontalement et à un tiers
du haut de la zone de
l'écran titre. Nous pouvons le
rétablir comme avant en réinitialisant les ancres
de l'écran titre titre de notre jeu est maintenant affiché sur notre écran titre. Dans la leçon suivante,
nous allons ajouter un arrière-plan. Je te verrai dans la prochaine leçon.
16. Étiquette B: Bonjour, mes amis. Avant de
passer aux textures, nous pouvons explorer un peu plus ce que les étiquettes ont à offrir. Aucune des modifications apportées dans cette leçon ne sera
sans danger pour le projet, et je vais simplement revenir à la fin de la
leçon précédente avant de passer à autre chose Toute vidéo intitulée B
suivra cette règle, fournissant uniquement des
informations supplémentaires sur le sujet précédent, mais
peut être ignorée En sélectionnant le nœud d'étiquette, nous avons une propriété
nommée label settings. Tout comme la ressource thématique
de la première leçon, nous pouvons créer une nouvelle ressource de
définition d'étiquette ici, mais cela n'
affectera que cette étiquette. En créant cette ressource de
paramètres d'étiquette, nous ignorerons les remplacements de thème et utiliserons ces paramètres à la place Ici, nous pouvons modifier
les mêmes paramètres disponibles dans le thème, à savoir l'
espacement, la police, la taille de police, la
couleur, couleur, contour et l'ombre Ajoutons une deuxième ligne
de texte au titre. Si, pour une raison quelconque, la taille d' un nœud d'étiquette est
supérieure à celle du texte, les propriétés d'alignement
détermineront l'endroit où le texte est dessiné, qu'il se trouve à
gauche, au centre, à droite ou qu'il occupe toute la largeur, en
haut, en bas, etc. Si le texte est trop long pour tenir dans la
largeur spécifiée du nœud d'étiquette, nous pouvons utiliser le
mode Auto rap pour modifier
la façon dont le texte est automatiquement
déplacé vers la ligne suivante. Arbitrary sera simplement
coupé au caractère situé à la fin de
la largeur de l'étiquette. Word essaiera de combler les
espaces entre les mots, et Word Smart séparera un mot s'il ne tient
pas sur une seule ligne. Si la signification d'une propriété
n'est pas évidente et que vous souhaitez une explication plus
détaillée, passez la souris sur le nom de
la propriété pour afficher une
infobulle J'utiliserai un peu de Lormipsum comme texte d'
espace réservé pour expliquer
les prochains paramètres Les indicateurs de justification
peuvent être utilisés pour modifier la manière dont l'
alignement du texte de remplissage est implémenté. À partir de la version 4.4 de Gudo, vous pourrez
modifier le nouveau caractère de
ligne comme bon
vous semble Le texte du clip peut être utilisé
pour empêcher tout texte d'être dessiné en dehors des limites
du nœud d'étiquette. Si le texte du découpage est activé, comportement de dépassement du texte peut être modifié pour modifier la manière dont le
découpage est implémenté Découper des caractères
ou des mots, voire ajouter des ellipses pour
remplacer des caractères ou mots Le caractère des points peut également être changé comme vous
le souhaitez. Normalement, les caractères de tabulation dans la zone de texte sont ignorés lorsque l'étiquette affiche le texte, mais vous pouvez également ajouter des taquets de
tabulation à vos étiquettes Cliquez sur le tableau float
32 compressé pour le développer. Cliquez sur le
bouton plus Ajouter un élément pour ajouter un taquet de tabulation. Définissez ensuite la valeur
sous forme de nombre décimal. Plusieurs tabulations peuvent
être utilisées pour trier ou
créer des graphiques ou des colonnes
dans le nœud d'étiquette. Pour en revenir à Orm Ipsum pour illustrer le texte affiché, si un nœud
d'étiquette contient une grande quantité de texte, nous pouvons personnaliser
la quantité de texte dessinée à
l'aide de ces propriétés Les lignes ignorées masqueront les lignes de texte en commençant par le
début, tandis que le nombre maximum de lignes visibles masquera les lignes de texte
commençant par la fin Dans ce contexte, le terme « un négatif » signifie
illimité. Les caractères visibles peuvent
être utilisés pour contrôler le nombre exact de caractères
qui seront dessinés. Ceci est directement lié à
la propriété du ratio visible, qui est
identique, mais
exprimée en pourcentage de
l'ensemble du texte. La modification d'une valeur entraîne automatiquement
la modification de l'autre. Si la visibilité des caractères
et l'habillage des mots
sont utilisés à la fois , manière dont l'habillage des mots
est implémenté peut être modifiée en utilisant le comportement visible des
caractères. Par exemple, ce mot ne
rentrerait pas sur la première ligne
s'il était entièrement dessiné, mais il ne convient qu'en raison du nombre de caractères
visibles. En modifiant le comportement
des
caractères visibles caractères après
la mise en forme, le mot est placé sur la deuxième ligne qu'
il
soit complètement visible ou non. Les
paramètres de disposition des glyphes ne sont utilisés que si le sens de la mise en page
est défini de droite à gauche, et les paramètres BD concernent les langues qui
écrivent spécifiquement de droite à Je vais maintenant rétablir le projet tel qu'il était
avant cette leçon Ce sont toutes les options d'étiquetage. Dans la leçon suivante, nous allons
passer à la texture Rx. Je te verrai dans la prochaine leçon.
17. Texture droite: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté un titre à
notre écran titre. Dans cette leçon, nous allons
ajouter une image d'arrière-plan. J'ai trouvé cette image qui correspond
parfaitement
à mon idée de jeu sur le site free pic.com
créé par UpClac Assurez-vous de vérifier les exigences
d'attribution et de
licence des actifs que vous trouvez
en ligne avant de les utiliser. J'ai téléchargé cette image
et nous allons l'importer dans Gadot afin que je puisse l'utiliser comme arrière-plan de mes écrans de
titre Pour éviter que le dossier
de
ressources de mon projet ne soit trop encombré
et désorganisé, je vais créer un dossier
pour les Ensuite, dans ce dossier, créez-en un autre pour vous amuser. Faites ensuite glisser chaque fichier dans le dossier approprié pour que
je sache où les trouver. Pour dessiner cette texture, nous devons ajouter un nouveau nœud
enfant à notre scène. Le nœud que nous devons
utiliser pour dessiner des images à l'écran est le nœud détruit par la
texture Renommons l'arrière-plan de ce
nœud. Renseignez ensuite sa propriété de
texture avec l'image importée On ne voit plus le titre. L'image est
dessinée dessus. Par défaut, chaque nœud de l'arbre de scène est dessiné
de haut en bas. Le titre est donc dessiné
en premier, puis l'arrière-plan est
dessiné dessus. Nous pouvons
facilement réorganiser nos nœuds en les faisant glisser. L'arrière-plan est donc trié au-dessus du titre dans
l'arbre de la scène. De cette façon, le titre est
dessiné sur le fond. Cette image est beaucoup plus grande que la
zone d'affichage de notre jeu. Nous voulons que l'image
d'arrière-plan couvre la totalité de l'écran Nous allons
donc modifier ses
préréglages d'ancrage pour qu'ils soient complètement détruits Cela déplace l'image pour qu'elle soit centrée sur
les quatre ancres, mais elle est toujours trop grande. Si nous changeons le mode
d'expansion du nœud détruit par une texture, nous pouvons lui dire d'ignorer
la taille de la texture et utiliser à la
place la taille
spécifiée par les ancres L'image couvre désormais
toute la zone d'affichage, même si le
rapport hauteur/largeur de l'image ne
correspond pas exactement au rapport hauteur/largeur de
la zone d'affichage. C'est difficile à deviner
avec cette image, mais elle est maintenant déformée et
étirée verticalement. D'autres options existent pour forcer l'image à se redimensionner
en fonction de la largeur, ignorant la hauteur de l'image, en l'adaptant une disposition horizontale
ou en ajustant la hauteur, ignorant la largeur de l'image, préférant l'adapter à
une disposition verticale une ou l'autre des
options proportionnelles tente faire la même chose que les options
précédentes, conservant le rapport hauteur/largeur
des images. Avec un ajustement proportionnel à la largeur, l'image couvre l'ensemble de la zone d'affichage tout en conservant
son rapport hauteur/largeur. Ensuite, nous avons les options du mode d'
étirement, mises à l'échelle par défaut, qui permettront à l'image de s'
étirer de la manière
nécessaire pour répondre aux exigences du mode
d'extension et des Le mode vignette est destiné aux images
dont la taille est inférieure
à la taille fournie. Remplaçons donc l'image
par l'icône Gudo. Maintenant, la zone est
remplie de tuiles de l'image. annulant cette modification, keep ignorera le mode
d'agrandissement et forcera l'image à conserver ses dimensions
d'origine et à l'aligner sur
le coin supérieur gauche restez centré, vous conservez également les dimensions
d'origine de l'image, mais concentrez-vous dans sa zone. Conserver l'aspect permettra l'image de se rétrécir ou de s'agrandir
pour s'adapter à la zone. Si vous revenez à Ignorer la taille, étant donné que
les rapports hauteur/largeur ne correspondent pas, l'image ne couvre pas
la totalité de l'écran. Garder l'aspect centré
fait de même, mais centre également l'
image dans la zone. Garder l'aspect couvert
permet de redimensionner l'image, en conservant son rapport hauteur/largeur, mais en veillant à ce qu'elle
couvre toute la zone. Les bords gauche et droit
de cette image sont donc maintenant recadrés Si vous voulez vous assurer que
l'image entière est affichée, vous devez probablement utiliser
conserver l'aspect ou garder l'aspect centré et changer
la couleur d'arrière-plan pour remplir la zone inutilisée. Si cela ne vous dérange pas de
recadrer les bords, utiliser Keep Aspect Covered est également une bonne option pour les images
d'arrière-plan Les boutons de retournement horizontal et de
retournement vertical retourneront simplement l'image si c'est ce que
vous souhaitez faire Appuyons sur Play pour
voir à quoi cela ressemble. N'oubliez pas que si nous
redimensionnons la fenêtre du jeu, les ancres changeront et affecteront la façon dont l'
image est dessinée Bien que l'image soit redimensionnée d'
elle-même pour s'adapter à la fenêtre, le titre ne fera que se
repositionner lui-même, puisqu'il est dessiné
avec une taille de police spécifique Mais nous pouvons modifier certains paramètres pour mieux
contrôler ce comportement. Dans le menu principal,
sélectionnez les paramètres du projet. Regardez ensuite la fenêtre sous l'
écran. Ici, nous pouvons modifier les dimensions de notre
fenêtre d'affichage, en modifiant
les dimensions de la fenêtre de jeu lorsque
nous lançons le jeu, ainsi que les dimensions
du rectangle bleu
dans l'éditeur Il est conseillé de le
configurer de manière à ce qu'il
corresponde aux dimensions de votre plateforme de publication
cible. Les ancres n'ont pas encore été mises à jour, mais le fait de sélectionner ou de redimensionner les nœuds
les obligera à se mettre à jour, et nous pourrons rétablir leurs
préréglages d'ancrage Je peux changer si le jeu s'ouvre
en fenêtre ou en plein écran, mais ne modifiez pas
ce paramètre avant avoir trouvé un moyen
de quitter le jeu Vous pouvez également modifier l'endroit où la
fenêtre sera affichée à
l'écran en définissant le type de
position initiale sur absolu, puis en modifiant les
coordonnées de la fenêtre à l'écran. Et aussi sur quel écran
il sera affiché en changeant le type de
position initiale au centre de l'autre écran, puis en spécifiant
l'index des écrans. Ces options ne fonctionneront que
sur un projet exporté, pas lorsque nous
les exécuterons dans l'éditeur. Nous pouvons rendre la
fenêtre sans bordure. Et modifiez même si
la fenêtre peut être redimensionnée ou non. C'est une façon de résoudre
le problème, mais ce n'est pas une solution très
flexible. Les réglages sous Stretch
offrent de meilleures alternatives. Nous pouvons changer le mode
Stretch de
l'ensemble du jeu en passant du mode
désactivé aux objets Canvas. N'oubliez pas que tous les nœuds de contrôle
héritent de l'élément Canvas, ils seront
donc tous
étirés avec la fenêtre Un autre paramètre permet d' étendre l'ensemble de la fenêtre d'affichage, qui inclura la
sortie de trois caméras D. Lors de cet étirement, nous pouvons changer si l'affichage du jeu
conservera ou non ses proportions. Ignorer permettra au jeu de s'écraser et de s'étirer dans
n'importe quelle direction Si vous conservez la largeur ou la hauteur, la fenêtre
de jeu ne
pourra être redimensionnée que dans la limite de sa
largeur ou de sa hauteur. extension permet à l'
affichage des jeux de croître et de diminuer, tout en
conservant
le rapport hauteur/largeur, mais elle s'agrandira pour remplir toute
la fenêtre. L'échelle peut être utilisée pour réduire
automatiquement tous les éléments du canevas à la
moitié ou jusqu'à
huit fois leur taille. Utile pour développer
pour des plateformes dont les
résolutions sont radicalement différentes de celles de votre machine de développement. Et le mode échelle peut être défini sur un entier
pour limiter la mise à l'échelle à la seule division ou multiplication par des nombres entiers. Cela est particulièrement utile pour pixel art, car cela ne
provoque aucune distorsion des pixels tente d'étirer ou réduire les pixels de
manière fractionnée. Les
paramètres d'orientation de l'appareil portable sont disponibles pour le développement
mobile afin de se
limiter au portrait, paysage, à l'envers ou d'utiliser le capteur de l'appareil pour
déterminer l'orientation Et le mode VSync peut être
modifié pour déterminer comment le GPU de la machine est synchronisé avec le taux de rafraîchissement de l'
écran Ces paramètres ne sont pas
disponibles lors de l'utilisation du moteur de
rendu de compatibilité et ne
seront pas applicables à tout ce que
nous faisons dans ce projet Nous avons maintenant une
image de fond pour notre écran titre. Dans la leçon suivante, nous allons
ajouter un bouton de démarrage. Je te verrai dans la prochaine leçon.
18. Bouton A: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté une
image d'arrière-plan à notre écran titre, et dans cette leçon, nous allons
ajouter un bouton de démarrage. En ajoutant un nouveau nœud à
l'écran titre, comme nous l'avons fait auparavant, nous
recherchons
cette fois le nœud bouton. Tout comme le nœud d'étiquette, un bouton peut contenir
du texte, mais également une icône. Nommons les boutons Start. Ensuite, placez également le même
texte dans le champ de texte pour qu'il soit affiché
sur le bouton. Il existe également un champ d'icône, que nous pouvons remplir avec l'icône Gadot pour
voir comment cela fonctionne Le bouton est dessiné sous la forme d'un rectangle arrondi comprenant à la fois le texte et
l'icône fournis Le bouton plat supprime
toutes les textures ou couleurs
du bouton, ne
dessinant que le texte et l'icône Cependant, l'ensemble de la
zone des boutons est toujours cliquable, et
le bouton possède toujours
un style de mise au point qui sera
dessiné une fois le focus activé En élargissant les sections sur le comportement du texte
et le comportement des icônes, nous pouvons modifier l'
alignement du texte et de l'icône pour modifier la façon dont ils
sont affichés sur le bouton. Ces modifications sont beaucoup plus apparentes si la taille
du bouton est supérieure à ce qu'elle devrait être pour
accueillir à la fois le
texte et l'icône. Certains paramètres de
comportement identiques sont disponibles en tant que nœud d'étiquette
pour contrôler le dépassement de texte Emballage automatique. Et le découpage si la taille du bouton est trop petite pour
contenir le texte Et l'icône peut être agrandie pour correspondre à la
taille du bouton. Les options BD sont également disponibles pour les langues
écrites de droite à gauche. Le bouton de base est une classe dont
tous les boutons héritent, même les boutons d'autres types Nous passerons en revue ces paramètres
dans la leçon B. Pour l'instant, modifions
les propriétés héritées du contrôle, commençant par la mise en page. J'aimerais que mon
bouton de démarrage soit situé en dessous mon titre, aux deux tiers
de la hauteur de l'écran. Donc, en passant du mode
de mise en page de la position à l'ancre, je vais changer les
préréglages d'ancrage en mode personnalisé Déplacez ensuite l'ancre gauche à 0,5 et l'ancre supérieure à 0,667 L'ancre droite ne peut pas être plus à gauche que
l'ancre gauche, elle est
donc automatiquement
remplacée par la même valeur. De même, l'ancre inférieure ne
peut pas être au-dessus de l'ancre supérieure. Le bouton se trouve actuellement en bas et à droite
de l'ancre, je vais
donc changer les
directions de croissance pour les deux. Réinitialisez ensuite les décalages
d'ancrage pour centrer le bouton
autour du point d'ancrage Une fois le bouton positionné, l'étape suivante consisterait à
modifier les propriétés du thème. Si vous souhaitez que le
bouton soit unique, il serait
approprié d'utiliser la
section de remplacement du thème pour ce bouton Mais si vous souhaitez que plusieurs boutons partagent les mêmes propriétés de
thème, il serait préférable de ne les définir
qu'une seule fois. En sélectionnant le nœud racine, nous avons créé un thème
dans la première leçon, ou vous pouvez en créer un maintenant
si vous ne l'avez pas encore fait. Nous allons changer la police
et la taille de police par défaut pour notre thème, et nous pouvons voir les effets de ce changement dans l'aperçu du
thème. Bien que ce thème soit une
propriété du nœud racine, non du bouton, les
modifications apportées à ce thème affecteront
également le bouton. Cela est dû au fait que le thème
est transmis par
le biais de l'arbre des scènes du parent à l'enfant sous une autre
forme d'héritage. Si un nœud utilise des
propriétés de remplacement de thème telles que le titre, ces paramètres
remplaceront les thème héritées Si vous regardez
le panneau du thème, notre aperçu du thème contient un nœud de boutons avec les propriétés du thème
par défaut, sauf que la
police et la taille ont été modifiées selon
les nouveaux paramètres. En cliquant sur le bouton Plus, nous pouvons ajouter des types de nœuds
au thème, comme le bouton. Cela ajoute plusieurs propriétés que nous pouvons ajouter
au thème et modifier. À partir de la section des couleurs, nous pouvons changer la
couleur du texte et de l'icône lorsque le bouton
est dans différents états. La couleur de police normale des boutons doit contraster
avec l'arrière-plan. Je vais simplement utiliser le gris clair
par défaut. Souvent, un
bouton désactivé aura texte
gris, parfois
même transparent. Les boutons survolés peuvent
éclaircir la couleur. Pressé, c'est parfois plus foncé, et j'ajouterai également
une couleur de contour. Toutes les mêmes options de couleur sont également disponibles pour l'icône, qui sera multipliée par les couleurs de la texture de l'icône
pour produire le résultat. Dans la section des constantes, nous pouvons ajouter le nombre
de pixels séparant le texte de l'icône lorsqu'ils
sont alignés horizontalement. Outre la
largeur maximale de l'icône, la hauteur de
l'icône
sera automatiquement ajustée en fonction de
son rapport hauteur/largeur. Et nous pouvons également spécifier la
taille du contour du texte. Nous n'avons pas encore abordé les zones de
style, mais si vous utilisez
des boîtes de style de tailles différentes, vous pouvez ajouter cette propriété et définir sa valeur sur un pour forcer le bouton à toujours utiliser la taille de sa
plus grande boîte de style. Nous pouvons changer la police de
tous les boutons si nous le voulons, mais je vais simplement utiliser la police de mon thème
par défaut. Je vais cependant augmenter légèrement
la taille de police de mes boutons par rapport à ma taille
de police par défaut. Dans la section des icônes, nous pouvons spécifier une
icône par défaut à utiliser pour tous les boutons. L'icône définie dans les propriétés des
boutons remplacera cette icône
si elle est fournie Donc, si vous voulez que presque
tous les boutons de
votre jeu aient la même
icône, vous devez la définir ici. Mais vous pouvez également
avoir des boutons spéciaux avec des icônes uniques. La section suivante concerne les styles, où nous pouvons dessiner un
arrière-plan différent pour le bouton, autre que le rectangle incurvé
noir transparent
par défaut . En commençant par le mode
normal, voici à quoi ressemble
le bouton lorsqu'
il ne fait rien. En l'ajoutant au thème, nous avons plusieurs options
pour fournir des styles. La texture Style Boox
est utilisée pour dessiner des images
importées à utiliser comme arrière-plan
des boutons J'ai ces images de boutons
que je vais importer dans Gadot avec le
dossier des actifs déjà sélectionné De cette façon, ils sont
automatiquement
importés dans ce sous-dossier Cliquez sur la zone de style pour l'
ouvrir dans l'inspecteur. Réglez ensuite la texture normale
sur la zone de style normale. Je ne souhaite en aucun cas modifier
la texture, mais le texte et l'icône ne s'intègrent pas vraiment bien dans
l'image d'arrière-plan. Je vais donc ajouter des marges
de contenu pour éloigner l'icône et la
texture des côtés les placer
dans l'intérieur plat
du bouton. Passons au style pressé, nous pouvons ajouter une autre texture de boîte de
style. Mais cette fois, remplissez la texture avec l'
image pressée du bouton. Ajoutez ensuite les mêmes
marges de contenu que d'habitude. Et répétez cette opération pour ajouter des options
désactivées et survolées. Je n'ai pas de
texture unique pour Hover Press, mais nous pouvons rapidement
dupliquer une zone de style
en cliquant et en faisant glisser celle
qui est pressée dans la fente sélectionnant le bouton
dans l'arborescence de la scène, nous pouvons prévisualiser à quoi
ressemble le bouton lorsqu'
il est désactivé en cochant la case désactivée dans les propriétés héritées
du bouton de base cours de jeu,
nous pouvons également voir le style du bouton changer
lorsque vous le survolez et
que vous appuyez dessus Cependant, une fois enfoncé,
le bouton est désormais focalisé, qui lui donne
cette bordure blanche. Si vous souhaitez le supprimer, vous pouvez fournir une autre zone de
style pour le focus. Ou bien, nous pouvons simplement ajouter une boîte de style
vide pour la supprimer. Ce bouton ne fait
rien pour l'instant, mais nous devrons
attendre une autre leçon. Nous avons maintenant un bouton de démarrage
pour un écran titre. Dans la leçon suivante, nous
ajouterons des liens vers les réseaux sociaux. Je te verrai dans la prochaine leçon.
19. Bouton B: Bonjour, mes amis.
Avant de poursuivre, nous allons passer en revue quelques
fonctionnalités supplémentaires des boutons. N'oubliez pas qu'aucune
des modifications
apportées au cours de cette
leçon ne sera enregistrée. Nous avons abordé la propriété désactivée de la classe de boutons de base, mais de nombreuses autres
propriétés sont répertoriées ici. mode bascule transformera le
bouton en bascule,
ce qui signifie qu'une fois qu'il est enfoncé, il restera enfoncé
jusqu'à ce
qu'il soit à nouveau pressé bouton enfoncé peut
être utilisé pour définir l'état par défaut du bouton lorsqu'il est
utilisé comme bascule S'il ne s'agit pas d'une bascule, le bouton ne peut pas
être réglé pour Nous pouvons changer si le bouton est considéré comme enfoncé lorsque le bouton de la souris est relâché
ou lorsque le bouton de la souris
est pressé pour la première fois. Spécifiez également le bouton de
la souris
utilisé pour cliquer sur le bouton. Si l'option Maintenir la touche
extérieure est activée, le fait de
cliquer sur le bouton et déplacer la souris en dehors des limites
du bouton
permet de maintenir
l' état enfoncé jusqu'à ce que le bouton de la
souris soit relâché. Un groupe de boutons peut être créé pour transformer un bouton à bascule
en bouton radio, ce qui signifie qu'un seul bouton
peut être pressé à la fois Nous verrons comment cela fonctionne lorsque nous l'utiliserons dans
une section ultérieure. Enfin, un raccourci peut
être attribué au bouton. Utilisons la touche Entrée
comme raccourci pour appuyer sur ce bouton. développant le raccourci en
cliquant dessus, nous pouvons voir qu'il
contient une liste d'événements, sur
laquelle nous devons également
cliquer pour développer. La liste est vide,
elle a donc une taille de zéro. Mais nous pouvons cliquer sur le bouton Plus Ajouter un
élément pour ajouter
un événement à cette liste. En cliquant sur le menu déroulant, nous utiliserons une touche
d'événement de saisie pour réagir lorsque le joueur appuie sur
une touche de son clavier. En cliquant sur la touche d'
événement d'entrée pour la développer, il y a beaucoup plus de
propriétés ici, mais il suffit d'appuyer sur le bouton de configuration pour ouvrir une fenêtre de configuration d'événement. Cette fenêtre
écoute activement les événements d'entrée Appuyez
donc sur n'importe quelle touche du clavier pour la sélectionner
automatiquement. Nous pouvons également ajouter l'obligation de maintenir enfoncées
d'autres touches telles
que Shift Alt, Control, Windows ou de détecter
automatiquement la touche de contrôle ou de commande en fonction du système
d'exploitation de l'utilisateur. En appuyant sur OK, vous remplirez les informations requises pour nous. Les commentaires relatifs aux raccourcis changeront si le
style du bouton change lorsque le raccourci est utilisé, et le raccourci et l'
infobulle
ajouteront automatiquement une infobulle au bouton
qui affiche le raccourci. En laissant les deux allumés,
voyons à quoi cela ressemble. En survolant le bouton, l'
infobulle indique
que la touche Entrée est une touche de
raccourci permettant d'appuyer sur ce bouton Lorsque vous appuyez sur la touche Entrée du clavier, vous appuyez
également sur le bouton. Si nous désactivons ces options, l'infobulle est supprimée
et, même si la touche Entrée
est toujours un raccourci, cela n'indique pas visuellement que le bouton
est enfoncé. Sélectionnez le nœud racine
et examinez
à nouveau les
options de texture de la boîte de style pour notre bouton. Je vais remplacer ma texture par l'icône Gadot pour
une démonstration Des marges de texture peuvent être ajoutées
pour créer une tranche de neuf tranches. Les textures à neuf tranches peuvent facilement être redimensionnées, les coins de l'image conservant
leur taille d'origine, étirant les bords le
long d'un seul axe et étirant l'intérieur le long deux axes pour occuper
l'espace supplémentaire façon dont ces étirements d'axes sont implémentés peut être modifiée dans
les paramètres d'étirement des axes, soit en étirant l'
image, en la carrelant,
soit en combinant tuilage et
étirement pour
tenter de supprimer les joints Les marges d'extension peuvent
être utilisées pour agrandir la
zone de style par rapport à sa surface normale, en l'
étendant dans
l'une des quatre directions. La sous-région est utilisée pour découper les feuilles de
sprites en textures
individuelles Cliquez sur le bouton
Modifier la région pour ouvrir une fenêtre d'éditeur de région. Cette fenêtre permet de cliquer et de faire glisser le pointeur pour
choisir la région, en ajustant les bords
et les coins selon les besoins. Il existe des options de
capture de pixels pour une plus grande précision Capture de grille Si
votre feuille de sprites est de taille et espacée de manière uniforme, vous pouvez spécifier la taille de la grille
et le décalage en fonction de
la feuille de Sélectionnez ensuite une ou plusieurs
cellules de la grille pour former votre texture. Ou Auto Slice
trouvera automatiquement les textures qui vous conviennent, et vous pouvez simplement en sélectionner
une en cliquant dessus. Modulate peut également multiplier la texture entière
par une autre couleur, ajustant à une couleur
différente Ceci est souvent utilisé pour ajouter de la teinte, ou si votre texture est
entièrement en niveaux de gris, la modulation peut être utilisée
comme source principale de couleur, créant ainsi une grande variété de boîtes de style
colorées
à partir d'une seule texture D'autres options sont
également disponibles pour créer des boîtes de style
dans l'éditeur de thème. Toutes les autres options de
zone de style ont également
les mêmes options de marge de contenu
que la texture de boîte de style. boîte de style vide ne dessine rien et n'a aucune propriété
unique Alors que la ligne Stylebox tracera une seule
ligne horizontale en haut du bouton En cliquant sur la ligne Stylebox, nous pouvons changer la couleur de la ligne Epaisseur. Mettez-la en position verticale et agrandissez la
ligne dans les deux sens. L'utilisation de valeurs négatives ici
réduira la ligne. Style box flat dessinera un
simple rectangle coloré. En cliquant sur la boîte de style à plat, nous pouvons changer sa couleur et l'
incliner dans les deux sens Si nous ajoutons une largeur de bordure, nous pouvons également modifier
la couleur de la bordure. Et mélangez la bordure à
l'arrière-plan du bouton. basculez vers le centre de dessin, l'arrière-plan sera supprimé pour ne
dessiner que la bordure Si nous ajoutons un rayon d'angle, le rectangle se courbera
comme par défaut. Et nous pouvons modifier le nombre d'
arêtes calculées pour créer les coins incurvés avec la propriété de détail des coins. Nous pouvons ajouter une ombre derrière
le bouton, changer sa couleur, taille et le décaler dans
les deux sens également. Et l'anticrénelage
peut être désactivé, ou nous pouvons modifier sa taille pour rendre les bords plus lisses Cela couvre toutes les propriétés
des boutons et les options de la boîte de style. Dans la leçon suivante, nous
ajouterons des liens vers les réseaux sociaux. Je te verrai dans la prochaine leçon.
20. Bouton de lien: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté un bouton Démarrer
à notre écran titre. Dans cette leçon, nous allons
ajouter des liens vers les réseaux sociaux. Commençons par ajouter une nouvelle
note à l'arbre des scènes. Cette fois, il s'agit d'un bouton Link. Nous donnerons à ce nœud
le nom de la plateforme de médias sociaux, dans mon cas, Patron. Ensuite, renseignez également le champ de
texte avec les
mêmes informations copiant et collant l'URI
souhaité dans le champ, rien de plus n'est nécessaire pour le bouton Link fasse
exactement ce que nous attendons En lançant le jeu, nous pouvons
cliquer sur ce bouton Lien pour ouvrir une fenêtre de navigateur à
l'URI que nous avons spécifié. L'
option de soulignement nous permet changer si le texte
est toujours souligné, uniquement lorsque la
souris passe dessus ou jamais Les mêmes options BD
sont disponibles pour les langages qui écrivent
de droite à gauche, et nous avons toutes
les mêmes propriétés héritées de la classe de
boutons de base si nous
voulons les utiliser. Cela fonctionne, mais ce n'est pas ce que je veux pour mes liens sur les réseaux sociaux. Je préférerais que l'icône de la
plateforme soit à côté
du texte et que les deux soient
cliquables en un seul bouton Pour ce faire, j'ai besoin d'
un nœud endommagé par une texture pour afficher l'icône Je vais renommer cette icône de nœud
et utiliser l'icône Gadot comme
espace réservé Je ne veux pas que l'icône
soit aussi grande Je vais
donc la configurer en
mode expansion pour ignorer taille et
en mode étirement pour conserver son aspect. Réduisez-le ensuite à une taille
plus raisonnable. Ensuite, au lieu d'utiliser le nœud du bouton Link
pour afficher le texte, j'utiliserai le nœud label. Je vais renommer ce pseudo de nœud et le mettre
dans le champ de texte Déplacez-le ensuite vers la
droite de l'icône. Je dois regrouper ces
deux nœuds, les
faire agir comme
un seul nœud. Nous pouvons le faire en utilisant
un autre nœud comme parent, comme le nœud du bouton Link. Groupe sélectionnant les deux nœuds, nous pouvons les faire glisser sur
le nœud du bouton Lien pour les relier
au bouton Lien Ils sont donc désormais les enfants
du nœud Link button. En déplaçant le nœud parent, les deux enfants
le suivent
tout en conservant leurs positions
relatives. Si nous élargissons la taille
du nœud du bouton Link pour
couvrir les deux enfants, toute
cette zone devient un bouton cliquable renvoyant à la plateforme du réseau
social Nous pouvons également ancrer
le nœud du bouton Link à n'importe quel endroit de l'écran, et il ajustera automatiquement les positions relatives
des nœuds enfants. Un moyen plus simple d'
être plus précis dans l'alignement horizontal
des commandes et de
les maintenir régulièrement
espacées consiste à utiliser un autre nœud de contrôle qui
répond exactement à cet objectif Ce nœud est appelé conteneur
horizontal. Il
organisera automatiquement tous ses enfants horizontalement avec un
espacement constant entre eux, en faisant de celui-ci l'enfant
du bouton de lien, puis de l'icône et de
la poignée
des enfants du conteneur horizontal Le mode de mise en page de l'icône et de la poignée est désormais défini sur conteneur. Comme ils se trouvent à
l'intérieur d'un conteneur, celui-ci est
chargé de déterminer leur
taille et leur position. Ces propriétés
sont donc désactivées. Les enfants sont également obligés réduire leur taille à la
plus petite taille autorisée, ce qui signifie que l'icône a été
réduite à néant Si nous changeons le mode d'expansion
pour l'adapter au mode proportionnel, ce mode d'expansion est
idéal pour les boîtes horizontales, en veillant à ce que la largeur de la
texture corresponde la hauteur autorisée par le conteneur
horizontal. Sélectionnons le
nœud racine pour voir l'éditeur de thème et ajouter le
conteneur de boîtes horizontales au thème. Ce type de nœud ne possède qu'
une seule propriété que nous pouvons définir dans la section constante, qui est le nombre
de pixels qui
seront utilisés pour séparer
les enfants des nœuds. N'hésitez pas à modifier cette valeur
et à voir ce qui vous convient. En sélectionnant le
conteneur horizontal, sa taille était initialement de 40 x
40 pixels par défaut et a été étendue pour couvrir
ses enfants horizontalement, mais sa hauteur reste de 40 pixels. Si nous cliquons sur le bouton de réinitialisation, le conteneur tentera de s'
effondrer autant que possible. Étant donné que la taille du texte du
nœud d'étiquette exige 31 pixels
d'espace vertical, le conteneur a
également une hauteur de 31 pixels. Cette hauteur est également
attribuée à l'icône, dont les paramètres définissent sa
largeur en fonction de sa hauteur. Puisque nous connaissons désormais la taille exacte dont
nous avons besoin pour cette
icône et cette poignée, nous pouvons copier ces chiffres dans la
propriété de taille minimale personnalisée du bouton de lien, afin de garantir qu'il
inclura toujours l'ensemble
de ses enfants Réinitialisez ensuite sa propriété
de taille pour le forcer à
se réduire à cette taille. Nous avons maintenant un bouton de lien vers
les réseaux sociaux qui inclut à la fois une
icône et une poignée, et vous pouvez cliquer sur l'intégralité des
deux Créons de nouveaux
dossiers de ressources, d'abord pour les icônes, puis un autre pour les icônes des réseaux
sociaux afin les
séparer des autres icônes de jeu. Importez ensuite des icônes de réseaux
sociaux avec ce dossier sélectionné. Nous pouvons ensuite remplacer l'icône Gdo par l'icône appropriée En sélectionnant le nœud du bouton de lien, nous pouvons le dupliquer à l'aide commande D ou de la commande D pour
ajouter d'autres liens vers les réseaux sociaux. Chaque doublon ajoutera
un numéro croissant au nom, car
les nœuds frères
ne peuvent pas porter le même nom Tous les nœuds enfants seront
également dupliqués mais conserveront leurs noms d'origine car ils ne
sont pas frères et sœurs avec
leurs doublons Nous voulons probablement que ces
liens soient disposés verticalement. Nous pouvons le faire avec un conteneur
vertical qui fonctionne exactement comme le conteneur
horizontal, mais qui dispose ses
enfants verticalement Ajoutons-le en tant qu'enfant de
l' écran titre et
renommons-le en réseaux sociaux Sélectionnez ensuite en groupe tous les nœuds
du bouton de lien et associez-les à ce conteneur de boîtes
verticales Le conteneur les
dispose automatiquement à la verticale pour nous. Je renommerai chaque bouton de lien en fonction de la plateforme de réseau
social appropriée Maintenant que nous pouvons voir
tous nos liens, changeons leurs
URI. Leurs icônes. Et leurs poignées, s'il le faut. Comme mes boutons encreurs ont
désormais des largeurs différentes, le conteneur vertical les
étendra tous à
la plus grande largeur, ce qui rendra plusieurs de
ces boutons de lien beaucoup plus longs qu'ils ne le devraient En sélectionnant
tous les liens,
nous pouvons modifier la
propriété de dimensionnement du
conteneur à partir de ce
menu contextuel de la fenêtre d'aperçu, en
modifiant le dimensionnement
horizontal du conteneur de remplissage
à un début de réduction. Ainsi, chaque bouton de lien
réduira sa largeur à la
taille minimale que nous avons définie précédemment. Ces propriétés de
dimensionnement des conteneurs se
trouvent également dans
la section de mise en page des propriétés
héritées du contrôle en développant la section de dimensionnement des
conteneurs Des
options horizontales et verticales sont disponibles, repliant vers le
début, le centre ou la fin du contenant ou le
remplissant entièrement
dans les deux sens Ancrons ces liens
de réseaux
sociaux dans un coin de l'écran
où ils sont beaux. Je vais mettre le mien dans le coin
inférieur gauche. Ce n'est pas une bonne idée
d'avoir ce type d'
icônes ou de texte en contact avec le
bord de la fenêtre de cette façon. Nous préférons généralement
avoir des marges. Nous pouvons facilement décaler
la position du nœud
du conteneur en modifiant ses préréglages d'ancrage pour les personnaliser, puis en ajustant les décalages d'
ancrage, en ajoutant une valeur positive le côté gauche pour l'
éloigner du bord gauche
de la fenêtre, et une valeur négative vers
le bas pour le déplacer vers le En sélectionnant le nœud racine pour
voir l'éditeur de thème, tout comme avec le conteneur de boîtes
horizontales, nous pouvons ajouter
des conteneurs de boîtes verticales au thème pour modifier le nombre de pixels utilisés pour séparer leurs enfants. J'aimerais que la plupart des conteneurs
verticaux de
mon projet aient la même séparation uniforme des
pixels que mes conteneurs horizontaux. Mais je vais utiliser un thème de
remplacement pour faire ce
conteneur vertical une exception et doubler
la séparation pour diffuser un peu plus ces liens Et nous pouvons facilement modifier l'ordre des liens en cliquant dessus et en faisant glisser pour les réorganiser
à fois
dans l'arborescence de la scène
et dans le conteneur Nous avons maintenant des
liens vers les réseaux sociaux sur notre écran titre. Dans la leçon suivante, nous ajouterons
une variante à notre thème. Je te verrai dans la prochaine leçon.
21. Variation du type de thème: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté
des liens vers les réseaux sociaux à notre écran titre. Dans cette leçon, nous allons ajouter
un type de variation de thème. Ajoutons une nouvelle étiquette à notre scène à des
fins de test uniquement. Un sans remplacement de thème
, contrairement au titre. Nous en utiliserons beaucoup
pour afficher toutes sortes de textes et de
chiffres à l'écran ultérieurement. Sélection du nœud racine pour que
nous puissions voir l'éditeur de thème. Nous pouvons ajouter un nouveau type à
notre thème, le nœud d'étiquette. Comme nous l'avons déjà fait, nous pouvons modifier les constantes de couleur. Police, taille de police et
style, si nous le voulons. Je vais simplement utiliser la
police par défaut et la taille de police par défaut que
j'ai déjà définies pour mon thème. Cela donne une
apparence cohérente à l' ensemble ou au moins à la majeure partie
du texte de notre jeu. Le titre étant unique, il utilise des remplacements de thème pour définir ses propres propriétés
thématiques spéciales Bien que j'apprécie la
police élégante du titre, du
texte et du bouton de démarrage de mon jeu , ces liens vers les réseaux sociaux doivent être très clairs
et faciles à lire, en particulier parce que mon nom
est très difficile en soi. J'ai donc importé une deuxième police à utiliser uniquement pour ces liens, Roboto, tandis que le
reste du texte de mon jeu doit rester
dans la police stylisée Nous pourrions sélectionner chaque étiquette de
poignée et utiliser la section de remplacement du thème pour modifier leur police, comme
nous l'avons fait pour le titre Mais que se passe-t-il si nous voulons le modifier ou ajouter
d'autres boutons de liens ? Nous devrons ensuite
modifier les remplacements de thème
de chacun des nœuds pour nous
assurer qu'ils correspondent tous Il serait préférable d'utiliser
notre thème pour les définir tous en même
temps tout en les
séparant des autres nœuds d'étiquette. Mais nous avons déjà ajouté le type d'
étiquette à notre thème. Ainsi, dans les cas où nous voulons
définir un thème pour certains nœuds, mais pas pour tous les nœuds
du même type, nous pouvons ajouter un type
de variation
au thème en tapant simplement
notre propre nom dans ce champ. Je vais l'appeler handle, puisque c'est pour cela que je vais
l'utiliser. Ce nouveau type n'a pas encore de
propriétés car l'éditeur de thème ne
sait pas quel est le type de base. Nous devons aller à
la dernière page et définir le type de base
pour cette variante. Et le type de base est le type
des nœuds que nous
voulons affecter, étiqueter. Nous pouvons soit taper le
nom dans ce champ soit cliquer sur le bouton plus pour sélectionner le
type de base dans une liste. Cela ajoutera à
cette variation de type
les mêmes propriétés que celles qui
seraient disponibles pour un nœud d'étiquette. Nous pouvons donc ajouter les mêmes couleurs, couleur de
police, couleur de contour,
couleur d'ombre, constantes telles que la
taille du contour et le décalage des ombres, police, que je vais
changer en roboto Et la taille de la police,
que j'aimerais être légèrement plus grande que
la valeur par défaut à 28. Aucune de ces modifications n'a
affecté nos étiquettes, le titre, le texte ou les poignées. En sélectionnant les nœuds de poignée, nous pouvons même les regrouper et
les sélectionner tous ensemble. Développez ensuite la section thématique. Ensuite, cliquez sur le bouton
Modifier à côté du champ de variation et saisissez le nom de notre variante de type de
thème. , tous
ces nœuds d' étiquettes
utiliseront désormais la variante du type de thème, afin que nous puissions ajuster
collectivement
leurs paramètres uniques tout en les séparant des autres
étiquettes du projet. La modification de la police et de
la taille de police peut également entraîner une de
la taille des cases horizontales modification de
la taille des cases horizontales pour
s'adapter au texte. Je vais donc rapidement ajuster les tailles minimales personnalisées de
mes boutons encreurs en conséquence. Je vais maintenant supprimer
ce nœud d'étiquette supplémentaire car il n'est pas nécessaire
pour l'écran titre. Nous avons maintenant des liens vers les réseaux sociaux
qui sont plus faciles à lire. Dans la leçon suivante, nous allons ajouter un arrière-plan
pour le jeu principal. Je te verrai dans la prochaine leçon.
22. Panneau: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté une
variante du type de thème pour donner à certains nœuds un thème cohérent qui
diffère de celui des autres
nœuds du même type. Dans cette leçon, nous allons ajouter un arrière-plan de base
pour notre jeu principal. Normalement, les jeux
proposent une scène différente pour l'écran titre
et le jeu principal, mais dans ce projet, nous
faisons tout dans une seule scène. Par défaut, l'
arrière-plan est simplement gris. Si vous souhaitez utiliser une
image pour votre arrière-plan, vous devez utiliser un nœud texture
rec pour la dessiner. Je ne veux pas
une simple image, alors commençons par ajouter
un nouveau nœud à notre scène. Cette fois, un nœud de panneau
et renommez-le jeu. Les panneaux ne font rien d'autre qu'un nœud de
contrôle standard, sauf qu'ils
dessinent également une boîte de style. Réglons ses ancrages pour qu'
ils recouvrent toute
la fenêtre La boîte de style par défaut d' un panneau est identique à celle d'un bouton, juste un rectangle
noir semi-transparent aux coins
arrondis. Avant d'importer l'
image pour mon panneau, je vais créer un nouveau dossier de
ressources pour les styles et un autre
à l'intérieur de celui-ci pour les boutons. Déplacez ensuite tous mes
styles de boutons dans ce dossier. Ensuite, un autre dossier pour les panneaux, et je sélectionnerai ce
dossier lors de l'importation des textures de style de
panneau. En sélectionnant le nœud racine pour
voir l'éditeur de thème, ajoutons un panneau au thème. Les panneaux n'ont qu'une seule
propriété de thème, leur boîte de style. Les mêmes options sont disponibles pour le panneau que pour les boutons :
vide, ligne, plat ou texture. Utilisons une texture de boîte de style, puis cliquons dessus pour l'ouvrir dans l'inspecteur et assignons la texture une
texture importée. Avec les paramètres par défaut, la texture est étirée pour
s'adapter à la taille du panneau, ce qui n'est pas très esthétique. Si la propriété d'
étirement de l'axe est remplacée par une mosaïque, l'image sera carrelée au lieu d'être étirée pour remplir
l'espace alloué L'ajustement des carreaux permet à la fois de
carreler et d'étirer telle sorte que
toute la région soit recouverte de carreaux entiers
plutôt que de fractions Cette image est un peu trop chargée, elle peut être trop distrayante Je vais
donc utiliser l'image de
bordure en corde à la Si nous ajoutons des marges de texture, l'image sera découpée en neuf textures différentes
qui seront utilisées pour créer la boîte de style les coins conservant leurs dimensions
exactes en pixels, les bords étant étirés
ou carrelés pour relier les coins et
le centre étant étiré ou carrelé pour
remplir la zone restante Maintenant que nous avons un
arrière-plan de base pour notre fenêtre de jeu, nous devons le
masquer par défaut lorsque le jeu démarre pour la première fois afin que nous
puissions voir l'écran titre, ce que nous pouvons faire en cliquant sur l'icône en forme d'œil à côté
dans l'arbre des scènes. Mais comme nous
passerons le plus clair de notre temps développer le jeu à modifier
le contenu de ce panneau, il serait préférable que
celui-ci soit visible pour nous et que l'écran titre
soit masqué à la place. Nous voulons donc remplacer le nœud de jeu
par le nœud de l'écran titre, pour faire du nœud de jeu
le nœud racine des scènes. En cliquant avec le bouton droit sur le nœud de jeu, sélectionnez l'option
make scene root. Le nœud de jeu est
désormais le nœud racine dont l'écran
titre est un enfant. L'écran titre est donc
initialement dessiné au-dessus du jeu. Pour passer de l'
écran titre au jeu principal, il
suffit de masquer l'écran titre en
désactivant sa visibilité. Cependant, maintenant que le thème du panneau
n'est plus appliqué
au nœud du panneau,
étant donné que le thème est une propriété
de l'écran titre, je n'affecterai que l'
écran titre et ses enfants. fois l'écran titre sélectionné, en élargissant la section du thème, nous pouvons cliquer sur la flèche à côté du thème et l'enregistrer
en tant que ressource du projet. Je vais simplement le laisser dans le dossier de ressources du
projet
et le nommer d'après la police. L'échange gagne. Ce thème est désormais enregistré dans le dossier de ressources de notre
projet. Nous pouvons donc sélectionner le nœud du jeu, développer la section du thème et utiliser le menu déroulant
pour charger ce thème. Maintenant, le thème est appliqué à l'ensemble du
projet comme auparavant, puisqu'il s'agit d'une propriété
du nœud racine. Nous pouvons également le supprimer du nœud de
l'écran titre puisqu'il est de toute façon hérité par le
biais de l'arbre des scènes. Ensuite, nous devons joindre
un script au nœud de jeu,
soit en le sélectionnant
et en cliquant sur le bouton du script joint, soit en cliquant avec le bouton droit sur le nœud et
en sélectionnant le script attaché. Nous allons donner à ce script
le nom de gestionnaire de jeu et créer un nouveau dossier
contenant tous les scripts de nos projets. Créez ensuite le script
dans ce dossier. Le script sera écrit en script
GD et
héritera du panneau, le type du nœud auquel il
est attaché Cela fait automatiquement
passer notre vue en mode
script et ouvre le
script que nous venons de créer. Ce script doit uniquement activer ou désactiver
la visibilité de l'écran
titre. Pour ce faire, nous avons besoin d' une référence au nœud de l'écran
titre. En cliquant avec le bouton droit sur le nœud de l'écran
titre, nous pouvons y accéder sous forme de nom unique
tant qu'aucun autre nœud l'arbre de scène ne porte
le même nom, qui sera indiqué
par un signe de pourcentage. Ensuite, en cliquant sur
ce nœud et en le faisant glisser dans le script, maintenant la touche
Ctrl ou Commande enfoncée tout en relâchant la souris, nous stockerons une référence
à ce nœud dans une variable Je vais commencer le
nom de la variable par un trait de soulignement pour la
marquer comme privée, ce qui signifie qu'elle est uniquement destinée
à être utilisée par ce script Annulation de la fonction Ready. L'icône représentant une flèche bleue à côté la fonction indique
que cette fonction remplace la définition
fournie dans la classe de nœuds Cette fonction est appelée lorsque le nœud et tous ses
enfants sont prêts, nous pouvons indiquer à l'
écran titre de s'afficher. En sélectionnant le bouton de démarrage, nous pouvons faire passer le
panneau d'inspection au panneau des nœuds, qui nous donne une liste de tous les signaux que
ce nœud peut émettre. Le signal auquel nous voulons
réagir est le signal pressé, qui sera émis lorsque vous appuierez sur
le bouton. Double-cliquez sur le signal ou cliquez avec le bouton
droit de la souris et
sélectionnez Connecter. Nous pouvons le connecter
au nœud de jeu, qui
générera automatiquement une nouvelle fonction pour nous sur Start Pressed. L'
icône de connexion verte à gauche de cette fonction nous indique qu' une connexion par signal
appellera cette fonction. Lorsque le
bouton de démarrage est enfoncé, nous indiquons à l'écran
titre de se masquer. cours de jeu, l'écran
titre s'affiche, et lorsque nous cliquons sur
le bouton Démarrer, il se masque, révélant le panneau de
jeu situé en dessous. Nous avons maintenant un arrière-plan
pour notre fenêtre de jeu. Dans la leçon suivante, nous allons
ajouter une transition de fondu. Je te verrai dans la prochaine leçon.
23. Couleur droite: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté un arrière-plan pour
notre fenêtre de jeu principale. Dans cette leçon, nous allons
ajouter une transition en fondu pour passer de l'
écran titre au jeu principal. Actuellement, l'écran titre
s'affiche immédiatement, et appuyer sur le bouton de démarrage permet
d'accéder au panneau de jeu, ce qui est un peu choquant Il serait préférable que nous fassions la
transition progressivement, ce que nous pouvons faire facilement
avec un autre nœud La couleur a détruit le nœud. Renommons-le Fade. Le nœud endommagé par la couleur
remplit simplement ses limites
d'une couleur unie, que nous pouvons modifier
dans l'inspecteur Nous allons
donc le mettre en noir Posez ensuite ses ancrages à
fond pour qu'il couvre toute
la fenêtre C'est ainsi que la plupart
des jeux commencent, se
terminent et changent de scène avec juste
un écran noir vide. Nous pouvons ajuster la transparence appelée Alpha de
cette couleur pour la rendre invisible progressivement au fil du temps et revenir au noir uni chaque
fois que nous en avons besoin. Cachons-le pour que nous puissions voir notre jeu pendant que nous y
travaillons. En attachant un script à ce nœud, en l'
enregistrant dans
le dossier des scripts, le but du script
sera de s'estomper. Chaque fois que nous ajustons
une valeur au fil du temps, nous pouvons utiliser une classe intégrée
de Gadot, un tween, que nous
stockerons dans une variable En ajoutant une fonction,
disons que c'est trop clair. La fonction peut renvoyer un signal qui sera émis une
fois terminée. La première chose à
faire est de créer un nouveau préadolescent. Assignez ensuite ce
tween créé à notre variable. Il s'agit d'une fonction
de la classe node. N'importe quel nœud peut créer une interpolation. Demandez ensuite au préadolescent de procéder
à l'interpolation d'une propriété. Cette fonction comporte quatre
paramètres. Quel nœud ? Nous pouvons utiliser le mot clé
self pour indiquer à ce nœud que le script est attaché au nœud
fade, quelle propriété ? Sous forme de chaîne
encapsulée entre guillemets, nous indiquons le nom de la
propriété, qui est la couleur La valeur finale de la propriété, qui est la couleur claire. Écrivons cela
en majuscules pour le moment. Et enfin, la
durée. Disons 1 seconde, par exemple. Nous pouvons ensuite renvoyer le signal
final de l'interpolation, qui émettra le signal automatiquement une fois terminé Clear n'est pas défini,
alors donnons-lui une définition en le déclarant en
haut du
script en tant que constante Une constante est le
contraire d'une variable. Bien qu'ils
stockent tous deux des informations, une constante ne change jamais. Ils sont classiquement
nommés en majuscules du serpent, et nous pouvons leur attribuer
la valeur d'une couleur Spécifiez ensuite entre parenthèses
zéro rouge, zéro vert, zéro bleu et zéro Alpha, qui est noir, mais
également totalement transparent. Passage au script du gestionnaire de
jeu. Donnons un nom unique au
fade et ajoutons-le au
gestionnaire de jeu en tant que variable. On peut lui dire de se
montrer en premier. Ensuite, une fois que
l'écran titre est affiché, nous pouvons passer au clair pour révéler
progressivement le
titre qui se trouve derrière le fondu. Lorsque vous
appuyez sur le bouton de démarrage, nous pouvons d'abord passer au noir avant de masquer l'écran titre, puis revenir au clair. Mais pour masquer l'écran
titre,
il faut attendre que le fondu
passe au noir pour terminer. Puisque nous renvoyons un
signal à partir de cette fonction, nous pouvons utiliser la commande await pour suspendre cette fonction jusqu'à ce que
le signal soit reçu. Nous devons donc également réécrire la fonction two
black dans notre script de fondu. Cette fonction fera
exactement la même chose que
l'autre fonction, mais uniquement en modifiant
la valeur finale laquelle la propriété de couleur
est interpolée Au lieu de dupliquer
tout le code, il serait préférable d'en
faire une fonction privée, plutôt que de demander aux deux fonctions
publiques de l'appeler Nous allons la nommer
couleur d'interpolation et remplacer l'argument de valeur finale de
la
fonction de propriété d'interpolation par couleur finale Ajoutez ensuite la couleur finale en
tant que paramètre de la déclaration de
fonction. Trop clair et
trop noir peuvent désormais renvoyer la
valeur de retour de la couleur d'interpolation, en passant clair comme argument ou point de
couleur noir puisque noir est déjà défini
pour nous dans la classe de couleurs Si nous appelions la fonction
deux effacer,
puis la fonction deux noirs, alors que le préadolescent est
actuellement occupé, cela peut provoquer un comportement
indésirable Donc, chaque fois que cela est possible, nous devons d'abord vérifier
si le tween a déjà été créé
et s'il est en cours d'exécution Si les deux sont vraies, alors nous pouvons tuer le préadolescent
avant d'en créer un nouveau, éviter tout
conflit, si deux
préadolescents essayent de
modifier la même propriété Si nous ne sommes pas sûrs
de vouloir utiliser 1 seconde comme durée, nous pouvons également en
faire une variable. Nommons-le durée et
définissons sa valeur sur 1 seconde. Ajoutez ensuite la balise export au
début de la déclaration pour nous permettre de donner une
valeur différente à
cette variable dans l'inspecteur. En sélectionnant le nœud de fondu
dans l'arbre de la scène, nous pouvons voir que la
variable de durée a une valeur de un, mais nous pouvons la
modifier comme bon nous semble. Je vais essayer pendant 2 secondes et
voir à quoi ça ressemble. Au cours du jeu, la fenêtre devient complètement noire
mais s'estompe pour s'effacer, révélant l'
écran titre qui se trouve derrière elle Nous ne pouvons actuellement pas cliquer
sur le bouton Démarrer car nous cliquons en fait
sur le rectangle de couleur fondu, même s'il est transparent. Le bouton ne répond pas non plus
lorsque vous le survolez. En sélectionnant le nœud de fondu, nous devons examiner
les propriétés héritées du contrôle de
la section souris et
modifier sa
propriété de filtre pour la section souris et qu'elle soit ignorée. Les signaux de la souris vont maintenant
passer par le nœud de fondu vers
les nœuds situés en dessous. Essayons donc de
relancer le jeu. Si nous appuyons sur le
bouton de démarrage, il passe au noir, masque l'écran titre et s'estompe pour effacer une fois de plus, révélant ainsi le panneau de jeu Nous avons maintenant une
transition en fondu pour notre jeu. Dans la section suivante, nous allons commencer à travailler sur
le jeu lui-même. Je vous verrai dans
la section suivante.
24. Barre de menu: Bonjour, mes amis. Dans
la section précédente, nous avons créé un écran-titre pour notre jeu qui permet
de passer au jeu principal. Dans cette section, nous allons commencer à travailler sur le développement
du jeu lui-même. Commençons par ajouter un nouveau
nœud au panneau de jeu, un nœud de barre de menu. Et triez-le derrière
l'écran titre. Le nœud de la barre de menu ne
dessine rien par lui-même. Donc, si vous voulez une
représentation visuelle de la barre de menu, vous devez placer ce nœud dans un autre panneau
ou une autre copie de texture. Utilisez ensuite la
zone de texture ou de style pour dessiner une barre réelle. Je vais bien sans
dessiner de barre réelle, je vais
donc supprimer ce nœud supplémentaire. Le fonctionnement réel
de la barre de menu peut être un peu confus. Si nous avons besoin de plus d'informations
sur le fonctionnement d'un nœud, nous pouvons toujours consulter
sa documentation en cliquant dessus avec
le bouton droit de la souris et
en sélectionnant la documentation ouverte. Nous allons changer de mode description et ouvrir la documentation
de ce nœud Nous pouvons lire dans la description que ce nœud créera des boutons de
menu pour chaque nœud de
menu contextuel ajouté en tant qu'enfant. Pour revenir à la vue en deux D, ajoutons un nœud enfant à la barre de menu de
type menu contextuel. Il ne s'agit pas à proprement parler
d'un nœud de contrôle, mais il est suffisamment proche. En ajoutant simplement le nœud de menu
contextuel en tant qu'enfant de la barre de menu, celle-ci ajoute automatiquement un bouton de menu portant le
même nom que le nœud. Renommons ce
nœud en quelque chose de plus courant sur une barre de
menu, comme un fichier J'en ajouterai également un autre pour
les paramètres et un autre nommé. Vous devrez peut-être apporter d'
autres modifications avant que la barre de menu ne soit mise à jour. Les boutons du menu se chevauchent avec la bordure du panneau de jeu, ce qui n'est pas très beau Il serait préférable de l' éloigner du
bord de la fenêtre. Nous pourrions le déplacer manuellement en utilisant soit sa position
de transformation, soit ses ancres et ses décalages d'ancrage Mais je ne voudrais pas qu'aucun élément de mon jeu
touche la bordure Il serait
donc préférable d'appliquer des
marges sur tout le pourtour qui s'
appliqueront à tout. Le nœud du panneau
n'est pas un conteneur, il ne peut
donc pas contrôler
la position ou la taille de ses enfants. L'ajout de marges de contenu à sa boîte de
style sera ignoré. Ajoutons donc un conteneur
au panneau de jeu, particulier un conteneur qui ajoutera des marges, le conteneur de marges. Ensuite, faites en sorte que l'enfant
direct
du panneau de jeu avec la
barre de menu soit un enfant du conteneur de
marge. Sélection du nœud racine pour que
nous puissions voir l'éditeur de thème. Ajoutons un
conteneur de marge au thème. Le conteneur de marge
ne dessine rien. Il ne contient que des constantes dans les propriétés de
son thème. Combien de pixels d'
espace de marge sont ajoutés de chaque côté ? Étant donné que l'écran titre est similaire au conteneur de
marges, non un enfant, il ne sera pas
affecté par les Ajoutons également une
barre de menu au thème. La barre de menu nous permet de
changer la couleur de police de tous les boutons de menu
qu'elle crée dans les différents
états des boutons que nous avons vus auparavant. Dans la section des constantes, nous avons la
séparation en pixels entre les boutons de
menu et la taille du contour de la
police. Nous pouvons modifier la
police et la taille de police, mais je vais utiliser mes thèmes, les paramètres
par défaut pour ceux-ci. n'y a pas d'icônes,
et nous pouvons modifier les boîtes de style pour
les boutons de menu créés par la barre de menu dans
le même état des boutons. Pour mes boutons de menu, j'utiliserai une boîte de style vide comme d'habitude et je
la copierai dans Disabled et une boîte de style à plat pour appuyer et la copier en
survolant et en survolant. En ouvrant la zone de style vide, je vais simplement ajouter des marges de
contenu pour que la taille
du bouton soit un peu
plus grande que celle du texte. Et pour le style box flat, je vais ajouter les mêmes marges de
contenu, quelques coins arrondis
et assombrir la couleur Rendez ensuite la case de style survol unique afin qu'elle ne soit pas
liée aux autres, puis ouvrez-la et
changez-la en une couleur plus claire Voyons à quoi cela ressemble
lorsque nous lançons le jeu. Les menus se
trouvent tous dans la barre de menu. Ils ont une boîte de style
plat incurvée couleur plus claire lorsque vous survolez le pointeur
et plus foncée lorsque vous appuyez dessus Cependant, leurs menus contextuels sont
actuellement vides. Il existe quelques
options que nous pouvons utiliser dans l'inspecteur pour modifier
le comportement des boutons de menu. Le bouton plat ignore les cases de
style des boutons de menu et dessine simplement leur texte désactivation de l'interrupteur lors du survol
obligera le joueur à cliquer sur les boutons du menu pour
passer de l'un à l'autre
au lieu de simplement survoler Et le menu global préféré permettra à cette
barre de menu d'être dessinée par les systèmes d'exploitation Mac en tant que menu global en dehors de
la fenêtre de jeu. Donc, si vous ne voulez pas
que cela se produise, vous pouvez le désactiver ici Mais si vous utilisez
le menu global, vous pouvez indiquer à quel endroit du
menu global vous souhaitez commencer à ajouter vos menus contextuels personnalisés ,
l'indice de départ négatif étant
dans ce cas
utilisé pour signifier automatique. Et, bien entendu, les
options BD sont également disponibles pour les langues qui
écrivent de droite à gauche. Nous avons maintenant une barre de menu
avec plusieurs menus vides. Dans la leçon suivante,
nous allons remplir
les menus contextuels avec
plusieurs options Je te verrai dans la prochaine leçon.
25. Menu contextuel: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté une barre de menu à notre jeu. Dans cette leçon, nous allons ajouter des
options pour les menus contextuels. En sélectionnant le nœud du menu
contextuel et en examinant les
propriétés de l'inspecteur, trouverez en bas une
section extensible nommée items Ici, nous pouvons ajouter chacune
des options qui seront disponibles dans
ce menu contextuel, comme Nouveau jeu, enregistrer,
charger et quitter. Ces articles peuvent être
réorganisés en cliquant sur les flèches ou en faisant glisser l'icône
du hamburger Je vais créer un nouveau dossier de ressources pour les icônes de
menu et importer
certaines icônes de menu. Attribuez ensuite à chaque
élément de menu sa propre icône. Pour les paramètres, je vais ajouter un autre élément et faire en sorte que
celui-ci soit coché sous forme de case à cocher Cela serait approprié
pour quelque chose qui peut être activé ou désactivé, comme le mode muet, par exemple Ensuite, j'ajouterai un autre menu
contextuel en tant qu'enfant de ce menu contextuel
pour créer un sous-menu, que je nommerai difficulté. Les éléments de ce menu contextuel
seront mes paramètres de difficulté,
chacun pouvant être coché sous
forme de bouton radio, ce qui signifie qu'un seul peut
être sélectionné à la fois La case Easy sera cochée par défaut. Facile, normal et difficile. Dans le menu d'aide, je vais ajouter un élément à propos
avec une autre icône. Puis un autre élément
qui dit « support ». En cliquant sur le bouton de
séparation, cette option de menu ne
sera pas un bouton cliquable, mais un séparateur entre des groupes
connexes d'éléments de menu, son nom étant écrit dans ce
séparateur sous forme d'étiquette J'ajouterai ensuite un autre élément sous le séparateur, qui
sera un lien vers mon Patron avec l'icône du réseau
social Sélection du nœud racine pour que
nous puissions voir l'éditeur de thème. Ajoutons un
menu contextuel au thème. La couleur de l'accélérateur de police est
utilisée pour afficher les raccourcis, mais nous n'avons pas la possibilité les
ajouter dans l'inspecteur. Nos menus contextuels
ne contiennent pas non plus de titre, mais les autres
options de couleur de police devraient vous être familières, ainsi que les
paramètres de couleur de police supplémentaires pour les séparateurs Dans la section réservée aux constantes, nos menus contextuels ne
comportent pas de bouton de fermeture, mais la
séparation horizontale peut être utilisée pour ajouter de l'espace entre l'icône
et le texte de chaque élément. La largeur maximale des icônes
sera utile pour limiter la taille des icônes en fonction la
hauteur de police du texte. n'y aura aucune indentation
dans ces menus contextuels, mais le rembourrage peut ajouter des pixels supplémentaires début et
à la
fin de chaque élément, ce qui donne un
peu plus La taille du contour de la police que nous connaissons
bien maintenant
, peut également être appliquée
au texte et aux séparateurs Ces menus contextuels ne peuvent pas être redimensionnés et ne comportent pas de titre Mais la
séparation verticale permet d'ajuster le nombre de pixels
séparant chaque option de menu. Il existe des propriétés relatives à
la police et à
la taille de police des options de menu, du
titre et des séparateurs Je vais simplement laisser tout cela
et utiliser les paramètres par défaut du thème. La page des icônes peut être utilisée pour modifier les icônes
utilisées pour les cases à cocher, boutons de
fermeture,
les boutons radio et les sous-menus J'ai importé de nouvelles
icônes à utiliser pour celles-ci, je vais
donc
les remplacer toutes. Ces images mesurent 16 pixels
carrés et ne seront pas redimensionnées. Assurez-vous donc d'utiliser une
image relativement petite pour ces icônes. Même si nos menus
contextuels ne
comportent pas de bouton de fermeture,
je vais ajouter ces deux boutons. Dans la page des styles, nous pouvons ajouter une boîte de style pour le panneau des menus
contextuels. J'utiliserai une
texture de boîte de style dessinée avec l'image de la plaque d'acier et je lui donnerai des marges
de texture pour empêcher les vis
de s'étirer. La zone de style de survol est dessinée lorsque l'
option de menu est survolée. Je vais utiliser une boîte de style plate et lui donner le même aspect
que les boutons du menu. Comme mon séparateur contient du texte, je peux utiliser les
cases de style Séparateur étiqueté à
gauche et
Séparateur étiqueté à droite pour modifier
la façon dont le séparateur est dessiné à gauche et à droite
du texte de mon séparateur. Si le séparateur
ne contient aucun texte, la zone de style du séparateur
sera utilisée pour le dessiner. Les bordures intégrées ne seront pas
utilisées par nos menus contextuels. Voyons à quoi ressemblent ces
menus contextuels lorsque nous lançons le jeu. En cliquant sur l'un de
nos boutons de menu, le menu contextuel s'
affiche avec le panneau. Vous pouvez
survoler chaque élément et cliquer dessus, mais aucune des options ne fait encore
quoi que ce soit et le
sous-menu de difficulté n'est pas là Cela ne se fait pas automatiquement. Nous devons l'ajouter
par le biais d'un script. Ajoutons donc un script à
notre menu contextuel des paramètres. Enregistré dans le dossier des scripts, en héritant du menu contextuel. En saisissant une référence
au sous-menu de difficulté, il suffit que
lorsque ce nœud soit prêt, et que ses
enfants soient également prêts, nous pouvons appeler une fonction de
la classe du menu contextuel Ajoutez un élément de nœud de sous-menu, qui nécessite une étiquette, un nœud de menu contextuel et éventuellement le numéro
d'index de l'endroit où le sous-menu
sera inséré. Nous pouvons simplement utiliser le nom du
nœud pour l'étiquette et le nœud lui-même. En ignorant l'index, le sous-menu sera
ajouté à la fin. Ajoutons un autre
script au menu déroulant du fichier afin d'
ajouter des raccourcis. Il suffit d'
exporter des variables
de type raccourci pour pouvoir les
définir dans l'inspecteur. Ensuite, lorsque le nœud est prêt, nous pouvons vérifier si
ces raccourcis ont une valeur avant de les définir comme raccourcis vers
les numéros
d'index de chaque élément de
ce menu contextuel. Nous pouvons remplir chacun
de ces raccourcis dans l'inspecteur avec des
raccourcis classiques auxquels nous nous attendons Contrôle ou commande N
pour le nouveau S pour la sauvegarde, L pour le chargement et E pour la sortie. Ensuite, nous devrions
retourner dans l'éditeur de thème et ajouter une couleur de police pour
nos nouveaux raccourcis. Maintenant, lorsque nous lançons le jeu, notre menu fichier contient des raccourcis et notre menu des paramètres comporte un
sous-menu avec des boutons radio. Mais l'icône du sous-menu est
cachée derrière le texte des éléments. Malheureusement, compte tenu de la disposition de
ces éléments, l'icône du sous-menu ne sera visible que si l'élément
n'est pas le plus long. Pour y remédier, nous pouvons écrire du code pour
modifier manuellement la largeur
du panneau ou renommer certains de nos autres éléments pour qu'ils soient
plus longs que l'élément du sous-menu Je vais devoir ajouter une séparation
horizontale
et un rembourrage supplémentaires pour tenir compte de
ma grande taille de police Jetons un coup d'œil aux
propriétés du sous-menu. Les trois premières options
détermineront si le menu contextuel se masque après avoir
cliqué sur une option. Si nous décochons l'option Masquer
les éléments
à cocher , le menu contextuel ne se
masquera pas lorsque cliquez sur une case à cocher ou que vous
modifiez les Cela peut être utile
pour les menus contextuels
des paramètres et des difficultés. Un élément d'état est similaire
à une case à cocher, mais il peut comporter plus de deux états et doit être créé
par le biais d'un script Le délai d'affichage du sous-menu
correspond au temps dont la souris a besoin pour survoler le sous-menu avant que la fenêtre contextuelle n'apparaisse Autoriser la recherche permet de rechercher
chaque option du menu contextuel à l'aide du clavier pendant que le menu
contextuel est affiché Les autres options
permettent d'intégrer ce menu contextuel aux différents menus du système
d'exploitation. En relançant le jeu,
tout est plus espacé et nous pouvons utiliser les entrées
du clavier pour rechercher dans le
menu contextuel qui se concentre Nous avons maintenant des menus contextuels pour
chacun de nos boutons de menu. Dans la leçon suivante, nous allons écrire des scripts pour nos options de menu. Je te verrai dans la prochaine leçon.
26. Signaux: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté des options de menu
à notre barre de menu. Dans cette leçon, nous allons
écrire des scripts qui réagiront au pressage de chacun d'
eux. En commençant par le menu contextuel des
fichiers, passez du
panneau d'inspection au panneau des nœuds où nous pouvons voir tous les
signaux que ce nœud peut émettre. Peut réagir au signal d'identification
pressé en le
connectant au script du menu contextuel du
fichier. Notre script réagira
donc lorsque le joueur sélectionnera des éléments du menu ou appuiera
sur les touches de raccourci. Contrairement au bouton, ce
signal nous passe en argument. La fonction générée possède donc un paramètre correspondant
du même type,
le numéro d'identification de l'
élément sur lequel vous avez appuyé. De retour dans l'onglet Inspecteur, nous pouvons voir les numéros d'identification de chaque article si nous avons besoin de les
connaître ou de les modifier. Dans cette fonction, nous pouvons utiliser une instruction match pour exécuter code
différent en fonction
de l'élément pressé. Et organisez les choses en appelant simplement une
fonction différente pour chacune d'entre elles. Imprimons simplement des instructions indiquant quelle
fonction a été appelée pour le moment. Après avoir démarré un nouveau jeu, nous devrons réinitialiser un grand nombre de
nos nœuds de contrôle
à leur état par défaut, ce qui serait un peu choquant
si cela se produisait Prenons donc une référence
au nœud de fondu. Ensuite, nous pouvons attendre de passer
au noir avant de créer les nouvelles données de sauvegarde et
de revenir à l'état clair après. Il est impossible de
prévoir le nombre d'
éléments nécessaires pour réagir aux
nouvelles données de sauvegarde créées. Au lieu de tous
les réinitialiser ici, il serait préférable
d'émettre un signal Nous pouvons déclarer nos propres
signaux comme des variables. Appelons-le reset. Puis émettez-le après avoir
créé les nouvelles données de sauvegarde. N'importe quel nœud de l'arborescence des scènes peut
se connecter à ce signal et revenir à son état par défaut lorsque le joueur
souhaite commencer une nouvelle partie. Comme ce processus ne
se produit pas instantanément, nous souhaiterons peut-être limiter le
moment où il peut être appelé. Si, par exemple, le
joueur commence à appuyer sur Nouveau jeu et à charger le jeu
en succession rapide, cela provoquera un comportement
indésirable. Déclarons une autre
variable indiquant si ce script est
occupé ou non en tant que booléen Ensuite, lorsque vous appuyez sur un identifiant, si ce script est occupé, il ignorera l'entrée. Si vous réglez occupé sur true
avant de passer au noir, puis sur false après la
décoloration pour effacer, aucune de ces fonctions ne
pourra interférer entre elles
après l'appel de l'une d'elles Le chargement du jeu
sera essentiellement le même que le démarrage
d'un nouveau jeu pour le moment. quitter le jeu, il
suffit de passer de occupé à vrai, de passer au noir, puis de dire à
l'arbre des scènes de quitter Cela fermera l'application sur n'importe quelle plateforme, à l'exception du Web. Les jeux en ligne ont tendance à ne pas avoir
la possibilité de se fermer du tout. Ensuite, examinons
le menu des paramètres et connectons son
signal ID pressé au script. Pour l'instant, je vais simplement
déclarer une variable
contenant la valeur actuelle
de mute sous forme de booléen,
qui sera naturellement définie
par défaut sur false et une qui sera naturellement définie
par défaut sur false et dont la autre pour la difficulté sous la forme d'
un entier Ce menu contextuel ne comporte qu'
un seul élément, le bouton muet. Je vais donc simplement confirmer
que l'idée est nulle, puis appeler une fonction
pour définir la valeur de mute à l'opposé
de ce qu'elle est actuellement donnant
une définition à cette fonction, acceptant la valeur
de mute sous forme de booléen, nous devons définir la case
à cocher En passant le pointeur de la souris
sur n'importe quelle propriété l'inspecteur à laquelle nous souhaitons
accéder par le biais d'un script, nous pouvons voir le chemin de la propriété, l'
élément zéro, la barre oblique En cliquant avec le bouton droit de la souris, nous pouvons également copier ce chemin dans
le presse-papiers Ensuite, en appelant la fonction set, qui accepte le
chemin de la propriété comme premier argument, nous pouvons le
coller entre guillemets. Suivi de la valeur, nous voulons le mettre en mode muet. Cela cochera la case, mais ne désactivera
rien. passant le
panneau inférieur à l'audio, nous pouvons voir l'éditeur de bus
audio de Godo, qui ne possède qu'un seul
bus par défaut, le bus Master Audio, dont l'indice de bus est nul La plupart des projets de jeu auront un bus pour la musique, les effets sonores
et les voix off, de sorte que chacun peut être géré en tant que groupe
distinct Dans notre script,
nous pouvons accéder à ce bus principal à partir d'un serveur audio Singleton intégré Accédez ensuite à la fonction set
bus mute en passant l'index du bus, qui est zéro, et la valeur
de mute comme arguments Nous aborderons les cours de Singleton plus
en détail dans
la prochaine leçon En connectant le signal ID pressé du sous-menu
au même script, nous pouvons définir la
valeur de difficulté
pour qu'elle corresponde à l'ID
qui a été pressé. Comme ils sont classés par
ordre croissant, cela a du sens. Nous devons ensuite définir la
propriété cochée de tous les éléments, car les boutons radio ne doivent jamais permettre d'en vérifier plusieurs à
la fois. À l'aide d'une boucle à quatre boucles,
nous pouvons parcourir chaque élément du nombre d'éléments de
difficulté Cela comptera donc
zéro, un, deux. Nous pouvons ensuite utiliser la même fonction de
réglage qu'auparavant, cette fois dans le menu contextuel de
difficulté, définissant la propriété
cochée à zéro pour
indiquer si
la valeur de l'élément est égale ou non à l'identifiant qui a été pressé. Mais nous ne voulons pas
uniquement mettre l'élément zéro. Nous remplaçons donc zéro
par un pourcentage S. Cela marque une position dans la chaîne qui sera
remplacée par une valeur. Après la chaîne d'
un autre signe de pourcentage, la valeur à remplacer par celui-ci indiquera
l'élément zéro coché, l'élément un coché et l'élément deux coché zéro
sera égale à ID. Un est égal à ID, et deux est égal à ID. Avant de créer
le script d'aide, créons rapidement une fenêtre simple
en ajoutant
un conteneur de panneaux au jeu, en
le renommant et en le triant
pour qu' il soit dessiné par rapport
aux
autres éléments du jeu Ajoutez ensuite un
conteneur vertical, une étiquette et un bouton. L'étiquette peut
décrire le projet, sa version actuelle et les
personnes qui le développent. Le bouton sera utilisé pour
fermer cette fenêtre et on
peut lui demander de se rétrécir au centre au lieu de remplir la
largeur du contenant. Nous allons ensuite l'ancrer
au centre de l'écran. En connectant le
signal appuyé sur le bouton au nœud about, nous n'avons pas besoin d'un script
attaché au nœud. Nous pouvons simplement sélectionner la
fonction de masquage définie dans la classe de contrôle en désactivant uniquement les méthodes
de script Masquez-le par défaut. Et donnez-lui un nom unique. Enfin,
créons un nouveau script pour le menu contextuel d'aide. Et saisissez également une référence à la fenêtre À propos et connectez son
signal ID pressé au script. faisant correspondre l'identifiant, en nous souvenant que le séparateur occupe
également un identifiant, nous pouvons soit afficher
des informations sur notre jeu, soit ouvrir une
URI dans un navigateur Web. En utilisant le système d'exploitation Singleton, abréviation de système d'exploitation, en utilisant la fonction Shell Open, puis en spécifiant le site Web Cependant, cela ne fonctionnera pas pour
Web Build. Donc, si le nom du
système d'exploitation est HTML five, nous devrions plutôt utiliser le JavaScript Bridge Sileton
pour évaluer ce qui suit Le point d'emplacement des points de fenêtre href
est alors égal au site Web. Cela fonctionnera désormais
sur n'importe quelle plateforme. Lancez le jeu et
essayons d'appuyer sur nos boutons. Dans le jeu principal, appuyer sur
Control end passe au noir. Nous voyons le nouveau message du jeu s'
afficher, et il s'estompe à nouveau. Le chargement fait la même chose. Et la sauvegarde ne fait
que transmettre le message. Nous pouvons cocher et décocher
le bouton muet,
modifier la difficulté
des boutons radio, ouvrir la fenêtre à propos, la fermer et ouvrir ma page Patrion dans le Toutes les options de
notre menu
réagissent désormais aux interactions des joueurs. Dans la leçon suivante, nous allons ajouter les
données de sauvegarde des joueurs et les gérer. Je te verrai dans la prochaine leçon.
27. Enregistrer des données: Bonjour, mes amis. Dans
la leçon précédente, nous avons connecté toutes nos options de
menu à des scripts. Dans cette leçon, nous allons créer les données de sauvegarde du joueur et les gérer à l'aide des options du menu. Pour gérer un Saffle, nous devons
créer un nouveau script qui décrit son Appelons-le
quelque chose comme enregistrer données et hériter de la
ressource plutôt que du nœud Cette ressource ne
sera pas dessinée ni même ajoutée
à l'arbre des scènes, mais sera simplement une
collection de données
décrivant les informations
dont le
joueur a besoin
pour jouer au jeu. En commençant par le haut du
script avant les extensions, nous devons donner à cette ressource un nom de classe en utilisant le mot clé class name
avec un trait de soulignement Ils sont traditionnellement
écrits en cas de Pascal. Nous pouvons ensuite ajouter les variables que
nous voulons à ce script. Ajoutons si
le volume est muet ou non, ce qui serait un booléen et le
paramètre de difficulté sous forme Et aussi toutes les autres variables qui pourraient être nécessaires
pour jouer au jeu, comme l'
or actuel du joueur, par exemple. Tous les
types de variables doivent être primitives telles que booléens,
entiers, flottants ou chaînes ou des
classes intégrées contenant uniquement
ces types primitifs,
tels que des vecteurs Toutes les informations que vous souhaitez
enregistrer doivent comporter la balise d'exportation. Vous souhaiterez peut-être inclure certaines variables sans
la balise d'exportation, qui ne seront pas conservées
entre les sessions de jeu. Bien que toutes ces variables
aient des valeurs par défaut naturelles, nous pouvons également leur attribuer nos
propres valeurs par défaut. Ou si nous voulons inclure des algorithmes
complexes ou la génération de
nombres aléatoires, il serait préférable de remplacer la fonction initialisée
héritée de Godot appellera automatiquement cette fonction pour nous lors de la
création de la ressource, afin que nous puissions initialiser toutes
les variables dont nous avons besoin Ce script doit être enregistré avant de pouvoir être utilisé
dans d'autres scripts. Passons ensuite
au script de fichier. Comme la ressource
a un nom de classe, nous pouvons déclarer une variable
en l'utilisant comme type. Ensuite, la nouvelle
option du menu du jeu peut créer une nouvelle ressource de
ce type en utilisant le nom de classe
suivi du point Nu. Afin de sauvegarder notre jeu, nous devons
également savoir
où l'enregistrer sur le système
d'exploitation du joueur,
il également savoir
où l'enregistrer sur le système
d'exploitation du joueur, est préférable de le stocker
dans une constante. Appelons-le path sous forme de chaîne. Heureusement, Godot résout
ce problème pour nous en fournissant le raccourci client-barre oblique à
l'utilisateur, qui pointe
automatiquement vers un emplacement approprié
sur Il suffit de nommer le fichier. En suivant le nom avec l'extension de
fichier point, TRS
générera un fichier de
ressources texte qui pourra être lu et modifié
par n'importe qui dans le Bloc-notes C'est certainement une bonne idée pour le
débogage et les projets Indi. Pour sauvegarder notre jeu, il suffit d'accéder à
une classe singleton intégrée,
Resource Saver, qui possède
une fonction appelée Cela accepte une ressource
et un chemin comme arguments. Le chargement du jeu ressemble
beaucoup à la sauvegarde, sauf que nous attribuons la valeur des données de sauvegarde à une autre classe de singleton
intégrée, chargeur de
ressources, qui possède
une fonction appelée load, accepte le même argument de
chemin Ces singletons
que nous continuons d'utiliser
ne sont que des scripts
contenant des classes, un peu que des scripts
contenant des classes, un peu comme beaucoup d'autres que nous avons écrits, mais ils font partie du moteur de jeu
Gadot lui-même Ils sont appelés singletons parce qu'ils sont
écrits de telle sorte qu'il ne peut y en avoir qu'
une seule instance à la fois
. Cela les rend très accessibles
car nous pouvons
accéder directement à l'instance unique
directement par le nom de classe, comme nous
l'avons fait ici sans avoir besoin de la
stocker dans une variable. Nous n'avons pas besoin de savoir où
elle se trouve ou de la trouver car le nom de la classe lui-même est une référence directe à
son instance, précisément parce qu'
il n'y en a qu'une. La plupart des scripts que nous écrivons en tant que développeurs n'
ont pas besoin d'être uniques, et il est en fait
préférable qu'ils ne le soient pas. Prenons le
script fade. Par exemple, il n'y a aucune raison pour que nous
ne puissions pas placer ce script exact sur un autre nœud de l'arborescence des scènes
et le réutiliser
dans sur un autre nœud de l'arborescence des scènes
et le réutiliser
dans un
autre but. Mais la nécessité de référencer
le nœud auquel le script est
attaché en
le stockant dans une variable
est le seul moyen de savoir à quel script de fondu
nous essayons d'accéder, car il y aurait
plusieurs instances. Il est possible de créer nos propres
classes Singleton dans Gadot, mais nous n'en aurons pas besoin
pour ce projet À partir du script du gestionnaire de jeu, attribuons
un nom unique au nœud du fichier et stockons une
référence à celui-ci dans une variable. Ensuite, lorsque le
bouton de démarrage est enfoncé, nous pouvons demander
au nœud de fichier de démarrer une nouvelle partie. Le script de fichier gérera le backend qui s'estompe pour nous afin que
nous puissions le supprimer d'ici définissez la valeur par défaut
de busy sur true
, le joueur
ne pourra accéder à aucune de ces fonctions
depuis l'écran titre, ce qui est actuellement possible à
l'aide des raccourcis. Et nous devons également désactiver le bouton de démarrage pour éviter qu'il ne soit pressé
plusieurs fois. En lui donnant un nom unique. Nous n'avons pas besoin de le
stocker dans une variable puisque nous ne l'utiliserons qu'une seule fois et que nous pouvons simplement définir sa propriété désactivée sur
true lorsque vous appuyez dessus. Dans le script de configuration, nous devons stocker une référence
au menu contextuel du fichier dans une variable afin d'
accéder à la ressource de données de sauvegarde, et nous pouvons supprimer ces variables
temporaires. Lorsque vous sélectionnez le bouton Muet, nous devons définir
la valeur de muet
à l'opposé de ce qui est
stocké dans les données de Nous allons définir la
valeur de la ressource de données de
sauvegarde du fichier de manière
à
ce qu'elle soit muette, ce qui en fera le contraire de
ce qu'elle était auparavant De même, pour modifier
la difficulté, vous devrez également définir la valeur
dans les données de sauvegarde du joueur. Lorsqu'une nouvelle donnée de sauvegarde est
créée ou qu'elle est chargée, nous devons définir ces
valeurs pour qu'elles correspondent aux données de sauvegarde. Ainsi, en sélectionnant le menu contextuel du
fichier, nous pouvons connecter le
signal personnalisé créé lors de la dernière leçon
au script du menu des paramètres pour appeler
automatiquement
une nouvelle fonction. Cela nous permet de régler
le mode muet et le niveau de
difficulté en fonction du contenu des données de sauvegarde nouvellement
créées ou chargées Essayons-le en
lançant le jeu. En utilisant les raccourcis de l'écran titre,
ils sont ignorés. Appuyez sur le bouton de démarrage créer nos données de sauvegarde initiales. Si nous sélectionnons Enregistrer dans le menu, un fichier de sauvegarde est
créé sur notre ordinateur, nous pouvons ouvrir dans n'importe quel éditeur de
texte tel que le Bloc-notes Nous pouvons voir les valeurs
de nos variables. De retour dans le jeu, nous pouvons modifier les valeurs de sourdine
et de difficulté, enregistrer le jeu et voir les modifications immédiatement
dans notre fichier de sauvegarde Si nous quittons le jeu
et recommençons, nous pouvons charger notre fichier de
sauvegarde et voir les modifications ont été apportées
aux valeurs que nous avons enregistrées. Toutes nos options de
menu fonctionnent désormais. Dans la leçon suivante, nous allons suivre l'or du joueur. Je te verrai dans la prochaine leçon.
28. Compteur: Bonjour, mes amis. Dans
la leçon précédente, nous avons géré les données de sauvegarde des
joueurs. Dans cette leçon,
nous allons ajouter un compteur à l'écran pour
suivre leur or. Réfléchissons d'abord à
la disposition générale de l'écran et décidons où
placer ces informations. La barre de menu occupant
le coin supérieur gauche, je pense que le fait de placer les compteurs de
ressources des joueurs la même
ligne horizontale que la barre de menu permet d'utiliser à bon escient
l'espace supplémentaire en haut à droite, laissant le reste de la fenêtre disponible pour le jeu principal Une fois le
conteneur de marge sélectionné, ancrons-le d'abord à la taille
réelle du panneau de jeu. Ajoutez ensuite un
conteneur vertical pour organiser la barre de menu au-dessus des autres composants que nous
n'avons pas encore ajoutés. Au conteneur vertical, nous allons ajouter un
conteneur horizontal, qui organisera
la barre de menu à gauche et les
compteurs de ressources à droite Les
compteurs de ressources eux-mêmes,
dotés à la fois d'une icône et d'un chiffre seront également des
boîtes horizontales Appelons celui-ci « or ». Donnez-lui ensuite un
nœud endommagé par une texture et un nœud d'étiquette
comme enfants J'ai cette icône en forme de pièce d'or que je vais utiliser pour la monnaie de mon
jeu, je vais remplir comme
texture pour mon icône Lorsque vous créez une
interface utilisateur comme celle-ci, il est conseillé de définir par défaut
le
nombre le plus élevé que vous souhaitez autoriser pour
vos compteurs nombre le plus élevé que vous souhaitez autoriser pour De cette façon, vous savez combien d'espace doit être alloué
pour l'accueillir Je pense que 10 millions devraient être un
chiffre suffisant ici. Le compteur est
actuellement trié en fonction la boîte horizontale juste à droite
de la barre de menu, mais je préférerais être dans
le coin supérieur droit et tous les compteurs de ressources supplémentaires remplir
tous les compteurs de ressources supplémentaires
que je pourrais ajouter
dans le coin gauche En sélectionnant la
barre de menu, nous pouvons lui demander s'étendre horizontalement pour occuper
le plus d'espace possible, poussant les autres enfants de la boîte
horizontale à se déplacer le plus à droite
possible. Maintenant, si je duplique
mon compteur d'or, chaque compteur sera
ajouté vers la droite, poussant les précédents vers la gauche. Ensuite, ajoutons un script
au nœud doré, qui sera chargé de s'
assurer que le nombre affiché
correspond toujours au nombre d'or dans les données de sauvegarde du
joueur. Appelons-le compteur et enregistrons-le dans le dossier
des scripts. Pour accéder aux données de sauvegarde du
joueur, nous devons stocker une référence au nœud du fichier dans une variable, et pour modifier la propriété du
texte
du nœud d'étiquette, nous en avons également
besoin. Ensuite, nous pouvons écrire une fonction
qui met à jour le compteur. Tout ce que nous avons à faire est de définir la propriété de texte
du nœud d'étiquette étant la valeur du
point or du fichier de données sous forme de chaîne. Chaque fois que le joueur commence une nouvelle partie ou charge sa partie, le signal
de réinitialisation est émis, que nous pouvons connecter à cette fonction pour
mettre à jour le compteur. Ensuite, nous devrons écrire une ou deux fonctions publiques
qui modifieront la valeur. J'écrirai deux fonctions
distinctes, l'une qui reçoit la ressource et l'autre pour dépenser
la ressource, toutes deux acceptant un
paramètre entier pour le montant. Lors de la réception, nous
définirons simplement la nouvelle quantité de la ressource
plus le montant reçu, puis nous
mettrons à jour le compteur. Mais nous avons peut-être décidé
qu'il devrait y une quantité maximale
pouvant être affichée. Appliquons donc cette
restriction ici. Nous allons exporter une autre
variable pour la quantité maximale
et lui attribuer une valeur. Nous pouvons ensuite appliquer ce maximum l'aide de la fonction minimale. La fonction minimum
renverra la plus petite de
toutes les valeurs fournies. donc soit de
la quantité de ressource plus la quantité ajoutée, soit de la quantité maximale autorisée, la valeur la plus faible étant retenue. Lorsque nous dépensons la ressource, nous devons d'abord vérifier
si le joueur en a assez
pour dépenser le montant. Si la quantité de la ressource est inférieure au
montant dépensé, nous ne voudrions probablement pas
poursuivre la
transaction et revenir. Si le joueur en a assez, nous pouvons réduire la quantité
du montant et
mettre à jour le compteur. Nous pouvons rendre cette fonction plus utile en renvoyant un booléen, renvoyant false si
le joueur n'en a pas assez ou en renvoyant true
s'il réussit Ainsi, toute logique de jeu qui appelle
cette fonction peut réagir
au résultat d'une tentative de dépenser cette ressource comme étant vrai
ou faux. À des fins de test,
redéfinissons la fonction d'entrée, qui accepte un
événement d'entrée en tant que paramètre Vérifiez ensuite si les touches haut
ou bas ont été enfoncées. Si vous appuyez dessus, je ferai en sorte que le joueur reçoive un nombre aléatoire de pièces d'or de 1 à 100 De même, en appuyant dessus, ils dépenseront une quantité d'or
aléatoire, et j'imprimerai le résultat. En cours de jeu, nous pouvons
constater que le compteur était réglé pour correspondre à la
valeur initiale de l'or du joueur. En appuyant sur le bas, le
montant diminue jusqu'à ce qu'ils n'aient plus
les moyens de dépenser. Dans ce cas, le
compteur n'est pas réduit et le résultat
devient faux. Une pression vers
le haut augmente le compteur et finit par atteindre
la quantité maximale. Cela fonctionnera plutôt
bien pour l'or, mais que se passerait-il si
nous avions
différentes ressources à traiter avec
les mêmes fonctions ? Nous aurions besoin d'un
script différent pour chaque ressource, ce qui n'est pas une très bonne conception. Rendons donc ce script plus flexible et exportons le nom de la ressource que
ce
compteur suit sous forme de chaîne. N'oubliez pas de définir cette
valeur exportée dans l'inspecteur avec exactement
la même orthographe que la variable dans les données de
sauvegarde du lecteur que vous
souhaitez compter. Je vais également ramener ma valeur maximale en or à
ce qu'elle devrait être. Nous devrons également déclarer une autre variable pour
maintenir la quantité. Désormais, les deux fonctions de transaction peuvent commencer par
obtenir la quantité de ressource à partir des
données de sauvegarde
du joueur à l'aide de la fonction G, qui accepte le
nom de la propriété sous forme de chaîne. Nous allons donc lui donner
le nom de la ressource. Nous effectuerons ensuite
nos transactions sur la variable locale au lieu de référencer
directement
les données de sauvegarde des joueurs Et après avoir exécuté
nos fonctions, nous pouvons définir la variable
dans les données de sauvegarde du joueur la même manière
en
utilisant la fonction set, passant le nom
de la propriété sous chaîne et sa nouvelle valeur. Nous devons également obtenir la quantité
actuelle à partir des données de sauvegarde
du joueur
lors de la mise à jour du compteur. Nous pouvons maintenant dupliquer le nœud
doré et lui demander suivre une autre ressource
sans modifier le script, en modifiant
uniquement les valeurs
de ses variables exportées. Ajoutons une autre ressource
aux données de sauvegarde des joueurs, peu comme des robots avec
une valeur initiale de un. Connectez-vous ensuite également au signal
de réinitialisation pour jour
automatiquement ce
nouveau compteur de ressources. Maintenant, lorsque nous lançons le jeu, les deux compteurs
affichent les quantités de ressources
différentes contenues
dans les données de sauvegarde des joueurs N'oubliez pas de supprimer ou
de commenter la fonction de saisie
avant de continuer. De plus, l'
affichage des compteurs aurait dû être mis à jour après avoir défini
la valeur de la quantité Nous avons désormais des
compteurs de ressources pour notre jeu. Dans la section suivante, nous allons commencer à implémenter certains mécanismes de
jeu. Je vous verrai dans
la section suivante.
29. Montage de ligne A: Bonjour, mes amis. Dans
la section précédente, nous avons créé une
barre de menu pour notre jeu. Dans cette section, nous allons commencer à implémenter certains mécanismes de
jeu. Commençons par réduire
le
conteneur horizontal et peut-être renommer de manière plus
descriptive, comme top Nous pouvons ensuite ajouter un autre enfant dans la boîte verticale pour remplir le reste
du panneau de jeu. Je vais utiliser un autre conteneur de
marge. Je vais nommer ce
porte-conteneurs à marge, car je vais l'utiliser pour
afficher des informations sur le navire du joueur et agrandir pour remplir verticalement le reste du panneau de jeu. À l'intérieur du conteneur de marge, je vais placer une
boîte verticale pour organiser quelques
composants verticalement, commençant par un nœud d'étiquette
qui indique simplement mon navire, afin que le joueur sache qu'il
s'agit de son navire. En dessous, je vais
mettre un rectangle de texture pour dessiner une image du navire, utiliser l'icône Gadot comme
image de remplacement, lui dire d'ignorer la
taille de l'image et lui donner des dimensions personnalisées
de 150 pixels carrés Et enfin, un bloc
de statistiques contenant les
différentes statistiques du navire. À l'instar d'un conteneur horizontal ou
vertical, nous pouvons facilement organiser un grand
nombre de nœuds de contrôle dans une formation de grille à
l'aide d'un conteneur de grille. Nommons ces statistiques
et attribuons-leur deux colonnes, l'une pour les libellés et l'
autre pour les valeurs. Pour les statistiques, j'ajouterai
deux nœuds d'étiquette pour chacun le nom du navire, son type, le nombre de membres d'équipage et la quantité de
cargaison qu'il peut contenir. Les étiquettes situées sur le côté gauche de la grille indiquent de quel
type de valeur il s'agit. Les étiquettes sur le côté
droit peuvent contenir exemples d'
informations pour le moment, mais nous voulons qu'elles soient liées aux informations contenues dans les données de sauvegarde du
joueur. Le conteneur de la grille triera
automatiquement ses enfants selon le nombre
de colonnes spécifié, en maintenant toutes les lignes
et colonnes alignées. En sélectionnant les trois nœuds enfants du conteneur vertical, je vais les faire rétrécir
au centre. J'aimerais que le
joueur puisse
changer le nom
de son vaisseau, alors changeons le nœud d'étiquette de nom en
nœud d'édition de ligne. Ce nœud permet
au joueur de modifier le texte qu'il contient
pendant le jeu. Je vais mettre tout cela dans un conteneur en panneaux pour qu'il soit
entouré d'une belle bordure. Dites ensuite au
conteneur vertical de se rétrécir verticalement jusqu'au
centre du conteneur à panneaux. cet écran, nous pouvons
clairement voir les informations dont nous aurons besoin pour stocker pour
chaque navire : une photo, nom, le type de navire, le nombre minimum
et maximum d'équipage et la capacité de chargement. Tout comme nous l'avons fait avec
les données de sauvegarde du joueur, nous pouvons créer un script
de ressources pour conserver ces informations. Créons d'abord un nouveau dossier de
script nommé Resources, nous pourrons placer le script de sauvegarde
des données. Créez ensuite un nouveau dossier pour les navires et créez un nouveau script dans ce dossier nommé ship
heriting from resource Ici, nous pouvons exporter des variables
comme nous l'avons fait avec les données de sauvegarde des joueurs
pour décrire un navire, y compris une texture,
deux D pour l'image, une chaîne pour le type et des entiers pour
l'équipage minimum, l'équipage maximum et la capacité de
chargement Je vais exclure le nom du
navire car il ne sera pas
associé au type de navire. Assurez-vous d'enregistrer ce script. En cliquant avec le bouton droit sur le dossier de ressources du
navire, nous pouvons maintenant créer une nouvelle ressource et fabriquer autant de
navires que nous le souhaitons. Je vais construire trois navires, un cutter, un catch et une goélette En double-cliquant sur la ressource, nous pouvons l'ouvrir dans l'inspecteur et modifier les variables exportées, l'image avec l'image
d'un cutter, en
indiquant le type, remplissant l'image avec l'image
d'un cutter, en
indiquant le type, les limites d'équipage
et les variables de capacité de chargement Chacune de nos ressources
peut renseigner les variables exportées avec ses
propres valeurs uniques, créant ainsi une catégorie d'objets
similaires pour notre jeu qui ont tous les mêmes propriétés mais avec des valeurs
différentes Pour mieux organiser mes scripts, je vais créer un
sous-dossier pour UI yes Où je placerai tous mes sous-manuscrits, en
fondu et en contre-impression. Ensuite, un autre dossier
pour les managers, qui contiendra le gestionnaire de
jeu et un autre nouveau script
que je vais attacher
au nœud du navire et le
nommer ship manager. La
responsabilité du directeur du navire sera gérer tout ce qui
se passe avec ses enfants, y compris la mise à jour des images et du texte
affichés. Pour ce faire,
ce script doit connaître tous les vaisseaux
présents dans le jeu. Nous allons donc exporter un ensemble
de navires sous forme de variable. En jetant un coup d'œil à l'inspecteur, nous pouvons voir notre gamme
de navires, y ajouter trois éléments et peupler chacun d'entre eux d'
un navire différent J'ai conçu mes
vaisseaux pour qu'ils fonctionnent comme des améliorations et je préférerais qu' ils soient triés
du pire au meilleur. Je vais donc placer le
cutter à l'indice zéro, suivi du catch,
puis de la goélette Maintenant, tout ce que nous avons besoin de savoir à partir des données de sauvegarde du joueur
, c'est quel vaisseau il possède
actuellement. Cela peut facilement être
stocké de manière très efficace sous forme d'
index matriciel du navire. Pour passer au script de
sauvegarde des données, je vais ajouter un entier exporté pour le numéro d'index du navire du joueur et le mettre à zéro par défaut. Pendant que je suis ici, j'
ajouterai également une chaîne pour
le nom du navire. De retour dans le script de gestion des navires, pour afficher les informations du navire du
joueur, nous aurons besoin d'une référence
au menu contextuel du fichier pour accéder aux données de sauvegarde du
joueur. Je vais renommer ce
nœud « Informations sur le navire ». Récupérez ensuite les références
aux nœuds de texture wrec, d'édition de
ligne et d'étiquette Je vais renommer chacune
de ces variables afin de m'assurer qu'elles décrivent le
jeton actuel du joueur et aussi une variable locale contenant le numéro d'index du navire du
joueur écrivant une fonction privée pour
mettre à jour les informations du
navire du joueur, chaque nœud attribuera à
la propriété appropriée
celle d'un navire du tableau, en utilisant le
numéro d'index du navire du joueur pour indexer le tableau. Je vais afficher l'équipage minimum
et maximum ensemble en les transformant en chaînes
et en les séparant par un
trait d'union Ensuite, affichez également
la capacité de chargement avec ses unités en tonnes. Lors du démarrage ou du chargement d'une nouvelle
partie, le signal de réinitialisation est
émis et nous pouvons nous connecter à ce signal pour mettre à
jour automatiquement les informations du
vaisseau du joueur. A après avoir récupéré le
numéro d'index de leur navire à partir des données de sauvegarde Mais notre vaisseau
n'a toujours pas de nom. Je vais générer aléatoirement des
noms de navires
à partir d'une liste en
déclarant d'abord une constante en haut de mon script appelée ship names, qui sera un
tableau de chaînes. Je vais ensuite remplir ce tableau avec un tas de noms de navires
courants Dans la fonction de réinitialisation du fichier, si le navire n'a pas de nom, je lui attribuerai un nom
sélectionné au hasard dans cette liste. Indexation du tableau
avec un entier aléatoire compris entre zéro et la taille
du tableau moins un La dernière chose à faire est
d'autoriser le nœud d'édition de ligne à modifier
le nom du navire du joueur, ce qui peut être fait en connectant signal envoyé par le texte
au script du gestionnaire de navires. Cela sera omis après avoir
appuyé sur la touche Entrée. Il existe également
des signaux chaque fois que le texte change ou lorsque la
limite de taille du texte est atteinte. Dans notre fonction nouvellement générée, il existe deux
situations possibles que nous devons prendre en compte si le
texte d'édition de ligne est vide ou non. Comme le nouveau texte nous a été
transmis en tant que paramètre, nous pouvons facilement le mettre
dans une instruction
if true n'étant pas vide
et false étant vide. Si le nouveau texte n'est pas vide, nous pouvons l'attribuer au nom du navire du
joueur. Mais s'il est vide, nous
pouvons faire le contraire, en
rétablissant le texte de la ligne d'édition à la
valeur précédente du nom du navire Cela empêchera le joueur d'avoir un navire sans nom. Il est également conseillé de demander au nœud
d' édition
de ligne de relâcher le focus, quel que soit le résultat. Le nom du navire peut être
lu directement à partir des données de sauvegarde
du joueur lors de la mise à jour. En revenant à la vue en deux D, nous pouvons constater que les informations sur
les navires de nos joueurs sont renseignées avec des informations d'
espace réservé Lorsque nous lançons le jeu,
tout est automatiquement remplacé par les informations associées au navire coupeur, et un nom
aléatoire a été attribué au navire dans la liste. Nous pouvons cliquer sur le nœud d'
édition de ligne pour changer le nom du navire et appuyer sur Entrée pour soumettre le changement. Aucune tentative de dénomination du
navire n'est rejetée. Sauvegarde de la partie, puis
démarrage d'une nouvelle partie. Le nom du navire est
remplacé par un nom
généré aléatoirement et
lors du chargement du jeu, notre nom de navire enregistré est restauré. Les
informations du navire de nos joueurs sont désormais affichées et nous pouvons modifier le nom du navire. Dans la leçon suivante, nous allons
passer en revue les options disponibles pour les
propriétés d'édition de ligne et le thème. Je te verrai dans la prochaine leçon.
30. Montage de ligne B: Bonjour, mes amis. Dans
la leçon précédente, nous avons autorisé le joueur à
changer le nom de son navire. Dans cette leçon, nous allons
passer en revue les options disponibles pour les
propriétés d'édition de ligne et le thème. En sélectionnant le nœud d'édition de ligne, examinons ses
propriétés dans l'inspecteur. En utilisant la propriété text, nous pouvons lui donner une valeur par défaut. Si la propriété text est vide, texte de l'espace réservé est affiché à la place avec
une couleur de police différente On peut aligner le texte
au centre, non ? Ou remplissez la ligne entière pour
espacer les mots de manière uniforme. Nous pouvons limiter la longueur
du texte saisi. Il est conseillé de tester la
quantité de texte qui peut être
affichée confortablement à l'aide d'une lettre large,
comme un M ou un W. Ensuite, utilisez-le pour déterminer
la longueur maximale du texte. Si l'édition de ligne n'
est pas modifiable, le joueur ne
pourra pas cliquer
dessus pour modifier son contenu Si l'extension à
la longueur du texte est activée, la zone s'agrandira pour
accueillir le texte qu'elle contient. L'activation du menu contextuel
permettra au joueur cliquer avec le bouton
droit sur la
ligne au niveau du nœud pour afficher un menu contextuel. Nous pouvons le voir dans l'
éditeur de thème sans lancer le jeu. Le menu contextuel
est automatiquement conçu pour correspondre aux menus contextuels de notre
jeu et inclut tous les éléments
habituels tels que couper, copier,
coller, tout sélectionner,
effacer, annuler et rétablir, un sous-menu permettant de modifier
l'orientation du texte
et des options pour afficher
et insérer des caractères de
contrôle Si vous ne souhaitez pas inclure ce menu contextuel, vous
pouvez le désactiver ici. Pour les consoles et les plateformes
mobiles, l'intégration du clavier
virtuel est disponible, et il existe plusieurs
options de clavier virtuel, en
particulier pour la saisie de chiffres, de décimales, de
numéros de
téléphone, d'e-mails, de mots de
passe ou d'URL. Un bouton transparent peut être inclus
qui, une fois cliqué, supprimera tout le texte de l'édition de ligne Les touches
de raccourci affichées dans le menu contextuel seront utilisées même si le menu
contextuel ne l'est pas. Ils peuvent être désactivés ici. Il existe une option permettant
de désactiver le collage à l'aide du
bouton central de la souris sur les plateformes Linux Vous pouvez également choisir si le joueur peut
ou non
sélectionner du texte à l'aide de
la souris ou du clavier. La désélection en cas
de perte de focus désélectionne le texte
surligné lorsque le nœud d'édition de ligne perd La sélection par glisser-déposer peut
être utilisée pour contrôler
si le joueur peut cliquer et faire glisser du texte dans cette modification de ligne. Une icône peut être affectée
sur le côté droit du nœud pour mieux
indiquer au joueur
que ce texte est modifiable Il est courant d'avoir un crayon, mais j'utiliserai une icône en forme de plume pour correspondre à l'
esthétique de mon jeu S'il existe à la fois une
icône droite et un bouton Effacer, le bouton Effacer
sera dessiné à la place de l'icône droite chaque fois qu'il
y a du texte à effacer. Flat fonctionne comme les boutons, en supprimant tous les styles
du nœud et en dessinant uniquement
le texte et l'icône. Dessiner les caractères de contrôle est la même option de bascule qui était disponible dans le menu contextuel, permettant de dessiner les
caractères de contrôle Enfin, sélectionner tout au moment du focus
sélectionnera automatiquement tout le texte
lorsque le nœud saisira le focus pour la première fois Dans la catégorie des carats, nous pouvons indiquer au
carat de clignoter et spécifier l'intervalle de
temps entre les clignotements La colonne de carats est l'indice de caractères indiquant la position actuelle du
carat. Nous pouvons le voir si nous
forçons la modification de la ligne pour afficher le carat
même sans focus. Si vous utilisez l'édition de ligne pour des informations
secrètes
telles qu'un mot de passe, nous pouvons activer le secret, et chaque caractère
sera dessiné comme le caractère secret
spécifié ici. Les options d'affichage du
graphème fabriqué au carat et du BD sont également disponibles pour les systèmes d'écriture plus
complexes en dehors de l'alphabet romain Pour mon jeu, je vais utiliser
le texte d'espace réservé nommer votre navire avec une longueur maximale de 16 caractères et laisser la boîte s'agrandir pour
accueillir le texte Je vais garder l'
icône de droite comme plume,
sélectionner tout le texte sur lequel le focus mis au point
et activer le
blanc en carats À part cela,
les autres options sont correctes
par défaut En sélectionnant le nœud racine pour
voir l'éditeur de thème, ajoutons une
modification de ligne au thème. Dans la section des couleurs, nous
pouvons changer la couleur
du carat et du bouton Effacer tels qu'ils sont normalement enfoncés. Nous pouvons modifier la
couleur de police du texte normal, texte
de remplacement, du texte sélectionné et du texte non modifiable, ainsi que la
couleur du contour de chacun d'entre eux et la couleur de la zone dessinée derrière Dans la section constante, nous pouvons modifier la
largeur du carat, définir la largeur minimale de
caractères pour la ligne ****,
mesurée en Ms, et l'épaisseur du contour de
la police. Comme pour tout ce qui concerne le texte, nous pouvons modifier la
police et la taille de police, mais je vais les laisser comme
valeur par défaut pour le thème, et nous pouvons remplacer l'icône
utilisée pour le bouton Effacer Les
couleurs claires des boutons seront utilisées comme modulation sur
cette texture d'icône. Enfin, dans la section style, nous pouvons fournir des boîtes de style indiquant
à quoi ressemble
normalement l'édition de ligne lorsqu'elle est focalisée
et lorsqu'elle est en lecture seule. Je vais utiliser le style Box
flat comme d'habitude. Cliquez ensuite dessus pour le modifier, ajoutez mes sept
pixels habituels de coins, de bordures et de marges de contenu. J'aurai la même couleur que le fond avec une couleur de bordure
plus foncée. Ensuite, je vais dupliquer
la boîte de style à
plat jusqu'à l'option de mise , la
rendre unique, puis l'
ouvrir pour la modifier. Une fois le focus atteint, je change la bordure en une
couleur plus claire et j'ajoute une ombre. Nous pouvons voir à quoi
ressemblent nos modifications dans l'aperçu du thème. Pour la lecture seule, je vais simplement
utiliser une boîte de style vide. Ajoutons également le
conteneur en grille à notre thème. Tout comme les conteneurs horizontaux et
verticaux, le conteneur de grille ne possède que des constantes pour les propriétés de son
thème, est-à-dire le nombre de pixels séparant
ses lignes et ses colonnes. N'oubliez pas de tester
l'
apparence de vos modifications en lançant votre jeu. Notre nœud d'édition de ligne est maintenant configuré pour correspondre à l'
esthétique de notre jeu. Et la prochaine leçon permettra au joueur
d'acheter un nouveau vaisseau. Je te verrai dans la prochaine leçon.
31. Bouton d'option: Bonjour, mes amis. Dans
la leçon précédente, nous avons autorisé le joueur à
changer le nom de son navire. Dans cette leçon, nous allons permettre au
joueur d'acheter un nouveau navire. Je vais simplement recréer
un ensemble
d'informations très similaires sur la droite
de ce panneau, affichant les statistiques d'
une amélioration de navire
disponible à l'achat, en
commençant par un conteneur
vertical,
que commençant par un conteneur
vertical, je nommerai
navires à vendre, puis en les plaçant tous les deux dans une boîte horizontale pour les
organiser côte à côte Lorsque les deux notes pour
enfants sont sélectionnées, leur
demandant de
s'étendre horizontalement, ils partageront l'espace
disponible de manière uniforme. À l'intérieur des navires à vendre, je copierai par-dessus l'étiquette
Wreck Wreck Grid Container et tous ses nœuds d'étiquettes Je vais faire en sorte que
les navires à vendre verticalement
au centre pour qu'ils correspondent à la disposition du côté gauche. Modification de l'étiquette pour
indiquer « navires à vendre ». Mais je vais changer le nom en coût, remplacer l'étiquette
de gauche par un rectangle de texture et utiliser l'icône de ma pièce au lieu du texte pour indiquer qu'il s'
agit du prix d'achat. Je vais le régler pour qu'il soit
proportionnel à la largeur et son rapport hauteur/largeur
corresponde à la hauteur du nœud à droite. Remplacez-le ensuite en nœud d' étiquette
normal et
remplissez-le avec un numéro d'échantillon Déplacez-les ensuite vers le
bas de la grille. J'ajouterai ensuite également un bouton en bas pour permettre au
joueur d'acheter ce vaisseau. Et réduisez-le au centre horizontalement pour qu'il
corresponde à la mise en page. Cela n'a peut-être pas beaucoup de sens de n'avoir qu'une seule puce à vendre Je vais
donc remplacer le
type de navire par un bouton d'option. Il s'agit d'un bouton
qui présentera au joueur plusieurs
options parmi lesquelles choisir. Ce bouton d'option hérite de ses
propriétés de thème Je peux utiliser le
thème de mon bouton pour le bouton d'achat, mais j'aimerais que le
bouton d'option ait un style
différent. En sélectionnant le nœud racine
pour voir l'éditeur de thème, ajoutons un
bouton d'option au thème. Cela nous permettra de remplacer les propriétés du thème dont le bouton d'option
hérite La plupart des propriétés du thème
pour le bouton Option sont identiques à celles
du nœud de bouton normal, ce qui nous permet de
modifier la police et couleurs des
icônes de tous
les états du bouton. La couleur du contour de la
police, la police et la taille de police, ainsi que les zones
de style pour chacun des états des boutons, également. Je vais utiliser le style Box flat pour mon bouton d'option et le
faire ressembler
au nœud d'édition de ligne. Ensuite, dupliquez cette zone de
style pour la presser, rendez-la unique, changez la couleur de la bordure en
une teinte plus claire. Utilisez-le pour le survol, le survol et la mise
au point. Ensuite, j'utiliserai simplement une
boîte de style vide pour les personnes désactivées. Nous pouvons voir à quoi ressemblent nos
modifications dans la fenêtre d'aperçu du thème
sans lancer le jeu. Dans la section des icônes, nous pouvons modifier l'
apparence de la flèche vers le bas en fournissant
une icône différente. Tout comme les menus contextuels, cette icône mesure 16 pixels au carré
et ne sera pas redimensionnée.
Il est donc important
que l'icône par laquelle vous la remplacez soit
correctement dimensionnée Il existe également une
propriété de thème pour une icône qui sera dessinée à gauche
du texte du bouton. Je vais juste ajouter une autre icône pour vous montrer à quoi
cela ressemble. Dans la section des constantes, il existe une propriété permettant de définir
la taille du bouton pour qu'
elle corresponde à sa plus grande boîte de style au cas où vos boîtes de style
seraient de tailles différentes. Cela fonctionnera lorsque mon bouton d'
option est désactivé, car la boîte de style vide
est plus petite que les autres. La marge de la flèche correspond au
nombre de pixels situés entre la flèche vers
le bas et le côté droit du bouton. La séparation horizontale
correspond à l'espace entre l'icône de gauche
et le texte du bouton. La largeur maximale de l'icône peut être utilisée pour limiter la taille
de l'icône de gauche. Cela n'a aucun effet
sur la flèche pointant vers le bas. Flèche modulée. Si une valeur
autre que zéro est donnée, nous modulons l'icône en forme de flèche
avec la couleur de police du texte du bouton dans tous
ses différents états Et la taille du contour dessine un contour autour
du texte, comme nous le savons. Je ne souhaite pas
utiliser l'icône de gauche pour mon jeu, je vais donc la supprimer. En sélectionnant le nœud du bouton d'
option, examinons ses
propriétés dans l'inspecteur. La section
des éléments extensibles fonctionne exactement comme celle que nous utilisons
pour créer nos menus contextuels Je vais donc ajouter un objet pour
chaque vaisseau de mon jeu. Chaque élément peut se voir attribuer
une icône si vous le souhaitez, désactiver ou l'utiliser comme séparateur. Le numéro d'identification est
utilisé pour identifier quel élément de la liste
est actuellement sélectionné. Si la valeur sélectionnée
est négative, aucun élément n'est sélectionné. Ajuster à l'article le plus long
permet de dimensionner l'ensemble du bouton pour qu'il s'adapte au mieux à l'ensemble du bouton pour qu'il s'adapte au mieux à l'article
dont le texte est le plus long. Désactivé, le
bouton est redimensionné pour s'adapter au texte de
l'élément sélectionné uniquement Et le bouton Autoriser la
resélection
permettra au joueur de sélectionner
le même élément qui
est déjà sélectionné, en
émettant à permettra au joueur de sélectionner
le même élément qui
est déjà sélectionné, nouveau le
signal sélectionné Bon nombre des mêmes options
sont également disponibles, héritées du
bouton et du bouton de base que nous avons déjà explorés. Il est clair que chacun de mes
navires aura
besoin d' une autre propriété, de
son prix d'achat. Donc, en passant à ScriptView, je vais ajouter une variable au script d'expédition pour
le prix du navire N'oubliez pas de sauvegarder le script. Donnez ensuite à chaque ressource du navire une valeur différente
pour son prix. Je vais renommer mon bouton By. Connectons le signal d'appui
sur les boutons By au script du gestionnaire de
navires. Et aussi le
signal de l'élément sélectionné à partir du bouton d'option. Il existe également un signal
qui sera émis lorsqu'un élément du
menu contextuel est focalisé si vous en avez besoin. Comme nous l'avons fait pour les informations sur le navire des
joueurs, nous allons renseigner les
informations sur le navire sur le côté droit de l'écran
avec les informations
du navire sélectionné sur
le bouton d' option en
fonction de son index Nous devrons donc
stocker les références au bouton d'
option
et
aux nœuds d'étiquette détruits par la texture ,
ainsi qu'au bouton Par Depuis que j'ai trié tous
ces nœuds dans un conteneur horizontal, tous ces chemins ne
sont plus valides. Je pourrais renommer tous
mes nœuds pour qu'ils aient des noms
uniques et utiliser des références de nom
uniques, mais je vais simplement ajouter le conteneur de
boîtes horizontales au chemin à
la place Nous pouvons copier presque toutes les lignes
de code
, de la mise à jour des informations du
navire du joueur vers la
fonction « valeur
du type » sélectionnée pour mettre à jour les informations sur le navire à vendre, en remplaçant
simplement
l'index du tableau par l'index du navire
sélectionné. Cela ne fonctionnera que si les
indices du réseau de
navires sont les mêmes que les numéros d'identification des éléments dans le menu contextuel
des boutons d'option. Nous pouvons le garantir
en générant nous-mêmes
les éléments des boutons d'option à partir de ce script. remplaçant la fonction « prêt », nous pouvons parcourir chacun En remplaçant la fonction « prêt »,
nous pouvons parcourir chacun
des navires du réseau de navires,
puis ajouter un élément au
bouton d'option,
le type de navire puis ajouter un élément au bouton d'option,
le type de Comme le réseau de navires est
indexé à partir de zéro, en ajoutant chaque article
au bouton d'option, les numéros d'identification
correspondront exactement Mais nous devons supprimer
tous les éléments
du bouton d'option et le faire démarrer le jeu à vide
pour que cela fonctionne. Lorsqu'une nouvelle partie est lancée
ou qu'une partie est chargée, nous récupérons l'index du
vaisseau que le joueur possède déjà. Je ne veux pas autoriser
le joueur à acheter le même vaisseau qu'il possède déjà ou un vaisseau de moindre qualité. Je vais donc compter de zéro jusqu'à la taille du
réseau de vaisseaux et désactiver chaque objet dont le numéro d'
index est
inférieur ou égal à l'indice de navire actuel du
joueur. Je sélectionnerai ensuite
la prochaine amélioration disponible pour le joueur,
s'il y en a une. Si le vaisseau actuel du joueur est le dernier numéro
d'index du réseau de navires, il n'y a plus d'améliorations Je vais
donc demander
au bouton d'option de sélectionner la valeur négative, et toutes les options
seront désactivées. Sinon, le
bouton d'option permet de sélectionner l'objet
dont l' indice est
supérieur d'un à l'indice de navire
actuel du joueur. Puisque j'autorise la sélection d'
une valeur négative, s'
agit évidemment pas
d'un index de tableau valide Je devrai
donc ajouter une
condition à la
fonction on type value selected pour l'adapter. Et supprimez plutôt toutes
les informations. La dernière chose que je souhaite faire
est de désactiver le bouton d'achat si le joueur n'a pas
assez d'argent pour acheter le navire actuellement
sélectionné. Saisir une référence
au compteur d'or du joueur. Je vais simplement définir la valeur
de Buy Dot Disabled à l'opposé de
Gold Dot has enough, en passant la valeur du jeton
actuellement sélectionné. Cette fonction n'existe pas, alors passons
au
contre-script et ajoutons-le rapidement. copiant la définition des dépenses, nous devons simplement
indiquer si
la quantité de la ressource est
supérieure ou égale au
montant en question. Pendant que je suis ici, je vais décommenter la fonction de saisie afin de pouvoir
tricher pour gagner plus Enfin, lorsque vous appuyez sur
le bouton d'achat, nous appelons gold dot spend, passant le prix
du navire actuellement sélectionné à vendre, et en le plaçant dans
un relevé I, nous pouvons
réagir pour savoir si le joueur possède suffisamment
d'or pour le faire. Cela ne devrait jamais se produire
puisque nous avons désactivé le bouton de manière préventive s'
ils n'avaient pas assez d'or, mais la redondance est une bonne
chose Si la transaction
est réussie, nous définirons l'indice de navire
actuel du joueur sur le navire actuellement sélectionné. Mettez ensuite à jour les informations du
navire du joueur ainsi que les navires à vendre. Sinon, j'imprimerai un message d'erreur pour
savoir si cela s'est produit. Lorsque vous définissez l'index sélectionné du bouton d'option
via notre script, le signal de l'élément sélectionné ne
sera pas omis Mais nous pouvons facilement appeler directement notre
fonction à la place. En passant l'
index sélectionné, nous le définissons simplement sur. En cours de jeu, le
joueur commence avec un cutter et la prise
est présentée à la vente. En appuyant sur le bouton d'option, le joueur n'est pas autorisé
à acheter un autre cutter, mais il peut également
voir la goélette En achetant la prise, les informations du navire du
joueur sont mises à jour et la goélette
est présentée à la vente En élargissant le bouton d'option, la goélette est désormais
la seule option Pour me donner plus d'argent, je vais sélectionner à nouveau la goélette
pour activer le bouton d'achat Si nous l'achetons, il n'
y a plus de navires à vendre. Je devrais également désactiver le bouton d'achat s'il n'
y a rien à acheter. Nous avons maintenant des navires à vendre que le joueur peut acheter
en tant qu'amélioration. Dans la leçon suivante, nous allons créer plusieurs pages d'
informations différentes que le
joueur pourra passer d'une page à l'autre. Je te verrai dans la prochaine leçon.
32. Récipient divisé horizontal: Bonjour, mes amis. Dans
la leçon précédente, nous avons autorisé le
joueur à acheter des navires
plus grands et de meilleure qualité. Dans cette leçon, nous allons
permettre au joueur de redimensionner
des régions du panneau de jeu Cette
page de gestion des navires de mon jeu est clairement divisée en deux
zones d'informations le navire actuel du joueur et les navires que le
joueur peut acheter. Organisés dans une boîte
horizontale, aucun d'entre eux n'occupe la totalité de l'
espace qui leur est fourni. Ils s'étendent
donc pour diviser l'espace de manière uniforme. Dans de tels cas, il
existe un nœud de contrôle que nous
pouvons utiliser pour donner au joueur
un meilleur contrôle sur la mise en page, en lui permettant de redimensionner
la division d'un espace entre deux
nœuds de contrôle, un conteneur divisé Les conteneurs divisés peuvent être
horizontaux ou verticaux, mais ils ne peuvent comporter que deux nœuds
enfants. Ils
diviseront l'espace disponible entre eux et permettront également au
joueur de l'ajuster. Si je renomme ce nœud, tous les chemins de mes nœuds seront interrompus Je vais donc laisser
le nom tel quel. Rien ne semble
avoir changé, mais si nous lançons le jeu et que nous passons la souris au-dessus
du centre du panneau
de jeu, il y a maintenant une barre sur laquelle
nous pouvons cliquer pour la saisir et la faire glisser vers la gauche ou la
droite pour redimensionner chaque Chaque camp ne sera autorisé
à se rétrécir que jusqu'au point où ses propres nœuds de
contrôle ne
pourront plus s'effondrer davantage. En sélectionnant le conteneur
divisé horizontalement, examinons ses
propriétés dans l'inspecteur. Le décalage fractionné peut être utilisé
pour ajuster la position du split, zéro
étant
l'endroit où il se trouverait naturellement après le
premier nœud de contrôle enfant, le négatif se déplaçant vers la gauche et le
positif se déplaçant vers la droite. Collapsed ignorera
le décalage de division, réduira le premier nœud de contrôle
enfant et positionnera le split
immédiatement après celui-ci. La visibilité du dragger peut être
utilisée pour masquer le dragger, rendre inutilisable ou pour le masquer
et le réduire en supprimant la séparation des pixels
entre les nœuds enfants En sélectionnant le nœud racine pour
voir l'éditeur de thème, nous pouvons ajouter le conteneur
divisé horizontalement à notre thème. Dans la section des constantes, nous pouvons supprimer le comportement
masqué automatiquement
du grabber en changeant
la valeur à zéro, ce qui rendra le
grabber L'épaisseur minimale de capture
est la largeur ou la
hauteur en pixels de la zone cliquable générée pour entourer
le capteur, étant donné que les icônes du capteur
sont généralement très fines et que la séparation est le nombre de pixels qui séparent les
deux nœuds de contrôle enfants Dans la section des icônes, il existe trois icônes de saisie
différentes, mais il suffit de
changer celle du haut Les
grabbers horizontaux et verticaux sont des propriétés
du conteneur
divisé de classe parent et ne
seront pas utilisés par ce nœud de conteneur divisé
horizontal lançant le jeu, nous pouvons
constater que le grabber
ne se cache plus automatiquement lorsque
la souris ne le touche pas La zone séparant
les deux nœuds enfants est plus large qu'elle ne l'était auparavant, tout comme la zone cliquable. Notre conteneur de marge est désormais divisé en deux régions
redimensionnables Dans la leçon suivante,
nous allons donner au joueur plusieurs pages d'informations
qu'il pourra passer d' une page à l'autre. Je te verrai dans la prochaine leçon.
33. Conteneur à onglets: Bonjour, mes amis. Dans
la leçon précédente, nous avons autorisé le joueur à
redimensionner une partie du jeu Dans cette leçon, nous allons
autoriser le jeu à afficher plusieurs
pages d'informations différentes. Ma fenêtre de jeu
semble désormais plus pleine, et je ne pourrais pas intégrer plus de
mécanismes sans surcharger le joueur avec trop d'informations
affichées en même temps. Pour résoudre ce problème,
transformons le nœud
situé sous la
barre de menu en conteneur d'onglets. La description nous indique
que le conteneur d'onglets créera un onglet pour
chaque contrôle enfant, affichant qu'un seul à la fois. Faire du nœud du navire un
enfant du conteneur à onglets. Il devient un onglet dans
le conteneur d'onglets. J'ajouterai plusieurs autres onglets en ajoutant plus d'enfants
au conteneur d'onglets. Ils seront tous des conteneurs à
marge. J'en aurai un pour laisser le joueur gérer l'équipage de son navire, un autre pour acheter
et vendre des marchandises, et un pour naviguer
vers un autre port Les onglets générés par
le conteneur d'onglets peuvent être réorganisés en modifiant
l'ordre de leurs enfants Avec la réorganisation
de l'arborescence des scènes, le
script du gestionnaire de navires aura déconnecté son chemin vers le nœud du compteur de ressources
en or Je peux résoudre ce problème en donnant un nom unique
au compteur et en utilisant l'annotation du
signe de pourcentage au lieu du chemin du nœud. En revenant à la vue en deux D et
en sélectionnant le conteneur d'onglets, examinons
les propriétés
du conteneur d'onglets
dans l'inspecteur. Les onglets sont alignés vers
la gauche par défaut, mais ils peuvent être déplacés
vers la droite ou vers le centre. Ils peuvent également être déplacés vers le bas du conteneur d'onglets. L'onglet actuel est le numéro
d'index
enfant de l'onglet
actuellement affiché. S'il y a tellement d'
onglets qu'ils ne correspondent pas tous à la longueur
du conteneur d'onglets, les onglets supplémentaires
seront découpés et des boutons de navigation seront fournis pour permettre au joueur de les
parcourir. Si les onglets à clips sont désactivés, le conteneur d'onglets
s'agrandira pour accueillir
tous ses onglets. La désactivation des onglets visibles
masquera l'intégralité de la barre d'onglets. Les onglets existent toujours et
peuvent être utilisés via un script, mais le joueur ne
pourra pas cliquer dessus. Tous les onglets situés à l'avant peuvent
être utilisés pour dessiner tous vos onglets par-dessus le contenu
plutôt qu'en dessous. Je montrerai à quoi
cela ressemble plus tard. Si le glisser-déplacer est activé, le joueur peut cliquer
et faire glisser les onglets pour réorganiser leur position
dans la barre d'onglets Si ce paramètre est
activé, que plusieurs
conteneurs d'onglets
sont visibles et que vous souhaitez que le joueur
puisse cliquer sur des onglets et les
faire glisser d'un
conteneur à l'autre, vous pouvez configurer tous les conteneurs d'onglets pour qu'ils aient
les mêmes onglets et réorganisez
l'
ID de groupe pour autoriser ce
partage d'onglets Avec la valeur
par défaut négative un, les onglets ne seront pas autorisés à être déplacés vers un
autre conteneur d'onglets Lorsque la taille
minimale des onglets utilisés est désactivée, le conteneur d'onglets sera redimensionné pour s'adapter au contenu de
chaque onglet sélectionné En l'activant, chaque onglet
aura la taille
du plus grand onglet. Le mode de mise au point des onglets peut
être utilisé pour contrôler la
manière dont les onglets de la
barre d'onglets peuvent se concentrer, en utilisant par défaut les commandes de la souris
et du clavier Vous pouvez vous limiter
à autoriser uniquement clics de
souris pour mettre
l'accent sur la barre d'onglets.
Par conséquent, appuyer sur la
touche de tabulation du clavier ou les touches
fléchées ne permettra pas au joueur de passer au
focus sur la barre d'onglets. Mais si la barre d'onglets est
focalisée après un clic, les touches fléchées peuvent toujours être utilisées pour naviguer entre les onglets, ou aucune ne peut être utilisée pour
ne jamais permettre à la
barre d'onglets de saisir le focus. Le joueur pourra toujours
cliquer sur les onglets pour passer de l'un à l'autre, mais il ne pourra pas se concentrer. Les touches fléchées ne
seront
donc pas utilisées pour passer d'un onglet à l'autre. Si la désélection
est activée, la valeur de l'onglet
actuel peut être définie sur moins un pour que tous les
onglets soient désélectionnés Après avoir configuré les propriétés
de mon conteneur d'onglets, je vais le
faire étendre verticalement pour remplir l'espace
de ma fenêtre de jeu. En sélectionnant le nœud racine pour
voir l'éditeur de thème, ajoutons un conteneur
d'onglets au thème. À partir de la section des icônes, nous pouvons remplacer
les icônes utilisées pour
les boutons d'incrémentation et de décrémentation que le joueur utilise pour faire défiler les onglets
découpés et leurs
homologues surlignés qui
s'affichent lorsque le joueur passe la
souris dessus. Nous pouvons également modifier le marqueur de
dépôt qui sera affiché entre les onglets lors du
glisser-déposer d'un onglet, et l'icône de menu, si ce conteneur d'onglets a
reçu un menu contextuel, ainsi que son surlignage Dans la section des couleurs, nous pouvons fournir une
couleur de modulation pour le drop marker. Une couleur de contour de police et des couleurs de police pour chaque état
des onglets de la barre d'onglets. Avant de passer au
reste des options du thème, lançons le jeu et voyons
comment fonctionnent ces paramètres. Comme mes onglets sont découpés, nous pouvons cliquer sur
les boutons d'incrémentation et de décrémentation pour les
parcourir Je peux cliquer et faire glisser des
onglets pour les réorganiser, et le marqueur de dépôt est
dessiné et modulé pour indiquer où l'onglet sera positionné si je relâche
le bouton de la souris Aucune icône de menu n'est
affichée car n'a encore été
attribué à
ce conteneur d'onglets menu contextuel n'a encore été
attribué à
ce conteneur d'onglets. Je vais rétablir la
modulation du drop marker en blanc. Je vais maintenant supprimer les
onglets excédentaires dans mon conteneur d'onglets. Si nous ajoutons un menu contextuel en tant qu'
enfant du conteneur d'onglets, il ne générera pas de nouvel onglet, car le nœud du menu contextuel n'
est pas un nœud de contrôle. Je vais le placer en haut
du conteneur d'onglets pour
faciliter les choses. Et il suffit de mettre un élément dans le menu contextuel
qui dit « Bonjour, si nous attachons un script
au conteneur d'onglets, je ne garderai pas ce
script dans mon jeu Je le laisserai
donc dans le dossier de
ressources principal avec
le nom par défaut ». remplaçant la fonction ready, nous pouvons appeler la
fonction tab container set pop up, qui accepte une fenêtre
contextuelle comme argument Nous pouvons donc transmettre ce get child avec un
indice enfant de zéro, le premier enfant, le nœud du menu
contextuel. Ensuite, je vais passer au script du gestionnaire de
navires. Les onglets peuvent contenir non seulement
du texte mais également des icônes. Mais tout comme le menu contextuel, ils doivent être ajoutés
par le biais d'un script. Exportons donc une
variable qui sera l'icône des onglets du navire
sous forme de texture en deux D, que nous pourrons renseigner
dans l'inspecteur Ensuite, dans la fonction ready, sachant qu'il s'agit d'un
enfant direct du conteneur d'onglets, nous pouvons appeler Get parent pour référencer le
nœud parent de ce nœud. Appelez ensuite la fonction
du conteneur d'onglets, définissez l'icône de l'onglet, en acceptant le numéro d'index de l'onglet et la texture de l'icône
comme arguments. Je vais donc lui transmettre l'index numéro trois et la texture exportée. revenant à l'éditeur de thème
dans la section des constantes, nous pouvons donner à cette icône
une largeur maximale en pixels. Le nombre de pixels séparant l'icône du
texte de chaque onglet, la taille du contour de la police et nombre de pixels d'espace de marge ajoutés à chaque
extrémité de la barre d'onglets. Comme toujours, je vais
ignorer les paramètres de police et de taille de
police et utiliser
mes paramètres de thème par défaut. Dans la section style, nous pouvons modifier
la façon dont le conteneur d'onglets, barre d'onglets et les onglets sont tous dessinés. Je vais tous les définir avec des textures de boîte de style
différent. panneau est le fond
du conteneur d'onglets dans lequel l'enfant
actif sera dessiné. Il est généralement dessiné homogène avec le style d'onglet
sélectionné. Cette image a des coins arrondis, je vais
donc ajouter des
marges de texture de 16 pixels. Je vais le copier dans le
style de l'onglet sélectionné, mais je vais le rendre unique
car je ne veux pas que les onglets aient des
coins arrondis en bas. élargissant la section sous-région, puis en cliquant sur le bouton
Modifier la région, nous ne pouvons utiliser qu'une partie de l'image fournie pour
dessiner la boîte de style Avec le quadrillage,
je peux découper les 16 pixels inférieurs pour
supprimer les coins arrondis Maintenant, l'onglet sélectionné
semble être connecté
directement au panneau. Je vais également supprimer les marges de texture
inférieures. Cela déplacera le texte et l'icône vers le bas sur l'onglet sélectionné, faisant apparaître comme
s'ils se trouvaient au-dessus des autres. copiant ces deux éléments non sélectionnés
et en les rendant uniques, je remplacerai la
texture par une texture plus foncée, puis je rétablirai la marge de
texture inférieure en déplaçant le texte et l'icône vers le haut Répétez ensuite le processus pour
ajouter différentes textures pour Hard focus, puis désactivez-le. L'arrière-plan de la barre d'onglets peut
également être doté d'une boîte de style, je vais
donc utiliser une ombre. En lançant le jeu, nous
avons maintenant une barre d'onglets stylisée, et l'onglet navire
a même une icône de navire L'icône du menu est affichée
sur la droite, et nous pouvons cliquer dessus pour
faire apparaître un menu contextuel. Je n'ai pas
l'intention d'utiliser ce menu pour quoi que ce soit dans mon jeu,
donc je vais le supprimer. Supprimez le script
du conteneur d'onglets et supprimez-le des ressources de
mon projet. Si le design de vos onglets est très orné et que vous
leur
donnez des marges suffisamment grandes pour recouvrent le contenu
de l'onglet sélectionné, marges suffisamment grandes pour qu'elles
recouvrent le contenu
de l'onglet sélectionné,
tous les onglets dessinés
au premier plan peuvent être utilisés pour dessiner tous les onglets situés devant le contenu de l'onglet sélectionné Je vais rétablir ces modifications
telles qu'elles étaient. Nous avons maintenant plusieurs onglets entre
lesquels le joueur peut
passer d'un onglet à l'autre. Dans la section suivante, nous utiliserons d'autres nouveaux
nœuds de contrôle pour ajouter plus de mécanismes. Je vous verrai dans
la section suivante.
34. Arbre A: Bonjour, mes amis. Dans
la section précédente, nous avons autorisé le joueur
à gérer son vaisseau. Dans cette section, nous autoriserons le joueur à gérer son équipage. passant à l'onglet équipage, je vais ajouter
à cet onglet une structure de
nœuds similaire En passant à l'onglet équipage,
je vais ajouter
à cet onglet une structure de
nœuds similaire à celle de l'onglet navire, commençant par un conteneur
divisé horizontalement contenant deux
boîtes verticales, l'une pour l'équipage que le
joueur possède actuellement et l'autre pour
les personnes qu'il peut engager, les deux s'étendant horizontalement et remplissant l'espace verticalement. Ensuite, sur le côté gauche,
j'ajouterai un nouveau nœud appelé arbre et je ferai en sorte que l'arbre s'étende pour remplir
l'espace verticalement. Si nous sélectionnons le nœud racine et jetons un coup d'œil à
l'éditeur de thème, nous pouvons voir une arborescence
remplie de différents
types d'éléments d'arborescence,
notamment du
texte brut, du texte modifiable,
une case à cocher, une case à roulettes
et une liste d'
options remplie de différents
types d'éléments d'arborescence, notamment du
texte brut, du texte modifiable, une case à cocher, une case à roulettes et une liste d' Les trois derniers sont également triés en tant qu'enfants d'
un autre élément de l'arbre. Une barre de défilement
peut être utilisée pour faire défiler les éléments de l'arbre si celui-ci est plus
haut que la zone allouée Les éléments de l'arbre parent
peuvent être réduits ou étendus pour masquer ou
montrer leurs enfants. J'ai pensé que ce serait
une bonne façon de représenter la chaîne de commandement pour les membres de l'équipage de
mon navire. Si vous sélectionnez à nouveau l'arbre, il n'est pas possible de le remplir
avec des éléments de l'arbre à partir d'ici Cela doit se faire
par le biais d'un script. En reconnaissant
que l'arbre des scènes fonctionne de
la même manière dans l'onglet
scène de l'éditeur Gudo, je peux recréer exactement ce que je veux dans mon arbre à
l'aide de nœuds de base Au sommet de la
hiérarchie se trouve le capitaine, suivi du premier officier, du deuxième officier
et du troisième officier. Autrefois, ils avaient peut-être
aussi un quatrième compagnon. Je peux réorganiser ces nœuds pour que le premier compagnon ait
autorité sur les deuxième, troisième et quatrième amis et ajouter d'autres enfants
à chacun d'eux. Le second officier est
chargé de la navigation aura
donc sous ses ordres un
navigateur, un timonier, un
Brelman, un matelot et des marins Le troisième officier est chargé
de la sécurité et du combat aura
donc sous ses ordres le maître d'
équipage ou le maître d'équipage, un constructeur de bateaux en anglais
moderne,
un
charpentier, un chirurgien et un artilleur constructeur de bateaux en anglais
moderne,
un
charpentier, un chirurgien et un artilleur Enfin, le quatrième
officier, s'il y en avait un, serait chargé de la
logistique et des ressources commanderait
donc le
cuisinier, le boucher et le commissaire de bord. Il se peut également que je
veuille autoriser les passagers payants à
bord du navire. En joignant un script
à l'onglet Équipage, j'exporterai une icône correspondante, remplirai avec l'icône de l'
équipage de mon jeu et je le définirai comme icône de l'onglet
Conteneurs de l'onglet pour cet onglet dans la fonction Prêt la même manière que pour l'onglet Navire Ensuite, je vais prendre une référence
au nœud de l'arbre. Écrivons une fonction qui
ajoute un élément à l'arbre. Nous pouvons ajouter un élément
à l'arbre en appelant sa fonction
create item, qui accepte des
arguments facultatifs pour le parent de l'élément en cours de création et
le numéro d'index enfant. En ignorant ces
arguments, cet élément sera créé en tant que
racine de l'arbre. Si nous voulons changer
quoi que ce soit à propos de cet élément, nous devons stocker une
référence à celui-ci dans une variable de type tree item. Je vais le nommer nouvel article. Ensuite, nous pouvons appeler la fonction
set text sur cet élément d'arbre nouvellement créé, qui nécessite un
numéro de colonne et des arguments de texte. L'arbre
ne comporte actuellement qu'une seule colonne, donc l'index de colonne est nul, et je vais mettre le
texte sur lequel je veux
le définir en tant que paramètre
de la fonction. Sachant que je vais
avoir beaucoup d'éléments de l'arborescence, je les stockerai dans un dictionnaire, puis j'assignerai à l'élément de l'arbre
situé à l'index du texte le nouvel élément. Maintenant, pour ajouter le
capitaine à l'arbre, il ne me
reste plus qu'à
appeler ma fonction en passant le nom du nœud enfant supérieur de l'
arbre. Si je veux ajouter le reste à
l'arborescence,
je dois également spécifier l' élément de
l'arbre parent lors de l'
appel à create item, afin que cela puisse être un autre
paramètre de la fonction. Lorsque vous appelez cette
fonction pour le capitaine, l'
élément de l'arbre parent sera nul. Je dois maintenant parcourir la hiérarchie que j'ai
construite dans mon arbre de scène, ajoutant chaque élément à l'arbre
avec le bon parent,
ce qui semble compliqué, ce qui semble compliqué, mais peut être simplifié
en utilisant la récursivité, c'est-à-dire une fonction
qui s'appelle elle-même Pour rendre les choses encore plus simples, je vais séparer la
logique récursive de ajout d'un élément d'arbre et le
faire dans une fonction distincte, que je nommerai populate Le premier paramètre
de cette fonction sera le
nœud actuel dans l'arbre de scène, et j'aurai également besoin de connaître l'élément de l'arbre parent
s'il en existe un. Je peux ensuite appeler la fonction d'élément d'
arborescence AD, en spécifiant le nom
du nœud sous forme texte et en transmettant
l'élément d'arborescence parent. Je vais ensuite le stocker dans une variable locale en le renvoyant à partir de la fonction d'
élément AdTree En utilisant une boucle à quatre pour parcourir tous les enfants de ce
nœud, nous pouvons simplement appeler à nouveau cette fonction d'arbre de
peuplement sur le nœud enfant et lui donner l'élément d'arbre parent généré
à partir du nœud actuel Si le nœud actuel n'
a pas d'enfant, ces quatre boucles ne s'exécuteront pas. La fonction Ready doit uniquement
lancer ce processus, commençant par le nœud enfant supérieur de l'
arbre et aucun élément de l'arbre parent. Au cours du jeu, l'
arbre est rempli avec la
structure de nœuds exacte de Mycin Tree Chaque élément de l'
arborescence peut être sélectionné et les éléments parents peuvent être
réduits ou développés. Sélectionnons le nœud de l'
arbre et examinons ses propriétés
dans l'inspecteur. Les colonnes peuvent ajouter des
colonnes supplémentaires à l'arborescence, en donnant à chaque élément de l'arborescence plusieurs entrées de texte,
une pour chaque colonne. Mon arbre comportera trois
colonnes pour
afficher les rôles, les noms et les salaires. Les titres des colonnes sont
masqués par défaut, mais peuvent être rendus visibles à l'
aide de cette case à cocher. Autoriser la resélection émettra à nouveau
le signal sélectionné si le joueur clique sur
l'élément sélectionné, et nous pouvons changer si le bouton droit de
la souris peut
être utilisé pour sélectionner des éléments ou non bouton droit de
la souris peut
être utilisé pour sélectionner des éléments Autoriser la recherche permettra au joueur parcourir les
éléments de l'arborescence en les tapant, faisant correspondre le texte de chaque élément. Masquer le pliage masquera les
flèches de réduction ou d'expansion, et l'activation du pliage récursif permettra au joueur de maintenir
la touche Shift enfoncée pour agrandir ou réduire les enfants de manière
récursive Masquer la racine masquera
l'élément de l'arbre racine. Dans mon cas, ce
serait le capitaine. Les drapeaux du mode drop
peuvent modifier
la façon dont le joueur glisse et
dépose les données dans l'arborescence, mais cela dépasse le
cadre de ce cours mode de sélection peut changer si le joueur sélectionne
un seul élément, plusieurs éléments ou
une rangée de l'arbre. défilement horizontal et
vertical peut également être activé ou désactivé Maintenant que plusieurs colonnes
et titres sont visibles, je vais ajouter des titres à
chacune de mes colonnes en appelant la fonction de définition du titre de
colonne de l'arbre. Ensuite, définissez également la dernière
colonne pour qu'elle ne s'étende pas. Les colonnes de rôle et de
nom
occuperont donc la majeure partie
de l'espace de l'arborescence. Après avoir saisi une référence
au menu contextuel des fichiers, nous devons connecter
le signal de réinitialisation du fichier au script
du chef d'équipe pour réagir au
démarrage d'une nouvelle partie ou au chargement
de la partie par le joueur , puis remplir deux colonnes restantes de
l'arborescence avec
le
nom de son équipage et ses taux de rémunération Comme les éléments de l'arbre sont
stockés dans un dictionnaire, il serait judicieux de
stocker également les données de l'équipage du joueur dans
un dictionnaire correspondant. Pour l'instant, je vais simplement initialiser
ce dictionnaire pour qu'il
contienne déjà un équipage réduit pour le navire, à
commencer par le capitaine Chaque membre de l'équipage a besoin de
plusieurs informations, qui
peuvent être stockées
dans un autre dictionnaire, donnant au capitaine
un nom par défaut et un taux de rémunération de zéro or. Ensuite, j'ajouterai un navigateur, un timonier, un matelot et un marin,
chacun ayant un nom et un Dans le script du gestionnaire d'équipe, lorsque le fichier est réinitialisé, nous pouvons remplir l'arborescence avec les membres de
l'équipage du joueur, mais nous pouvons également avoir besoin d'
effacer ceux qui s'y
trouvent déjà En parcourant
chaque rôle de l'arbre, nous vérifierons si l'
équipage du joueur joue ce rôle Appelez ensuite une autre fonction, en spécifiant l'
élément de l'arbre que vous modifiez, ainsi que le nom et le
taux de rémunération
auxquels nous les changeons , avec des valeurs vides au cas où le joueur
n'aurait pas ce rôle. écrivant cette fonction, en
acceptant les mêmes paramètres, nous pouvons simplement définir le
texte de l'élément de
l'arbre dans les autres colonnes
comme étant les valeurs transmises. Désormais, l'arbre est automatiquement renseigné avec les noms et les taux de
rémunération de l'équipage du joueur, mais j'aimerais que le salaire du
capitaine soit vide et que son
nom soit modifiable Définir l'
élément des racines de l'arbre pour qu'il soit modifiable dans la première colonne est assez
simple avec un appel de fonction Ensuite, lors de la saisie
d'un membre de l'équipe, je ne définirai le texte de la deuxième colonne que si l'
élément n'est pas l'élément racine En connectant le
signal modifié par l'objet au script du
chef d'équipe, nous pouvons réagir lorsque le joueur
modifie le nom de son capitaine. Cela ne
nous fournit aucun argument, mais ils sont stockés
dans la classe tree et peuvent être récupérés
avec les fonctions get. Dans le cas de mon arbre, un
seul élément de l'arbre est modifiable Je n'ai
donc pas vraiment besoin de
savoir autre chose que ce que le joueur a saisi
pour le nom du capitaine S'il n'est pas vide, je changerai le nom du capitaine dans
les données de sauvegarde du joueur. Ou s'il est vide,
rétablissez la valeur de l'élément
de l'arborescence Cela fonctionne tant que
chaque rôle est unique, mais je souhaiterais peut-être
avoir des rôles avec plusieurs membres d'équipe. Dans ces cas, je vais
changer la valeur stockée dans mes données
de sauvegarde d'un dictionnaire
décrivant un membre de l'équipe à un ensemble de dictionnaires décrivant
une liste de membres de l'équipe Je vais donner au joueur
plusieurs marins et hommes de
haut niveau pour gérer les
opérations de navigation de base du navire, chacun portant un nom unique, mais je laisserai
leur salaire le même car mon navire est syndiqué De retour dans le
script du chef d'équipe, lors de la création de l'arbre, je dois ajouter
autant d'éléments d'arborescence que le nombre maximum de rôles
dupliqués
possible,
ce que j'indiquerai
dans l'arborescence des scènes en
ajoutant un X suivi d'un chiffre
au nom du rôle. Ensuite, lors du remplissage de l'arbre, je rechercherai la lettre X dans le nom
du nœud et je l'
enregistrerai dans une variable Si la lettre X n'est pas
trouvée, le résultat sera négatif
un. déclarant de nouvelles variables pour le rôle et la quantité
de ce rôle, le rôle étant par défaut
le nom du nœud et la quantité
par défaut un,
si X est trouvé, je peux
analyser ces valeurs à si X est trouvé, je peux partir du nom du nœud à l'aide
de la fonction
de sous-chaîne,
le rôle étant situé
avant X et la avant X Appelez ensuite l'élément Ad tree
avec les variables. L'ajout d'un élément d'arbre nécessitera un
nouveau paramètre de quantité, et si la
quantité est supérieure à un
, l'entrée du dictionnaire pour cet élément d'arbre devra
être un tableau d'éléments d'arbre, peu comme le dictionnaire d'équipage. La création de l'
arbre peut ensuite être enroulée dans une boucle à quatre boucles
comptant jusqu'à la quantité. Et selon que la quantité est égale ou
non à une, définissez l'entrée du
dictionnaire pour l'article ou ajoutez-la
au tableau d'articles je ne veux pas un tas de Cependant, je ne veux pas un tas de rôles
vides et répétés
dans l'arborescence Je vais
donc régler la
visibilité des éléments de l'arbre pour qu'elle ne soit
vraie que pour le premier, puis fausse pour le reste. Lorsque le
signal de réinitialisation du fichier est reçu, code
différent
devra être exécuté selon que
le rôle est un tableau ou non. S'il s'agit d'un tableau et que
le joueur a ce rôle
dans son dictionnaire d'équipage, la quantité de ce rôle sera égale à la taille du tableau. Passer en revue tous
les rôles
disponibles dans l'arborescence Si I est inférieur à la quantité, alors l'élément de l'arbre
au rôle d'index I peut être renseigné avec les données de l'équipage du joueur
aux mêmes indices. Dans le cas contraire, ils seront vides. Et la visibilité de l'article
peut également être définie sur true si I est égal à zéro ou si I
est inférieur à la quantité. Ainsi, au moins un de
chaque rôle
sera toujours affiché même si le
joueur ne l'a pas encore. cours de jeu, nous pouvons
constater que le joueur dispose désormais plusieurs membres d'équipage assignés aux principaux rôles d'hommes et de marins Nous avons maintenant un nœud
arborescent affichant l'équipage du joueur. Dans la leçon suivante,
nous allons passer en revue les options de thème disponibles
pour le nœud d'arborescence. Je te verrai dans la prochaine leçon.
35. Arbre B: Bonjour, mes amis. Dans
la leçon précédente, nous avons utilisé un arbre pour afficher
l'équipage du joueur. Dans cette leçon, nous allons explorer
les options de thème disponibles
pour le nœud de l'arborescence. Avant cela,
je vais changer
ce paramètre de nom en nom d' équipage pour me
débarrasser de l'avertissement. Une fois le nœud racine sélectionné, ajoutons le nœud
arborescent au thème du jeu. À partir de la section
constante, nous pouvons définir
si les lignes horizontales
séparant chaque élément de l'arbre seront dessinées en modifiant la propriété du guide de dessin
à zéro ou non à zéro. La même chose peut être faite pour les
lignes de relation qui montrent les relations parent-enfant plus clairement
les relations parent-enfant
des éléments de l'arbre. La
largeur de la ligne de relation peut être modifiée ici. Et nous pouvons fournir différentes largeurs de ligne de
relation pour les lignes de relation
enfant
ainsi que pour les lignes de
relation parent Nous pouvons également séparer la ligne de relation
parent des lignes de relation sœurs
non sélectionnées en ajoutant une marge en pixels La séparation horizontale correspond aux pixels d'espace entre les
colonnes de l'arbre, ainsi qu'au côté gauche de l'arbre si le pliage est désactivé. Les cellules des éléments de l'arbre
peuvent se voir attribuer
des pixels d'espace de marge dans
les quatre directions. La marge des articles fournira également une indentation
supplémentaire à gauche
des articles des arbres taille du contour est le contour de la police que nous connaissons très bien
à l'heure actuelle. bordure de
défilement et la vitesse de défilement servent uniquement à
modifier le comportement du défilement par glisser-déposer,
et non le comportement
naturel de la barre de défilement. Nous ne les utiliserons
donc pas Nous pouvons ajouter une séparation horizontale des
pixels entre les éléments de l'arborescence et
la barre de défilement verticale, ainsi qu'une séparation verticale des
pixels
par rapport à la
barre de défilement horizontale s'il y en a une. Et nous pouvons également donner des marges aux
barres de défilement. La séparation verticale
ajoute une séparation des pixels entre chaque élément de l'arbre. Les éléments de l'arborescence peuvent contenir
plusieurs boutons, et nous pouvons utiliser cette
propriété pour modifier la séparation horizontale
entre les boutons. largeur maximale des icônes peut
être utilisée pour limiter la taille des icônes
fournies pour les éléments de l'arborescence, et leur hauteur sera
automatiquement ajustée pour conserver
leur rapport hauteur/largeur. Je vais exporter une autre icône depuis mon script de chef d'équipe et l'ajouter à la racine de
l'arbre dans la première colonne, afin que le joueur puisse
clairement voir
qu'il est autorisé à modifier le nom de
son capitaine. En cours de jeu, le nom du
capitaine
comporte désormais une icône indiquant
au joueur qu'
il peut être modifié. De retour dans l'éditeur de thème,
dans la section des couleurs, il existe des couleurs de police pour le texte
par défaut des éléments de l'arborescence, du texte de police
désactivé lorsqu' un élément de l'arborescence est modifiable
ou une case à cocher, mais également contour de
la police,
la couleur de police des éléments de l'arborescence
sélectionnés,
ainsi que les couleurs de police du
titre de colonne Nous pouvons changer la couleur
des directives ici, et nous pouvons également changer la couleur des
lignes de relation et avoir couleurs
différentes pour les lignes de
relation enfant et de
relation parent. couleur de la position de dépôt
est la couleur utilisée pour indiquer l'endroit où
les éléments déplacés seront déposés, et la mise en surbrillance de la
police des boutons personnalisée
n'est utilisée que pour les boutons personnalisés lorsque la
souris passe dessus Nous n'utiliserons aucune
de ces options. Il existe différentes options de
police et de taille de police pour les éléments de l'arborescence et
les titres des colonnes, mais je continuerai à utiliser les paramètres par défaut de mon
thème pour ceux-ci Dans la section des icônes, nous pouvons modifier l'apparence des flèches d'extension
et de réduction, ainsi que les cases à cocher lorsqu'
elles sont cochées ou décochées, activées ou
désactivées, ainsi que les
états indéterminés Utile pour que les parents traitent les éléments contenant des listes de
cases à cocher comme des enfants Le parent peut donc afficher
la case
à cocher indéterminée pour indiquer que certains enfants sont cochés, mais pas tous Ce comportement n'est
cependant pas automatique et doit être écrit par script. L'
icône en forme de flèche de sélection est dessinée pour indiquer les boutons d'option
qui affichent un menu contextuel, et l'icône Upwn est utilisée pour les cases de
rotation qui modifient
les nombres compris dans une plage Le joueur pourra
cliquer sur la flèche vers le haut pour augmenter ou sur la
flèche vers le bas pour diminuer la valeur. Pour créer ces différents types d'objets d'arbre interactifs, je vais accéder à ma fonction de remplissage des
membres d'équipage. Ensuite, j'appellerai la fonction
set cell mode sur la deuxième colonne, qui est la colonne de paiement, et je
changerai de mode pour vérifier. Si la valeur du
salaire n'est pas vide, je définirai sa
propriété modifiable sur true Sinon, je le mettrai sur false. Nous pouvons maintenant voir que les trois
éléments de la colonne des salaires sont des
cases à cocher et qu'ils ne sont activés que si le joueur a un
membre d'équipage pour ce rôle L'icône du mode cellulaire
n'affichera qu'une icône sans texte, et le mode personnalisé peut être utilisé pour créer des boutons personnalisés, mais
nous ne le ferons pas. Si nous le définissons en mode plage, nous pouvons l'utiliser soit
pour créer un bouton d'option en fournissant
une liste d'
options séparées par des virgules en tant que propriété de texte, soit une plage numérique qui peut
être modifiée sous forme de spinbox Nous pouvons configurer les propriétés de la plage de spin
box en appelant set range config, en fournissant la colonne, la valeur
minimale, la valeur
maximale et la valeur de l'étape, et définir la valeur actuelle
en appelant set range, en fournissant la colonne et
la valeur sous forme de flottant. Cependant, si la valeur du salaire
est vide, je changerai le
mode cellule en chaîne et je l'
afficherai simplement sous forme de texte
vide non modifiable cours du jeu, le joueur peut modifier le taux
de rémunération des membres de son équipage fourchette allant de une
à neuf pièces d'or par jour, par étapes d'
une pièce par clic. Cette interaction
émettra également le signal d'
édition des éléments de l'arborescence. Je vais donc devoir vérifier si
l'élément modifié est l'élément racine de l'arbre avant de
modifier le nom du capitaine. Je vais également devoir écrire un code
supplémentaire pour modifier le taux de rémunération du membre de l'équipage dans les données de sauvegarde du joueur ici. Sans connaître le
rôle ou l'index du membre de l'équipe
dont le salaire a été modifié, je ne
peux pas faire grand-chose d'autre que de les parcourir tous
et de vérifier lequel il s'agit Donc, en parcourant
tous les éléments de l'arbre, je vais d'abord vérifier s'il s'agit
d'un tableau S'il ne s'agit pas d'un tableau et que c'est
l'élément qui a été modifié, je vais définir le
salaire de ce rôle la nouvelle valeur de plage,
convertie en un entier. Si le rôle est un tableau, je devrai parcourir ce tableau jusqu'à ce
que je trouve
celui qui a été modifié, me donnant
maintenant l'index du tableau, je peux utiliser
pour définir le salaire du membre de l'équipe occupant ce rôle
et le numéro d'index du tableau. De retour dans l'éditeur de thème,
dans la section style, nous pouvons modifier le
panneau de boîte de style dessiné derrière l'arbre. Je vais juste utiliser une boîte de
style vide pour l'ignorer. Ainsi que le style de mise au point, qui sera dessiné sur l' ensemble de l'arbre lorsqu'il sera focalisé, que je supprimerai également en le
mettant sur vide. Nous pouvons modifier les
cases de style des boutons de titre
normalement lorsque vous les survolez
et que vous appuyez dessus Je ne veux pas que mes titres
agissent comme des boutons Je vais
donc également utiliser des boîtes de
style vides pour ceux-ci. La seule zone de style que
je souhaite utiliser pour mon arbre sera celle où un élément de l'
arbre est sélectionné. Je vais donc le mettre à plat dans
une boîte de style, lui donner une couleur foncée
avec des coins arrondis et le copier dans la
zone de style pour le focus sélectionné Le nœud de l'arborescence peut automatiquement inclure des barres de défilement horizontales et
verticales, nous pouvons
donc également les
ajouter au thème Dans la section des icônes, nous pouvons fournir des icônes
pour l'incrémentation et la décrémentation dans les états de
surbrillance et de pression normaux N'oubliez pas qu'avec
la barre de défilement verticale, l'incrément est celui qui
pointe vers le bas Je ne souhaite pas inclure ces
boutons dans mes barres de défilement, mais je souhaite les utiliser pour définir la zone cliquable de la souris. Je vais donc les ajouter sous forme de textures d'
espace réservé et leur donner une largeur de
huit pixels, mais pas de hauteur Par conséquent, rien ne
sera dessiné par eux. Ensuite, dans la section style, je peux définir la
zone de style de défilement sur une boîte de style plate. Faites-en une ligne noire très
étroite en ajoutant une bordure invisible
sur les côtés gauche et droit. Je vais ensuite le copier également dans
le style de focus. Pour le grabber, je vais le
faire de la même couleur que mes boutons avec des
coins arrondis et une ombre En copiant cela dans les deux
autres styles, je vais ensuite les rendre uniques, définissant la couleur du
surlignage plus claire et celle de la couleur pressée plus foncée. Toutes ces mêmes
options sont également disponibles pour la barre de
défilement horizontale. Nous avons maintenant le
thème de notre nœud arborescent qui correspond à l'esthétique de notre
jeu. Dans la prochaine leçon, nous autoriserons le joueur à engager et à
licencier des membres d'équipage. Je te verrai dans la prochaine leçon.
36. Conteneur de défilement: Bonjour, mes amis. Dans
la leçon précédente, nous avons exploré les options de thématisation disponibles pour le nœud de l'arborescence Dans cette leçon, nous allons permettre au joueur d'engager et de
licencier des membres d'équipage. Je vais commencer par ajouter un bouton
sous le nœud de l'arbre qui indique « feu » et le réduire horizontalement vers
le centre. Connectez ensuite son signal pressé au script du chef d'équipe. Nous pouvons demander quel
élément est sélectionné le nœud
de l'arbre et le
stocker dans une variable. Si rien n'a été sélectionné, ou si l'
élément sélectionné est le capitaine, qui dans mon jeu représente
le joueur lui-même, alors appuyer sur le bouton de tir
ne devrait rien faire. Donc, si quelque chose
d'autre que le capitaine a été sélectionné, j'obtiendrai le rôle
sélectionné sous forme texte dans
la colonne zéro de
l'élément de l'arbre sélectionné. Ensuite, divisez ma logique selon que le rôle autorise
plusieurs personnes, soit en effaçant le rôle de l'équipage du joueur, soit vérifiant si la taille
de l'équipe affectée à ce rôle
n'est pas nulle avant de supprimer la personne au même indice que
l'index du tableau de l'élément d'arbre
sélectionné Cela n'est nécessaire
que parce
que le rôle est toujours représenté par
une entrée vide, même si personne
n'est assigné
à ce rôle au joueur . Après avoir renvoyé le membre de l'équipage, je peux simplement faire appel à la réinitialisation du
fichier pour mettre à jour l'arbre d'équipage avec les nouvelles
informations. Essayons-le. Nous pouvons virer n'importe quel membre de l'
équipage sauf le capitaine. Tenter de déclencher des
entrées vides ne sert à rien. Dans le script de sauvegarde des données, je vais supprimer l'
équipage initial à
l'exception du capitaine et initialiser
les tableaux comme étant vides Ensuite, je dois
générer une liste de personnes à la recherche d'un travail
que le joueur peut engager. Je vais donc ajouter un conteneur quadrillé le côté droit de ce panneau et un bouton en dessous qui indique louer, rétrécir horizontalement au
centre ». Je vais faire agrandir le
conteneur quadrillé pour remplir l'espace à la fois horizontalement
et verticalement. donnant trois colonnes au
conteneur de la grille, j'ajouterai deux nœuds d'étiquette et une texture rect comme en-têtes
de colonne Nommez-les et
remplissez-les avec leur rôle, nom et l'icône « Ma pièce Je vais
agrandir les étiquettes
des rôles et des noms pour occuper
le plus d'espace possible, en la
colonne
des salaires jusqu'à la fin Je vais devoir écrire
un script qui
remplira cette grille avec des candidats
potentiels Mais d'abord, je ne veux pas être limité par l'
espace disponible ici. J'aurai besoin de barres de défilement
comme celles de l'arbre. Le nœud arborescent inclut
le défilement automatique. Mais si je veux que mon
conteneur de grille soit défilant, je dois ajouter un autre
nœud, un conteneur de défilement Le conteneur de défilement
ne peut avoir qu'un seul nœud enfant, qu'il clipsera pour qu'il s'insère dans son rectangle de contrôle et fournira des barres de défilement si
l'enfant ne rentre pas, que je développerai pour
remplir l'espace prévu. Nous pouvons voir les effets du conteneur
de défilement en dupliquant plusieurs fois les
nœuds enfants,
afin qu'ils ne soient plus ajustés verticalement et en
continuant
à ajouter du afin qu'ils ne soient plus ajustés verticalement et en
continuant
à texte jusqu'à ce qu'il ne soit
plus ajusté En sélectionnant le nœud du
conteneur de défilement, examinons ses
propriétés dans l'inspecteur. Follow Focus indiquera au conteneur de défilement d'ajuster
automatiquement position
du défilement pour que
le nœud de contrôle de la mise au point reste visible à tout moment. Le mode de défilement horizontal et
vertical comporte plusieurs options. L'option par défaut automatique n'affiche la
barre de défilement que lorsque cela est nécessaire, mais nous pouvons
la modifier pour
qu'elle soit toujours affichée ou pour ne jamais l'afficher, soit pour la désactiver Nous allons étendre le conteneur de
défilement pour qu'il intègre son nœud enfant
dans cette dimension, éliminant ainsi le besoin de
faire défiler la page. Une zone morte peut
être ajoutée au
défilement tactile pour ajuster
sa sensibilité élargissant la section de défilement, nous pouvons modifier la position de défilement par
défaut horizontalement
ou
verticalement par pixel, ainsi que modifier l'
incrémentation ou la décrémentation des étapes, ce qui déplacera la position du
défilement lorsque le joueur
clique sur ces boutons J'ai supprimé les boutons d'incrémentation et de décrémentation de
mon thème de barre de défilement Je suis maintenant prêt à
remplir cette grille avec membres d'équipage
potentiels qui attendent
d' être embauchés par le joueur Je vais centrer le texte dans les en-têtes de
mes colonnes pour éviter qu'il ne soit découpé
par le conteneur de défilement Je vais donc connecter le signal des boutons
de location au script du chef
d'équipe. Tout d'abord, je vais prendre une référence
au nœud du conteneur de la grille. J'aurai également besoin de connaître tous les rôles
possibles
qui peuvent être embauchés, je stockerai dans un tableau, et une liste de toutes les personnes que je générerai
au hasard, que je stockerai également
dans un autre tableau. Ensuite, après avoir généré
l'arbre d'équipage, définissez les
rôles possibles comme étant le tableau de clés du dictionnaire des
éléments de l'arbre, en retirant le capitaine et le passager des rôles potentiels
pouvant être embauchés. J'appellerai ensuite une
autre fonction pour remplir la grille supérieure La première chose que je
ferai en remplissant
la grille supérieure est d'effacer son contenu avec
une autre fonction Une fois cela fait, je vais
répéter un certain nombre de fois, disons 15, et ajouter une nouvelle personne à la liste
des personnes à la recherche d'un emploi Cette entrée du tableau
sera un dictionnaire
contenant un rôle, un nom et un taux de rémunération, le nom
et le taux de rémunération
étant des nœuds d'étiquette, initialisant avec
leur nom de classe point neu Le rôle sera une case à cocher, qui est un autre nœud qui
hérite du bouton De cette façon, le joueur peut cocher
les cases de toutes les personnes qu'il souhaite embaucher
avant de cliquer sur le bouton d'embauche pour les
embaucher toutes en même temps Ces trois nœuds ont une propriété de texte qui
doit être renseignée. Je vais simplement leur
donner des valeurs aléatoires, commençant par le rôle étant une sélection aléatoire
parmi les rôles possibles. Je vais choisir un nom
aléatoire dans un tableau constant de chaînes de la même manière
que je l'ai fait pour les noms de navires, fournissant une longue liste de noms
potentiels
dans mon script dans une balise de région que je peux réduire pour éviter que cela
ne gêne. Pour leur rémunération, je vais simplement utiliser un entier aléatoire de 1 à 9
converti en chaîne Les trois nœuds peuvent être ajoutés à la grille supérieure en tant qu'enfants. effacer la grille,
il suffit de parcourir le
tableau des personnes qui
cherchent du travail, d'
appeler Q gratuitement pour les trois entrées
de leur dictionnaire,
puis de vider le tableau Si nous l'exécutons maintenant, la case à
cocher n'a pas de thème et elle hérite de ses
propriétés de thème du bouton Ajoutons donc une case à cocher au thème
du jeu et
lui donnons un aspect plus approprié À partir de la section des styles, les cases à
cocher ont toutes le
même style que les boutons, que je supprimerai en
les réglant toutes sur la case de style vide. Ensuite, dans la section des icônes, en
plus de la même icône
héritée du bouton, icônes cochées
et non cochées sont activées et désactivées, ainsi qu'un ensemble de boutons
radio Comme toujours, je vais
laisser la police et taille de
police utiliser le paramètre de thème
par défaut. Les mêmes options de police et de
couleur d'icône sont également disponibles pour la case à cocher que pour le bouton Notez que les couleurs de
modulation des icônes s'appliquent
uniquement à la propriété de l'icône, et non aux cases à cocher ou
non cochées Dans la section constante, alignée sur la plus grande boîte de style que nous connaissons à ce jour, identique à la taille du contour
et à la largeur maximale de l'icône. Check vertical offset
décalera la position verticale icônes
des cases à cocher de
quelques pixels vers le haut ou vers le bas. La séparation horizontale
ajoute des pixels d' espace entre l'icône de la
case à cocher et son texte. Si la case à cocher comporte à la fois
une case à cocher et une icône, la séparation horizontale
sera appliquée aux Je vais supprimer l'icône
de ma case à cocher. Ça a l'air bien mieux.
Dans le script, lorsque le joueur clique
sur le bouton d'embauche, étant donné que mon jeu contient des
règles selon lesquelles il ne
faut pas avoir plusieurs personnes
dans le même rôle, je crée un tableau
de tous ceux qui ont été embauchés
avec succès et
une chaîne pour le rôle. Après avoir passé en revue les personnes qui
cherchent du travail, je vais ensuite
passer en revue toutes les personnes qui ont été
embauchées et je les
retirerai embauchées et je les
retirerai de la liste des personnes à la
recherche d'un emploi, puis je mettrai à jour l'arbre d'équipage Dans cette boucle for, je vais vérifier si la case à cocher du
rôle de la personne a été cochée
et, dans l'affirmative, définir le rôle comme étant
le texte de cette case à cocher Pour savoir si cette
personne peut être embauchée, la logique sera différente si le rôle autorise
plusieurs personnes ou non, ce que je sais selon
que l'entrée du
dictionnaire des éléments de l'arbre à l'index
de ce rôle est un tableau. En commençant par les rôles uniques, si le dictionnaire de sauvegarde des
données du joueur ne
contient pas ce rôle, je peux définir la valeur de
ce rôle comme étant cette personne, créant un dictionnaire contenant
son nom et son
taux de rémunération sous forme d'entier. Mais s'il s'agit d'un tableau, je devrai comparer
le nombre de personnes assignées à ce rôle dans l'équipage existant du joueur au nombre maximum autorisé. Et s'ils ont encore de la place, ajoutez cette nouvelle
personne au tableau Si le joueur
n'a plus
de place pour ce rôle ou si le
rôle unique est déjà rempli, je passe à la personne
suivante qui
cherche du travail. Si cette personne a été recrutée
avec succès, je libérerai tous les nœuds qui lui
sont associés
du décor et je
les ajouterai à la liste des
personnes embauchées Cela suffira pour permettre au joueur d'engager
ces membres d'équipage Les tentatives de recrutement de
membres d'équipage
déjà pourvus ou à pleine
capacité seront ignorées. Mais je pense qu'il est
important de renforcer la capacité maximale de l'équipage
du navire actuel du joueur. Je vais donc écrire une
fonction qui compte l'équipage actuel du joueur, en
renvoyant un entier, en parcourant chaque entrée du dictionnaire de l'équipage du joueur, si l'entrée est un tableau, en ajoutant la taille du tableau, sinon en ajoutant une entrée et en
renvoyant le résultat En cliquant sur
le bouton d'embauche, j'ajoute une variable
pour l'équipage maximum. Et à chaque itération ,
je vérifierai si le joueur a atteint la capacité de
son équipage et au
courant s'il l'a fait Je vais devoir récupérer
ces informations sur le vaisseau actuel du joueur. donnant à ces
onglets des noms uniques, je vais trouver une référence au gestionnaire
de navires
en utilisant Add on Ready. Et demandez au
joueur de limiter son équipage, en définissant le maximum comme
premier élément d'un tableau. Le script de gestion des navires a
ensuite besoin d'
une fonction
qui renvoie un tableau à deux nombres entiers indiquant
les limites d' équipage actuelles du joueur, renvoyant
simplement un tableau
de deux nombres contenant l'équipage minimum et l'équipage
maximum de
son navire actuel. Désormais, le joueur ne peut pas engager plus d'équipage que ne peut en contenir son navire
actuel. Le joueur peut désormais
gérer son équipage depuis cet onglet avec des
mécanismes d'embauche, d' ajustement des taux de rémunération et de
licenciement des membres d'équipage. Dans la section suivante, nous autoriserons le joueur à
naviguer vers un autre port. Je vous verrai dans
la section suivante.
37. Bouton radio: Bonjour, mes amis. Dans
la section précédente, nous avons autorisé le joueur
à gérer son équipage. Dans cette section, nous leur
fournirons une carte des différents ports entre
lesquels ils peuvent naviguer. Comme pour l'onglet équipage, je vais commencer par passer
à l'onglet carte, y ajouter un script, l' appeler le gestionnaire de cartes et l'enregistrer dans le dossier des scripts du
gestionnaire. Exportez ensuite une icône sous forme de
texture deux D et définissez-la comme icône de
cet onglet en appelant l'icône de définition d'onglet sur le parent de
ce nœud, le conteneur d'onglets, en passant
l'icône en argument et en remplissant l'
icône exportée d'une icône de carte Pour revenir à la vue en deux D, je vais commencer par ajouter un conteneur
vertical
à cet onglet, contenant un nœud
texturé, peuplé de la texture d'
une carte de la mer des Caraïbes, configuré pour s'ajuster proportionnellement
à sa largeur, conserver son rapport hauteur/largeur, étendre pour remplir
l'espace verticalement, et le réduire au
centre horizontalement Sur cette carte, je vais ajouter un nœud de contrôle à
utiliser comme dossier pour contenir tous mes ports et ancrer sur l'épave
complète de la carte Ensuite, je vais représenter chaque
port avec des cases à cocher, commençant par La Havane, Cuba ,
puis Kingston en Jamaïque,
Porto Prince Haïti et Saint-Domingue en
République dominicaine Ces cases à cocher sont
naturellement configurées en mode bascule, afin que le joueur puisse les
cocher ou les décocher, mais je veux qu'il ne puisse en cocher qu'une
à la fois, ce qui signifie qu'il doit s'
agir Nous pouvons créer des boutons radio en
cliquant sur le menu déroulant intitulé groupe de boutons et en
créant un nouveau groupe de boutons. Nous n'avons rien d'autre à
faire avec ce groupe de boutons que de enregistrer en tant que ressource de projet. Ensuite, assignez tous les boutons pour qu'ils utilisent également le
même groupe de boutons. Les boutons d'un
groupe de boutons utiliseront les icônes
des boutons radio au lieu des icônes des cases
à cocher, et un seul bouton d'un groupe pourra être activé
à la fois Je vais
désactiver le bouton Havana Cuba car ce sera le point de départ du
joueur. Ainsi, ils
auront le choix entre trois
choix pour leur
première destination. J'aimerais personnaliser
l'
apparence de ces boutons sans affecter les autres
cases à cocher de mon projet Je vais donc ajouter une nouvelle variante de
type de thème à mon thème, l'
appeler port et définir son type de
base sur case à cocher. Si un port est désactivé, qu'il
soit coché ou non, je mettrai son icône sur une ancre, car cela indiquera où se
trouve
actuellement le joueur. Un bouton radio non coché
sera une icône de vente, et un
bouton radio coché sera un X rouge, indiquant qu'il s'agit de la destination sélectionnée par le
joueur Je vais également réduire
la taille de police de ces boutons afin qu'ils n'
occupent pas autant d'
espace sur la carte. En sélectionnant tous mes
boutons de port dans l'arborescence de la scène, je les changerai tous pour utiliser la variante du type de thème des ports. Réinitialisez ensuite leurs
propriétés de taille pour qu'elles soient aussi petites que possible lorsqu'elles
contiennent leur texte. Pour éviter que le texte
de mon bouton ne se chevauche, je vais demander à
Kingston
et Portal Prince d'
inverser leur disposition de droite à gauche, afin que le texte apparaisse à
gauche de l'icône du bouton radio Pour garantir que les boutons restent dans les bonnes positions, même si la carte est
redimensionnée pour une quelconque raison, je vais les mettre en mode ancrage
à l'aide d'ancres
personnalisées et positionner
leurs points d'ancrage au
centre de leurs icônes de boutons ancres
personnalisées et positionner leurs points d'ancrage au
centre de leurs icônes de Je vais ensuite répéter cette opération
pour chacun de mes ports. En sélectionnant
l'un des boutons radio, en examinant ses signaux, il ne serait pas judicieux
de connecter chacun de ces signaux activés à une fonction différente du
script Cela compliquerait considérablement l'ajout de
ports supplémentaires. Mais notez que l'
argument transmis par le signal est un booléen
nommé toggled Dans le script du gestionnaire de cartes, nous pouvons réagir à l'activation de n'importe quel bouton avec
une seule fonction Déclarez d'abord
une variable contenant
le port actuel du joueur sous forme d'entier, qui sera naturellement égal à zéro
par défaut, et un autre pour
sa destination. Je vais lui donner une
valeur par défaut négative un, ce qui signifie
que le joueur
n'a pas sélectionné de destination. Nous pouvons ensuite écrire une fonction
pour définir la destination, acceptant d'
abord le paramètre activé
pour qu' corresponde
à l'argument transmis
par le signal Ajoutez ensuite un autre paramètre, l'ID de port du bouton sur
lequel vous avez appuyé. Si le bouton
est activé,
la destination
sera l'ID du port Si le bouton est
désactivé et que l'ID du port
est la destination, cela signifie que la destination
a été supprimée par le joueur et doit être remise à
un point négatif Pour connecter le
signal activé par les boutons à cette fonction, nous devons développer
la section avancée du dialogue de
connexion du signal Ici, nous pouvons ajouter des
arguments supplémentaires au signal. Le type d'argument que nous
souhaitons ajouter est un entier, et pour La Havane, je vais
laisser sa valeur à zéro. Nous pouvons ensuite revenir à la
liste des nœuds de la scène, sélectionner le nœud de la carte et choisir une fonction à appeler
en réaction à ce signal. La fonction appelée
doit avoir des paramètres dont les types correspondent à ceux
émis par le signal. Étant donné que ce signal
est devenu un
booléen et que nous
lions un entier supplémentaire, destination
définie doit avoir booléen
suivi d'un paramètre Nous pouvons ensuite répéter ce processus
pour chaque bouton radio, en remplaçant la valeur de l'argument
entier lié par une valeur différente. Pour simplifier, j'utiliserai numéro d'index enfant de
chaque bouton dans l'arborescence des scènes. De retour dans une vue en deux D, je vais également ajouter un
conteneur de marge au bas de la carte ancré dans
le bas de la carte et placer à l'intérieur de ce
conteneur de marge une étiquette
indiquant
la distance entre le port actuel du joueur sa destination, mesurée
en jours de navigation, et un bouton pour entreprendre son voyage rétrécir au bout
du conteneur de marge. Je noterai ensuite la position et taille du conteneur de marge et ajouterai un nœud coloré
car son frère, avec les mêmes ancres,
la même taille et la même position, est coloré en noir
semi-transparent L'image de la carte est très chargée, et l'ajout de cette
teinte ne fera que rendre l'étiquette et le bouton
plus visibles. L'étiquette sera invisible et le bouton
désactivé par défaut. De retour dans le script,
je vais récupérer les références
au gestionnaire de navires et à ces
deux nœuds en utilisant Add on Ready. Ensuite, définissez également un tableau
constant pour contenir les distances entre chacun de mes ports mesurées
en miles nautiques. En créant une matrice d'entiers, les
positions réflexes seront les mêmes si le port et la
destination actuels sont les mêmes, donc la distance serait nulle Et je vais simplement
remplir la matrice avec des valeurs réalistes pour la distance de navigation
en miles nautiques entre chacune de ces villes Les valeurs symétriques
doivent être les mêmes, en supposant que vous puissiez suivre le même chemin
dans les deux directions Ensuite, après avoir défini
la destination, si la destination est négative
ou si elle a la même valeur
que le port actuel, je masquerai l'étiquette de
distance et désactiverai le bouton d'embarquement. Sinon, je réglerai le texte de l'étiquette de distance sur
le nombre correct
de jours de navigation, puis j'activerai le bouton d'embarquement. Pour accéder aux données de sauvegarde du
joueur, j'ai besoin d'une référence
au nœud 2 du fichier. Pour calculer le nombre
de jours de navigation, je vais utiliser la fonction d'étanchéité, qui arrondit un flotteur à l'entier le
plus proche et divise la distance parcourue
en miles marins par la vitesse
actuelle du navire du joueur. Pour que cela fonctionne,
je vais devoir ajouter cette fonction
get speed au script
du gestionnaire de navires. Donc, en revenant à flot, je vais rendre les navires indexés par le numéro d'identification actuel du navire du
joueur Et comme je n'ai pas inclus de
valeur de vitesse pour mes ressources de navire, je vais ouvrir le script de
ressources de navire et exporter une autre variable
pour la vitesse du navire. Donnez-lui ensuite une valeur par défaut de 100 milles marins par jour. Je peux ensuite donner à chaque navire une vitesse
différente si je le souhaite, et le joueur
pourra effectuer ces voyages en
moins de jours de navigation. J'aimerais également que le
joueur puisse
désactiver sa destination en
cliquant à nouveau dessus, ce qui n'est pas autorisé par défaut Si nous double-cliquons
sur le groupe de boutons dans les ressources du projet, nous pouvons activer la propriété Autoriser la
presse pour adapter ce comportement. Essayons-le. Le joueur peut cliquer sur l'un
de ces
boutons radio sur la carte,
en le sélectionnant comme
destination. Le nombre de
jours sera mis à jour
et le bouton d' de ces
boutons radio sur la carte, en le sélectionnant comme
destination Le nombre de
jours sera mis à jour embarquement sera activé. Si nous appuyons sur le bouton qui
était déjà activé, nous pouvons également le désactiver Et comme il n'y a plus de destination, le nombre de jours est masqué et le bouton d'embarquement est désactivé. Nous avons maintenant une carte
avec plusieurs ports le joueur peut choisir
comme destination. Et la leçon suivante permettra au joueur de contrôler
l'ancre du navire. Je te verrai dans la prochaine leçon.
38. Bouton de vérification: Bonjour, mes amis. Dans
la leçon précédente, nous avons autorisé le joueur à sélectionner
une destination sur une carte. Dans cette leçon, nous allons les laisser
contrôler l'ancre du navire. Sous ma carte, le conteneur
vertical contiendra un conteneur horizontal
, figurera
un bouton à cocher qui sera utilisé pour
contrôler l'ancre du navire. Comme la case à cocher,
le bouton à cocher
hérite également de la plupart de ses propriétés du bouton,
y compris son thème En sélectionnant le bouton à cocher, examinons ses
propriétés dans l'inspecteur. Je vais commencer par supprimer les propriétés du thème de
style héritées du bouton en
cochant la case plate Nous pouvons ajouter du texte au
bouton de vérification et également une icône. J'utiliserai le texte pour indiquer
au joueur qu'il est utilisé pour contrôler l'ancre du navire. Comme les autres boutons, nous pouvons ajuster la façon dont le texte
et l'icône seront dessinés en fonction de la position du bouton de
vérification et de l'espace disponible. Ensuite, sélectionnons le nœud
racine pour voir l'éditeur de thème et ajouter le bouton
Vérifier au thème. Le bouton de vérification hérite de
nombreuses propriétés que nous
connaissons bien du bouton,
telles que les couleurs de police et d'icône Dans la section des constantes, nous pouvons tout aligner sur la plus grande boîte de style en la
réglant sur une valeur
autre que zéro. Ajoutez un décalage vertical
au bouton de vérification, séparation
horizontale
entre l'icône, bouton de
vérification et le texte. Définissez un plafond pour la
largeur maximale de l'icône. Et une
taille de contour pour le texte, ce que nous avons déjà fait
avec d'autres nœuds de contrôle. Comme toujours, je vais
laisser la police et la taille de
police comme valeurs par défaut du thème Dans la section des icônes, nous pouvons modifier l'apparence du
bouton de vérification lorsqu'il est coché, décoché ou désactivé, ainsi que fournir une icône qui sera utilisée pour tous les boutons à
cocher du projet, sauf si elle est remplacée par la l'icône des
boutons de vérification individuels Enfin, dans
la section style, nous avons tous les mêmes styles hérités
du bouton, que je vais supprimer en
les remplaçant tous par une boîte de style vide. En sélectionnant le nœud du bouton de vérification, mon bouton sera
enfoncé par défaut. Je vais renommer mon nœud
d'ancrage et le dossier des
ports avant de les
utiliser dans mon script Nous devrons répondre lorsque
le joueur clique sur le bouton de vérification en connectant
son signal à un script. Au lieu du signal que
nous
utiliserions normalement pour le bouton, nous devons savoir
si le bouton de vérification est activé ou désactivé Nous allons
donc connecter le signal
activé, qui transmet l'état activé du bouton
de vérification de En le connectant à mon script de gestionnaire de
cartes, je peux facilement réagir
au signal selon que le bouton de vérification
est activé ou non vérification
est activé ou passant au script de
sauvegarde des données, j'ajouterai la variable
ancrée is en
tant que booléen exporté et je lui donnerai
par défaut la valeur true Connectons également le signal de
réinitialisation du fichier au
script afin initialiser cet onglet avec les informations appropriées
issues des données de sauvegarde du joueur J'aurai besoin de références
à mon nœud d'ancrage et au tableau de nœuds
enfants dans mon dossier de ports. Tout ce que j'ai besoin de faire pour
l'ancre est de définir sa propriété pressée sur le bouton
pour qu'elle corresponde aux nouvelles données de sauvegarde. Je dois
également parcourir tous mes ports et définir leur propriété
désactivée pour qu'il
corresponde ou non au qu'il
corresponde ou non port actuel
du joueur et définir aucun d'
entre eux pour qu'il soit activé. Le bouton de vérification réagit au
survol et un clic
dessus pèse l'ancre Cliquez à nouveau dessus pour faire
tomber l'ancre. Nous avons maintenant un bouton de vérification
contrôlant l'ancre du navire. Dans la prochaine leçon, nous allons permettre au joueur de
contrôler les voiles Je te verrai dans la prochaine leçon.
39. Curseur vertical: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté un bouton de vérification qui
contrôle l'ancre du navire. Dans cette leçon, nous allons utiliser un curseur pour contrôler
les ventes du navire Je vais commencer par ajouter
un curseur vertical
au conteneur horizontal situé sous ma carte Contrairement au bouton à cocher, le curseur vertical ne
possède pas de propriétés de texte ou d'icône Je vais
donc également ajouter un nœud d'étiquette, que je
remplirai
avec le mot sales, afin qu'il corresponde au style
de mon contrôle d'ancrage Sélectionnons le nœud du curseur
vertical et examinons ses
propriétés dans l'inspecteur La case à cocher modifiable
déterminera si le joueur peut
ou non modifier la valeur de ce curseur,
et
le mode défilement indiquera
s'il peut le
faire à l'aide de la molette de la souris
tout en passant la souris sur le curseur Le nombre de tiques ajoutera des lignes
horizontales
au curseur pour indiquer les
segments, comme un thermomètre J'aurai trois
cases sur mon curseur, et la
case à cocher des bordures indiquera si la première et la dernière coche sont dessinées pour les valeurs maximale
et minimale Les propriétés de plage sont également
importantes pour ce nœud, nous
permettent de spécifier les valeurs minimale et maximale du curseur, ainsi que la mesure dans laquelle la
valeur du curseur peut changer à chaque étape Comme mon curseur est utilisé
pour contrôler les ventes de navires, il ne comportera que
trois valeurs possibles :
zéro, moitié ou un pour une vente complète Ces propriétés de plage sont
également utilisées par d'autres nœuds, comme la barre de défilement, qui
utilise la propriété de page, mais pas les curseurs. Nous pouvons donc l'ignorer valeur est la
valeur actuelle du curseur Nous pouvons
donc la modifier par défaut,
et
elle reprendra
automatiquement
les valeurs des étapes comprises entre
notre minimum et notre maximum édition exponentielle biaisera la valeur pour qu'elle soit exponentielle
plutôt que linéaire, mais uniquement si la
valeur minimale est supérieure arrondie est toujours arrondie La valeur arrondie est toujours arrondie à l'entier le
plus proche. Autoriser une valeur supérieure ou
inférieure permettra à
la valeur de dépasser les valeurs
minimale et maximale. Mais le curseur n'
indiquera pas que c'est le cas. Nous en apprendrons davantage sur ces propriétés dans la prochaine leçon. Sélectionnons le
nœud racine pour voir l'éditeur de thème et ajouter le curseur vertical
à notre thème Toutes les propriétés du thème
pour le curseur vertical sont également disponibles pour les curseurs
horizontaux Comme le curseur
ne contient ni texte ni icônes, il n'a pas de couleurs, de
police ou de taille de police Nous allons donc commencer par la section consacrée aux
constantes. Si le capteur central est
différent de zéro, il
sera positionné
dans l' espace du curseur vertical fonction uniquement de son point central plutôt que des dimensions complètes
de l'image Et le décalage de la pince peut entraîner un certain déplacement horizontal de la pince vers la
gauche ou vers la droite Sur un curseur horizontal, cette même propriété sera plutôt
un décalage vertical Dans la section des icônes, nous pouvons fournir différentes images pour le grabber dans ses états normal, désactivé et surligné, ainsi que l'image utilisée pour dessiner des marqueurs le
long du curseur Je n'utiliserai aucune corde comme moyen préhension et une
traverse pour ma Dans la section style, nous pouvons modifier
la façon dont le curseur est dessiné, ainsi que la zone remplie normalement sous le grabber et
le
moment où il est le cas d'un curseur horizontal, il
s'agirait de la zone située à
gauche de la pince. Mon curseur sera
une fine ligne brune
représentant un mât,
et le remplissage sera
une texture
de boîte de style que je remplirai une fine ligne brune
représentant un mât,
et le remplissage sera
une texture
de boîte de style que je remplirai avec l'image d'une voile
et que je l' élargirai à
gauche et à droite, pour qu'elle ressemble à une
vraie Je vais ensuite le copier, le
rendre unique et modifier la texture
lorsqu'il est surligné. Pour donner plus de place à cette vente, je vais remplacer mon paramètre de
thème pour le
conteneur horizontal afin qu'il y espace de
21 pixels
entre les nœuds enfants En sélectionnant le nœud du curseur, nous devons réagir au joueur utilisant
le curseur en connectant l'un
de ses signaux à un script Si vous souhaitez réagir à la modification de la
valeur uniquement
après que le joueur ait relâché le bouton de
la souris et
arrêté de faire glisser le pointeur, il
serait approprié de connecter le signal de
fin du Mais je veux réagir
à la
modification de la valeur même si le joueur
maintient le bouton de
la souris enfoncé. Je vais donc connecter le signal de changement de
valeur place et le connecter à
mon script de gestionnaire de cartes. Je vais enregistrer la valeur
du curseur des ventes dans les données de sauvegarde du
joueur En saisissant une référence
au nœud de vente, je peux également définir sa valeur
lorsque les données de sauvegarde sont réinitialisées Je devrai également ajouter cette variable au script de
sauvegarde des données. Essayons-le. Le curseur vertical
réagit au survol et nous pouvons modifier sa valeur à l'
aide de la molette de la souris Nous pouvons également cliquer et faire glisser le grabber pour modifier sa valeur Nous avons maintenant un curseur vertical contrôlant les voiles du navire Dans la leçon suivante, nous allons laisser le joueur embarquer vers
sa destination. Je te verrai dans la prochaine leçon.
40. 6 4 Barre de progression: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté un curseur vertical
pour contrôler les voiles du navire Dans cette leçon, nous allons
utiliser une barre de progression pour indiquer la distance parcourue par le
navire. Je vais ajouter un nœud de barre de progression
au conteneur horizontal situé sous ma carte et le faire s'étendre
horizontalement pour remplir l'espace, puis le positionner entre les commandes
d'ancre et de voile. Jetons un coup d'œil à ses
propriétés dans l'inspecteur. Nous pouvons changer le sens
du remplissage et modifier la valeur
pour en voir l'effet. Nous pouvons également activer ou désactiver l'affichage des
pourcentages,
et le bouton indéterminé nous
indiquera que quelque chose
progresse sans
aucune indication sur et le bouton indéterminé nous
indiquera que quelque chose
progresse sans
aucune indication degré
de progression,
ce pouvons voir si nous cochons également le degré
de progression,
ce que nous pouvons voir si nous cochons également
l'option d'aperçu sous Éditeur. Toutes les mêmes propriétés de
plage sont présentes et fonctionnent de la même
manière que le curseur Mais si nous autorisons que la
valeur soit
inférieure au minimum ou
supérieure au maximum, la valeur sera indiquée
par le pourcentage, mais pas par le remplissage
de la barre de progression. Sélectionnons le
nœud racine pour voir l'éditeur de thème et ajouter la barre de
progression à notre thème. Comme tout nœud contenant du texte, nous pouvons modifier la police et les couleurs du
contour de la police et définir la taille du contour dans
la section constante. Comme toujours, je vais
laisser la police et la taille de
police comme valeurs par défaut du thème, et la barre de progression ne
comporte aucune icône à modifier Dans la section style,
nous pouvons modifier à la fois l'arrière-plan et le
remplissage de la barre de progression, que je
remplirai de cases de style plates Je vais utiliser la même couleur de
fond bleu que mon panneau, arrondir les coins et ajouter des marges
de contenu pour l'agrandir un peu. Copiez-le ensuite pour le remplissage,
rendez-le unique et changez
sa couleur en vert. Pour entreprendre notre voyage, nous devons connecter le
signal appuyé
sur le bouton d'embarquement au script. En haut du script, j'ai besoin d'une référence
à ma barre de progression. Je vais également déclarer
une variable booléenne indiquant si le
joueur navigue actuellement ou non, le temps
écoulé sous forme de flotteur et le nombre de
jours en mer sous forme de nombre entier Pour commencer à naviguer, je vais définir
la variable booléenne sur true. Le temps s'est écoulé et le nombre de
jours en mer est tombé à zéro. Je vais également
parcourir les autres onglets de mon
conteneur d'onglets et les désactiver,
car ils ne devraient être
accessibles que dans car ils ne devraient être
accessibles que un port, et
non pendant la navigation J'écrirai ensuite une autre
fonction pour arriver à un port, acceptant un
identifiant de port sous forme d'entier. Une fois que le réglage est
défini sur False, j'activerai le port d'où
le joueur a navigué, je
changerai le port actuel par le port
de destination, désactiverai le
nouveau port actuel, puis je mettrai la destination
sur moins un, ce qui signifie qu'il n'y a pas de destination Je peux ensuite réactiver les autres onglets puisque le
joueur est désormais dans un port Définissez ensuite la valeur maximale de la barre de progression sur la distance entre le port actuel et
la destination et désactivez le bouton d'embarquement. Pour naviguer entre le
port actuel et la destination, j'utiliserai la fonction de traitement pour remplir
progressivement la barre de
progression au fil du temps. Si le joueur
ne navigue pas, s'il est ancré ou si
les voiles sont réglées à zéro, aucune progression ne sera
faite et je reviendrai simplement Sinon, j'augmenterai le
temps écoulé par Delta, et si le temps écoulé est supérieur au nombre de jours en mer,
j'augmenterai le
nombre de jours en mer et je verserai à l'équipage ses revenus quotidiens J'ajouterai ensuite à la valeur de la barre de
progression la vitesse actuelle du
navire du joueur multipliée par sa
valeur de vente multipliée par Delta. Cela permettra au
navire de parcourir sa vitesse en miles
nautiques toutes les 1 seconde 1 seconde
représentant un jour. Si la valeur de la barre de progression atteint sa valeur maximale, cela signifie qu'ils sont arrivés
à destination. Je vais devoir écrire
cette fonction de paiement dans mon script de chef d'équipe Saisissez une référence au chef d'
équipe à l' aide de l'option d'ajout Ready, puis passez au script du chef
d'équipe abord, en déclarant une variable pour le paiement total
sous forme d'entier, je vais passer en revue
l'équipage du joueur Si le rôle de l'équipage n'
est pas un tableau, j'ajouterai le salaire correspondant à ce
rôle au salaire total. S'il s'agit d'un tableau, je
vais parcourir à nouveau chaque personne occupant ce rôle et ajouter la totalité de son
salaire au total J'ai besoin d'une référence
au nœud de ressources en or pour que ce script puisse demander au joueur de dépenser
ce montant total. Enfin, dépensez la quantité d' or nécessaire pour payer
tous les membres de l'équipage. Si le joueur n'a
pas assez d'argent pour payer tout son équipage, c'est le bon moment
pour terminer le jeu
une fois le jeu terminé. J'ai ajouté un S au nom de mes
variables ici. Il va falloir que je répare ça. Lorsque je
clique sur une case à cocher, je vérifie d'abord si le
joueur navigue actuellement,
et si c'est le cas, j'appuie sur le bouton correspondant au
port de destination et je reviens. Cela empêchera
le joueur de
changer de destination
pendant la navigation. S'ils ne naviguent pas et qu'ils
fixent leur destination, je mettrai la valeur de la barre de
progression à zéro. Essayons-le. Le
joueur peut sélectionner une destination et cliquer sur le bouton d'embarquement
pour commencer à naviguer, mais il ne progressera pas
vers sa destination s'il est ancré ou si
ses voiles ne sont pas déployées La vitesse du navire peut être réglée lorsque la
voile est à moitié ou pleine. Une fois arrivés à
destination, il possible
d'interagir à nouveau avec les onglets et
les cases Une fois dans un port, le joueur
peut recruter des membres d'équipage, et en naviguant vers un autre port, le salaire de l'équipage sera déduit
pour chaque jour passé en mer Nous avons maintenant une
barre de progression indiquant la
distance entre le navire et
sa destination. Et cela couvre presque tous les nœuds
de contrôle de Godo. Les quelques mécanismes qui restent pour terminer ce jeu n'
utiliseraient que les mêmes nœuds que ceux que nous avons déjà utilisés ailleurs
dans le projet. Vous devriez maintenant être prêt
à terminer votre projet. Si vous avez suivi
ce projet, voyez si vous pouvez terminer l'accès au marché de
ce jeu
et ajouter un jeu à
l'écran. Bonne chance