Transcription
1. Promo: Bienvenue dans mon cours sur l'
inventaire et les boutiques à Gado. Ce cours s'inscrit dans la continuité du dialogue et des événements de Gado, mais peut être suivi et appliqué à tout projet impliquant de
récupérer des objets, les
ajouter à un
inventaire, de déposer, utiliser ou d'équiper des objets
depuis un menu d'inventaire et d'échanger des objets avec un Vous pouvez rejoindre
notre serveur Discord pour travailler sur ce cours
aux côtés de vos pairs Dans ce cours, nous aborderons différentes méthodes pour
récupérer des objets, gérer les données d'
inventaire des joueurs, afficher leur inventaire
sur l'interface utilisateur dans un menu, permettre au joueur d'interagir avec son inventaire de différentes
manières et échanger des objets avec des PNJ. Lorsque vous aurez terminé,
vous disposerez d'un système d'
inventaire simple pour votre jeu facilement personnalisable dans sa présentation
et ses fonctions. Vous acquerrez également des compétences utiles pour travailler avec le moteur de jeu
Gada, organiser et concevoir vos projets de manière à ce qu'ils
soient plus évolutifs Vous allez
apprendre à coder avec le script
GD avec tout
expliqué en détail Nous appliquerons les principes de conception
orientée objet dans nos scripts, à savoir
l'héritage, l'encapsulation, l'abstraction et le polymorphisme,
afin de les organiser, de les personnaliser et de les réutiliser
pour un projet de toute taille Tous les fichiers du projet sont
également disponibles sur GitHub, si vous devez revoir
le projet tel qu' il était après avoir terminé
chaque leçon Ces vidéos ont été enregistrées
avec Gdoersion 4.2 0.2. Le projet commence avec des
actifs provenant de K Kits, personnages et de
packs remasterisés de donjons créés par Bundle Basic Guy
créé par Penzilla et icônes créées par Tous sont
téléchargeables gratuitement sur ce site. Les effets sonores réalisés par
Valensbyer sont également
inclus et sont disponibles sur
2. Pièces de monnaie: Bonjour, mes amis.
Avant de commencer, votre projet devrait inclure
un jeu contenant un personnage
que le joueur peut
contrôler et un niveau dans
lequel il
peut se déplacer. Vous devez avoir au moins
un autre personnage pour faire office de commerçant, ainsi que des actifs sous forme de pièces et d'
objets que le joueur pourra
récupérer, utiliser et équiper Tout au long de ce cours,
nous fournirons au joueur un inventaire pour suivre
son argent et ses objets, les
afficher sur l'
interface utilisateur, utiliser des consommables, équiper des objets pour le personnage et les acheter ou les vendre à des PNJ Vous pouvez utiliser votre propre projet
pour suivre ce cours ou télécharger un projet de
démarrage sur mon GitHub, intitulé Godo Inventory
course, branche principale Votre projet peut être en deux ou
trois D et dans presque tous les genres de
jeu dans lesquels le personnage possède de
l'argent et/ou des objets dans un inventaire et la
possibilité d'échanger avec des PNJ. Commençons par ajouter
une variable pour
suivre la
devise du joueur dans son fichier de sauvegarde, qui dans ce projet est
la ressource de progression. Exporter les variables, afin qu'elles soient sérialisées et enregistrées Appelons ça des pièces. Il s' agira d'un entier dont la valeur
par défaut est zéro. Ensuite, affichons ces
informations sur le Canvas à l' aide d'un nœud d'étiquette. Après avoir défini la
police et la taille de police, il est conseillé de
définir la limite de taille du nombre que vous souhaitez autoriser
à afficher, expérimentant avec un numéro de
remplacement. Limite de somme de 10 millions. Ce serait bien d'
avoir une icône à côté ce numéro pour indiquer au
joueur ce que cela signifie. À l'aide d'un nœud texturé, peuplé d'une icône représentant une pièce de monnaie, nous pouvons placer les deux enfants une boîte horizontale pour les disposer
à notre Renommons le portefeuille du nœud
parent. Et déplacez-le pour qu'il soit
derrière le fondu. Je pense que le compteur de pièces sera plus
beau dans le coin
supérieur gauche, où il est déjà ancré, mais avec 32 pixels de rembourrage depuis le
bord de la fenêtre L'icône est trop grande Je vais
donc modifier son mode d'étirement
pour conserver son aspect afin de conserver son rapport hauteur/largeur et la redimensionner
automatiquement pour qu'elle s'adapte à sa largeur proportionnellement
à sa hauteur Réinitialisation de la hauteur
du conteneur parent. Il sera désormais défini par la taille de police des nœuds d'
étiquette, qui est apparemment de 42 pixels. La hauteur de l'icône
sera également de 42 pixels. Ainsi, avec un rapport hauteur/largeur de un
pour un, la largeur de l'icône sera également définie sur 42. Je vais également
centrer le texte verticalement et ajouter un contour noir à 16 points
au numéro pour qu' il corresponde au
contour autour de l'icône. Pour l'avenir, j'
aimerais que l'icône clignote légèrement
lorsque le chiffre change. Définir sa valeur de
taille minimale personnalisée y sur 42. Cliquez et faites-le glisser vers la droite, et nous pouvons voir les effets de l'
augmentation puis de la diminution de
cette valeur au fil du temps. procédant ainsi rapidement, nous pouvons constater l'effet de l'
application d'un effet de pouls rapide mais subtil, qui
déplace également légèrement l'étiquette, attirant ainsi l'attention du joueur Je tiens également à
ce que le Canvas ne contienne aucune information non pertinente pendant que le joueur joue au jeu. Nous
masquerons donc le compteur lorsqu'il ne sera pas nécessaire. Sélection du nœud du portefeuille. Nous pouvons cliquer et
faire glisser la valeur de la position y pour voir comment elle peut se déplacer vers le haut hors de l'écran pour se masquer et
redescendre pour s'afficher. Commençons le portefeuille
dans sa position fermée, où sa valeur de position
y sera la même que sa
valeur de taille y mais négative. Après avoir affiché le portefeuille, nous pouvons démarrer un chronomètre pour le masquer
automatiquement après un certain temps à l'
aide d'un nœud de minuterie. Appelons-le « masquage automatique et définissons sa
propriété one shot sur true,
afin qu'il ne
compte à rebours qu'une seule fois lorsqu'on lui demande, pour que la
démonstration soit courte. Je masquerai automatiquement le portefeuille au
bout de 3 secondes. En ajoutant un script à ce nœud, appelons-le compteur et enregistrons-le dans le dossier des
scripts de l'interface utilisateur. Il peut hériter du
contrôle puisqu'il n'a besoin d'aucun comportement du conteneur
horizontal Nous aurons besoin de
références à toutes les notes pour enfants définies
pendant la phase de préparation. Et une variable d'interpolation privée. fonctions publiques
seront disponibles pour indiquer à cette note de s'
ouvrir ou de se fermer, renvoyant le signal de fin de l'interpolation une fois
terminé, et une pour régler la
valeur du compteur L'ouverture du compteur
se fera en
interpolant sa position y
à 32, et en le fermant, il en sera de
même pour le point y. Il serait judicieux de les exporter sous forme de
variables
afin de rendre le script plus réutilisable pour
d'autres compteurs En ajoutant des variables de
position à
l'écran et de position hors écran,
toutes deux sous forme de vecteur deux, O pen peut désormais interpoler la position
des nœuds à l'écran et fermer les
interpolations en mode hors écran Modification de l'argument float
en un vecteur deux. Interprétation de la position des nœuds,
acceptation d'une nouvelle position
en tant que paramètre vectoriel à deux
et renvoi du
signal terminé d'interpolation acceptation d'une nouvelle position
en tant que paramètre vectoriel à deux et renvoi du
signal terminé Nous allons d'abord vérifier si un préadolescent
existe et est en cours d'exécution. Si c'est le cas, tuez-le et
créez-en un nouveau. Nous pouvons ensuite interpoler la position
des nœuds pour atteindre la nouvelle position
au fil du temps. Exportons-le
sous forme d'une autre variable et donnons-lui une
valeur par défaut de 1 seconde. N'oubliez pas de définir les valeurs des positions à
l'écran et
hors écran de ce nœud de contrôle
dans l'inspecteur Pour définir la valeur, nous avons besoin d'une nouvelle valeur,
qui doit être un entier. Nous allons définir la
propriété de texte du nœud d'étiquette corresponde
à cet entier
après avoir converti son type en chaîne, mais en la fixant entre zéro
et la valeur maximale
autorisée à l'acheteur à afficher Mais d'abord, nous devons vérifier si le compteur est
actuellement affiché, et dans le cas contraire, attendre
la fonction d'ouverture. Pour cela, nous aurons besoin
d'une variable booléenne nous
indiquant si le
compteur est actuellement ouvert ou non, qui sera définie sur true
pendant la fonction d'ouverture, mais uniquement une fois l'
interpolation Ensuite, attendez également l'animation du pouls de l'
icône avant de mettre à jour
le nombre réel. Vous pouvez également omettre le
poids ici pour que le pouls et le nombre soient mis
à jour simultanément En ajoutant une fonction d'impulsion, renvoyant le
signal d'interpolation terminé après avoir effectué les vérifications
d'interpolation habituelles, je vais simplement interpoler la propriété minimale y
personnalisée des icônes pour qu'elle soit Disons 46 pixels. Sur une durée d'un
dixième de seconde, puis revenez à sa taille
d'origine pendant
la même durée Nous pouvons également exporter des variables pour la durée et la taille de
l'impulsion si nous le voulons. Notez qu'en raison des paramètres de
nœud que j'utilise, la réduction de l'icône à valeur inférieure à 42
pixels sera ignorée Vous pouvez toujours modifier le type de la boîte horizontale pour en faire un
nœud de contrôle normal et
positionner manuellement ses enfants si
vous souhaitez plus de flexibilité. En sélectionnant le nœud
Auto Hid Timer, nous pouvons connecter son signal de
temporisation à la fonction de fermeture du compteur. sélectionnant dans la liste, la flèche verte
indique que la fonction est connectée à un signal. Parfois, nous souhaiterons peut-être
désactiver la fonction de masquage automatique. Ajoutons cette
fonctionnalité avec un paramètre booléen facultatif appelé stay open, dont la valeur
par défaut En le stockant dans une
variable locale du même nom, nous pouvons l'utiliser comme condition avant de demander au chronomètre de masquage
automatique de démarrer, désactiver le comportement de masquage
automatique et de garder ce compteur ouvert Lorsque vous définissez la
valeur du compteur, si celui-ci
n'est pas déjà ouvert, il va de soi que le compteur n'a pas
reçu l'ordre de rester ouvert. Nous devons donc attendre
son ouverture et passer false comme argument pour
déclencher le masquage automatique, et set is open back
à false lors de la fermeture. Passons maintenant à
la scène du niveau et créons une pile de pièces que
le joueur pourra récupérer. En commençant par un nœud
Aa en trois D, appelons-le coin stack Small. Faites ensuite glisser l'actif du modèle sur le nœud de la zone 3 D
pour l'ajouter en tant qu'enfant. En cliquant avec
le bouton droit sur la pile de pièces, sélectionnez Make Local pour séparer ce nœud de
l'actif importé, en faisant simplement une copie locale, au lieu d'une référence
à l'actif. Nous pouvons maintenant extraire
uniquement le nœud 3D de l'
instance de maillage qui dessine la pile de pièces et
supprimer tout le reste. Assurez-vous que les pièces
reposent bien sur le sol, ajustant votre
perspective si nécessaire Ensuite, nous allons ajouter une forme de
collision pour le nœud de la zone 3 D. Je vais utiliser une sphère,
lui donner un rayon qui l'entoure suffisamment et la déplacer au-dessus du sol. Attachons un nouveau script à cette pile de pièces
appelée pile de pièces. Je vais le mettre dans le dossier des scripts d'
événements. T. Et faites-lui hériter d'un événement de proximité pour réagir
automatiquement aux
collisions avec le joueur Pour plus d'informations sur les événements, consultez le
cours sur le dialogue et les événements de la série. Exportons une variable pour le nombre de pièces
qui se trouvent dans la pile, un entier avec une valeur
par défaut de dix. Nous pouvons également restreindre cette
valeur pour qu'elle soit
contenue dans une plage à l'aide de
la balise export range, en spécifiant une valeur minimale
et maximale autorisée pour cette variable. Une pile de pièces ne
doit pas être vide, donc la
valeur minimale serait de une, et je vais juste mettre le
maximum à 10 millions. En fournissant une définition permettant au gestionnaire d'événements d'appeler la fonction d'exécution des scripts, acceptant le
gestionnaire d'événements comme paramètre, nous n'aurons pas besoin de l'utiliser, vous
pouvez donc le poursuivre
avec un trait de soulignement Nous devons définir la variable de
progression de manière à soit augmentée de la valeur de
cette pile de pièces, puis la détruire en utilisant Q free. Nous devrons également annuler la fonction saisie sur le corps pour
indiquer au game manager de ne pas
désactiver le nœud joueur
pendant cet événement Faisons de cette pile
de pièces sa propre scène, enregistrant dans le
dossier des scènes et en créant un nouveau
sous-dossier pour les objets. Éloignez ensuite la pile de la position de
départ du joueur. La dernière chose à faire est mettre à jour l'interface utilisateur lorsque les
pièces sont collectées. Il y
aura probablement beaucoup de pièces dans le
jeu et nous ne
voulons pas gérer leurs signaux manuellement. Ce
serait une perte de temps. Un moyen simple d'y parvenir consiste à utiliser des signaux chargés automatiquement. En créant un nouveau script de chargement automatique, appelons-le global et
donnons-lui un signal appelé pièces daté avec un paramètre entier
pour le montant des nouvelles pièces. Ce script est également utile
pour fournir des valeurs pour les variables couramment utilisées dans les
différents scripts
de votre projet, en particulier ceux qui ne
sont pas censés être ajustables par le joueur
dans les paramètres du jeu. Nous pouvons ensuite ajouter le script
global à la liste
des nœuds chargés automatiquement dans
les paramètres du projet. Le script de compteur attaché
à notre portefeuille peut désormais utiliser la fonction ready pour connecter ce signal à sa fonction de valeur
définie. Définir l'étiquette de l'
interface utilisateur pour qu'elle corresponde à l'argument transmis par le signal émis par le chargement automatique global. Et initialisez également la
valeur à tout ce qui est stocké dans le fichier de sauvegarde du joueur lors du premier chargement du jeu Mais il ne s'agit plus
d'un script réutilisable. Donnons-lui donc un compteur
de noms de classes. Créez ensuite un nouveau script hérité du compteur
appelé Wallet. Cette fonction prête à l'emploi sera directement liée
aux pièces du joueur. Remplacement du script fixé
au mur en le faisant
glisser sur le nœud Le script de compteur
peut désormais être utilisé pour compter tout ce qui est
affiché sur l'UY, comme les clés ou les
potions de santé, par exemple Dans le script de progression, en ajoutant une fonction de réglage
à la variable coins, nous pouvons indiquer à ce signal d'être émis
automatiquement chaque fois que
la valeur change À l'aide d'une instruction if,
nous pouvons nous
assurer que le nombre n'est pas défini
comme il était
déjà. Essayons-le. En se dirigeant vers les
pièces, elles disparaissent. Le portefeuille apparaît avec un
solde de zéro, qui clignote
et passe à dix. Puis, après un temps d'attente de trois
secondes, le portefeuille se cache tout seul. Nous avons maintenant des pièces que
le joueur peut récupérer et suivre sur
le Canvas du jeu. Dans la leçon suivante, nous ajouterons effets
visuels et audio pour améliorer l'apparence de
ces mécanismes de jeu. Je te verrai dans la prochaine leçon.
3. Polonais: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté des
pièces à collectionner à notre jeu Dans cette leçon, nous allons utiliser toutes
sortes d'effets spéciaux pour
peaufiner le processus de
collecte des pièces afin de le rendre plus satisfaisant. À partir du contre-script, nous pouvons ajouter divers
effets au comportement de nos préadolescents à l' aide
de
transitions et d'assouplissements, qui modifient l'évolution de la propriété au fil du
temps Exportons une variable de type de
transition entre deux. Et réglez-le lors de la
création de l'interpolation. Dans l'inspecteur,
le comportement par défaut est une transition linéaire, modifiant la
propriété de
manière uniforme au fil du temps Mais nous pouvons le remplacer par
plusieurs options différentes. En regardant ces graphiques, je pense qu'il serait intéressant le compteur utilise le type de transition
élastique. Et chacun de ces éléments peut également être combiné avec un type d'assouplissement, en les
appliquant à la moitié entrante de l'interpolation, à la moitié
extérieure ou aux deux Au lieu d'exporter
le type d'
assouplissement, j'aimerais que
différents assouplissements soient appliqués aux fonctions
ouvertes/fermées Comme il serait
logique que
l'effet élastique
apparaisse à l'écran, je vais intégrer la fonction ouverte et la fonction fermée. fait passer
le type d'assouplissement des fonctions ouvertes/fermées à Dans chaque cas, on fait passer
le type d'assouplissement
des fonctions ouvertes/fermées à
la
fonction de position d'interpolation Dans la scène des piles de pièces, nous pouvons attendre que la
pile se rétrécisse avant de la détruire au lieu
de simplement disparaître En saisissant une référence au
désordre pendant la phase de préparation,
nous pouvons indiquer au maillage de
se rétrécir à l'aide d'une interpolation Comme il n'est pas possible utiliser
ce préadolescent plus d'une fois, nous n'avons pas à nous
en inquiéter. Il suffit de créer le préadolescent J'utiliserai le même
type de transition
élastique pour ajuster la propriété d'
échelle des maillages à zéro sur une courte durée
et renvoyer le signal Mais nous devons nous assurer
que le joueur n'entre pas nouveau
en collision avec cette zone pendant l'interpolation Désactivons-le donc en
ajoutant une fonction dans le script d'événement de proximité qui met son masque de collision à zéro. Nous pouvons également apporter du peaufinage
en ajoutant un
lecteur de flux audio à trois nœuds en D. Doté d'un effet sonore qui
claque des pièces. J'utilise le pack de
sons de pièces créé par Val Inspired Or. Nous devons récupérer une référence à ce nœud
à l'aide d'un module complémentaire. Et dites-lui de jouer
pendant l'événement. Attendez ensuite que le
son soit terminé avant de mettre le nœud
en attente pour qu'il soit
libéré afin qu'il puisse être diffusé En tant que
lecteur de flux audio à trois nœuds D, le son émis
ajustera son volume en fonction proximité de l'
écouteur par défaut, la caméra Si nous voulons ajouter
des effets sonores à l'interface utilisateur, nous devons plutôt utiliser le nœud de
lecture de flux
audio de base, qui produira toujours son effet sonore au volume sur lequel il est réglé. Saisir une référence au nœud du lecteur de flux
audio. Nous pouvons émettre un cliquetis à chaque fois que la
valeur du compteur est réglée Nous avons maintenant des
effets sonores joués à partir de différents nœuds et de
différentes scènes. Un nœud
chargé automatiquement diffuse également la musique de
fond tandis que d'autres nœuds diffusent des effets sonores, et nous en aurons
certainement beaucoup plus au fur et à mesure que le jeu s'agrandira, et d'autres pourront
également jouer à des dialogues. Nous devons régler leur volume pour qu'il corresponde à celui des paramètres du jeu. Mais il
serait difficile de les gérer individuellement. Si nous cliquons sur l'onglet
audio en bas de l'éditeur, Gada dispose d'un bus
audio intégré que nous pouvons utiliser pour classer nos
différentes sources audio Cela nous permet d'
ajuster les volumes ou d'autres paramètres de chacun
collectivement via le bus, au lieu de chaque nœud individuel. En ajoutant un nouveau bus pour la musique et
un autre pour les effets sonores, les deux seront transmis par le master avant
d'être transmis aux haut-parleurs. Le réglage du volume principal affectera tout ce qui se passe
dans le jeu. Le réglage du
volume de la musique
n'affecte que la musique,
de même que les effets sonores. En sélectionnant les nœuds du flux
audio des effets sonores, nous pouvons changer leur bus en SFX Comme nous ne pouvons pas accéder
au nœud musical en dehors du script chargé automatiquement, nous pouvons utiliser la fonction Ready
pour mettre son bus en musique. Assurez-vous que l'orthographe
est exactement la même. le cas contraire, le bus sera
redéfini sur la valeur par défaut de master. Enregistrez le schéma du bus audio en
tant que ressource du projet. Ouvrez ensuite les
paramètres du projet. Sous Bus audio, sélectionnez la
disposition du bus audio par défaut. Le nœud musical n'aura plus besoin de se référer
au réglage du volume, puisque le
bus audio musical fixera le plafond de son volume et pourra simplement passer
à un volume linéaire de un. Dans la
ressource des paramètres, nous pouvons ajouter des variables pour stocker chaque réglage de volume
individuel, master, la musique et les effets
sonores, en fournissant également des valeurs par défaut
pour chacun. Dans le menu des paramètres, nous pouvons ajouter des curseurs de
volume pour modifier
chacune de ces valeurs Je vais changer le volume
en volume principal. Dupliquez-le ensuite deux fois et modifiez les doublons pour volume musical
et des effets sonores Saisir les références à chaque curseur pendant
la phase de préparation Initialisez-les pour qu'ils correspondent aux paramètres
du jeu
lors du premier chargement Nous n'avons plus besoin
de régler manuellement le volume de la musique puisqu'il
sera géré par le bus. Et lorsque le lecteur
modifie ses valeurs, modifiez les variables dans
la ressource de paramètres et ajustez également les volumes du bus audio
en conséquence. serveur audio définit le volume du bus
Décibels
Index du bus du serveur audio Les paramètres des points du fichier principal correspondent au volume principal, converti du
linéaire Donner à chaque curseur
sa propre fonction de modification de valeur,
après avoir modifié modification de valeur,
après avoir les connexions
de signal des curseurs pour les
connecter aux fonctions de modification de
valeur appropriées Nous devons également initialiser les volumes
de bus
lors du premier chargement Désormais, nous n'avons plus besoin de nous embêter à ajuster
manuellement
les volumes
des nœuds audio, à condition qu'ils soient triés dans la catégorie
appropriée. Ouvrir les pièces, empiler une petite scène Réinitialisez l'
origine locale des transformations si ce n'est pas le cas. Ajoutons également un
simple effet de particules aux pièces lorsqu'
elles disparaissent. Pudo possède deux types de nœuds
différents pour générer des particules, l'un fonctionnant sur le processeur
et l'autre sur le processeur graphique Particules de processeur
compatibles avec les
ordinateurs plus lents ou ceux qui ne disposent pas d'un processeur
graphique dédié comme les appareils mobiles, mais qui ne peuvent pas produire autant de particules et ont
moins de fonctionnalités. Un système de particules à processeur
est suffisamment capable de produire une petite rafale de particules, comme ce que nous
essayons de réaliser ici. Mais un émetteur de particules GPU
serait plus approprié pour émettre des milliers ou des millions de particules sur un système moderne J'utiliserai un émetteur de particules du processeur. heure actuelle, rien n'émet car il n'y a aucune
particule à dessiner. Développez la
section de dessin et ajoutez une ressource de maillage pour représenter
une seule particule. J'aimerais utiliser le maillage à
pièces comme particule. Je vais faire glisser une seule pièce du pack d'actifs
dans la scène. Rendez-le local et sélectionnez le nœud à trois D de l'instance de
maillage. Après avoir rendu ce maillage unique, il n'est plus lié
à l'actif importé. Je peux enregistrer ce maillage en
tant que ressource de projet. Je l'appellerai Coin Mesh. supprimant tous ces nœuds et resélectionnant l'émetteur de
particules, je peux maintenant utiliser ce
maillage comme Les particules émettent désormais huit fois par seconde
et tombent. J'aimerais une explosion ponctuelle de particules au lieu d'une émission
continue. En élargissant la section temporelle, je vais définir un cliché pour vrai
et l'explosivité pour un En cliquant sur le bouton émetteur, les huit particules apparaissent toutes en même temps et
disparaissent
au bout d'une seconde, ce qui est la propriété de durée de vie Je veux que les particules éclatent
vers le haut Je vais
donc étendre la section de
direction et changer la direction vers le haut
avec un écart de 15 degrés. Ensuite, je vais régler la
vitesse initiale sur un nombre aléatoire de 2 à 3 mètres/seconde et la gravité à seulement moins 4
mètres/seconde Je vais demander aux particules d'
aligner leurs vecteurs ascendants locaux dans la direction dans laquelle elles se déplacent. Voyons à quoi cela ressemble jusqu'à présent. Je préférerais que les pièces n'apparaissent pas ou ne disparaissent pas
soudainement Je vais
donc agrandir la section d'
échelle, et selon une courbe d'échelle. élargissant la
ressource de la courbe pour la modifier, nous avons le temps le long de l'axe X
et l'échelle le long de l'axe Y. Notez qu'un temps de
un n'est pas égal à 1 seconde, pas plus qu'une échelle de 1 mètre. Il s'agit des pourcentages de
la durée de vie
et des propriétés d'échelle des particules Au temps zéro, je veux que la
pièce soit invisible, en réglant son échelle à zéro, et la même au premier instant. À mi-chemin de
la durée de vie des particules, je veux que leur échelle
soit une ou une taille normale. Cela crée une onde
qui permet à la particule de croître et de rétrécir
progressivement
au cours de sa durée de vie. Nous pouvons modifier les
points d'ancrage de n'importe quel point de cette courbe pour ajuster la façon dont cela
affecte l'échelle des particules Maintenant, il semble que
les pièces éclatent vers le haut et pleuvent
après avoir été collectées. Il existe de nombreux
paramètres différents pour ajuster la façon dont particules sont générées et leur comportement au cours de leur durée de vie Essayez d'expérimenter différents paramètres d'effet de
particules pour obtenir le type d'effet que
vous souhaitez pour votre jeu Dans le script coins stack, nous pouvons saisir une référence
au nœud émetteur de particules et définir sa propriété d'émission true lorsque les
pièces sont collectées Attendez ensuite la fin du signal avant de mettre ce
nœud en file d'attente pour qu'il soit libéré Je vais faire en sorte que le rétrécissement, l'effet
sonore et l'effet de particules se
produisent simultanément En dupliquant la petite scène de la
pile de pièces, nous pouvons créer une pile moyenne ou
grande Remplacement du nœud en
trois D de l'instance de maillage par différentes piles de pièces Je vais également définir la valeur
de ces piles pour qu'elle ait une valeur par défaut plus élevée modifiant dans l'inspecteur au
sein de leurs scènes Modifiez leur effet sonore et le nombre de particules émises par leurs effets de
particules. Ajoutez ensuite différentes piles autour du niveau à sélectionner par
le joueur Nous pouvons également utiliser
les effets de particules en deux D. Faisons un effet similaire sur l' icône
du portefeuille lorsque le point de contact avec les
pièces est mis à jour. Ajout d'un
émetteur de particules à deux D au nœud d'icône. Je vais le
placer au centre. R En utilisant presque toutes les mêmes propriétés
pour cet émetteur de particules, je vais simplement remplacer la particule
par une copie de l'icône de la pièce Utilisez un écart de 180 degrés
pour que les particules volent
dans toutes les directions et éliminent la gravité. La vélocité est mesurée
en pixels par seconde, je vais
donc la faire varier de 16 à 32 Mais appliquez la même courbe pour que les particules
croissent et rétrécissent. Et réglez l'échelle minimale et maximale à seulement 5 % de sa taille normale. Ensuite, dans le script du compteur, saisissant une référence à
l'émetteur de particules, nous pouvons lui dire d'émettre lors de la
mise à jour de la valeur du compteur Désormais, lors de la collecte des pièces, le comportement des pièces et l'interface utilisateur semble beaucoup
plus intéressant. Essayez d'expérimenter différents types de
transition et d'assouplissement, effets
sonores et d'effets de
particules pour obtenir l'apparence que
vous recherchez pour votre jeu Nous avons désormais une
expérience plus satisfaisante pour les joueurs qui collectent des pièces dans notre jeu grâce à une variété d'effets. Dans la leçon suivante, nous
autoriserons le joueur à récupérer un objet en appuyant sur un bouton et en l'ajoutant à
son inventaire. Je te verrai dans la prochaine leçon.
4. Retrait: Bonjour, mes amis. Dans
la leçon précédente, nous avons peaufiné les mécanismes de collecte de
pièces. Dans cette leçon,
nous allons ajouter des objets que le joueur peut récupérer
en appuyant sur un bouton. Commençons par
créer quelques objets que le joueur
devrait pouvoir récupérer. À partir de la scène du personnage, nous pouvons utiliser l'un des
objets qu'ils ont en main. Je vais utiliser la hache des Barbares. faisant de cette hache sa propre scène, en l'
enregistrant dans le dossier des scènes d'
objets, remarquez que l'origine de la hache trouve au niveau de la poignée où
le personnage la tient. Nous pouvons ajouter un nœud en
trois D à corps rigide à cette scène, ce
qui en fera
un objet physique, indiqué par l'icône du ballon de
plage. Donnez-lui une forme de collision. Je vais juste utiliser une boîte Collide. Ajustez ensuite les limites
et la position de la boîte pour encapsuler
le modèle x. L'utilisation de points de vue orthographiques
facilite grandement les choses. En cliquant avec le bouton droit sur le nœud en trois D à corps
rigide, je vais en faire le nœud
racine de la scène et le renommer en X. Mettons-le sur une
nouvelle couche de collision J'utiliserai la couche six pour les objets. Cet objet peut
masquer le terrain, d'autres objets, le joueur et le MPC Ouverture des paramètres du projet, noms des
couches, de la physique des trois D, mise de côté de la couche
six pour le ramassage des objets En attachant un script
au nœud racine, je l'appellerai simplement item. Je vais rester simple
pour le moment et simplement exporter le nom d'affichage de
l'élément sous forme de chaîne. Nous allons développer les
articles eux-mêmes. Pour en revenir à la scène du
personnage, nous pouvons supprimer le nœud de l'objet, car nous n'avons
pas encore mis
en place les systèmes appropriés pour l'
équiper Dans la scène du donjon, en
faisant glisser
une bouteille A étiquetée brune dans la
scène et en la rendant locale, l'actif a été importé pour être déjà recouvert d'un
corps rigide Nous pouvons cliquer avec le bouton droit sur ce
nœud, en faire sa propre scène et le nommer potion de santé Redéfinissez et renommez la potion de santé et
supprimez le nœud 3 D. À l'ouverture de la scène, la simulation
du monde
est désactivée Je vais le réactiver. Renommons également le nœud racine
en potion de santé. Et joignez le script de l'objet en donnant un nom d'affichage
à la potion de santé En utilisant les mêmes
paramètres de collision que la hache. L'origine de la potion se trouve à sa base, où
elle repose sur le sol, tout comme son centre de gravité, ce qui entraîne un comportement
inhabituel Pour que les
personnages puissent plus facilement tenir
les objets entre leurs mains, il est utile que leur origine soit celle où le personnage les
tiendra. En sélectionnant à la fois le maillage
et la forme de collision, déplacons-les vers le bas d'environ les
deux tiers de la bouteille, positionnant l'origine autour
du goulot de la bouteille. Et en sélectionnant le nœud du corps
rigide, en élargissant la section de
distribution de masse. Nous pouvons également modifier le centre de gravité en
le faisant passer
de automatique à personnalisé, déplaçant pour qu'il soit plus
proche de la partie la plus large de la bouteille le long de l'axe
y d'environ un tiers. Cela empêchera la bouteille de se comporter comme un rouleau. Nous avons maintenant deux objets différents que le joueur
devrait pouvoir récupérer. Posons une hache
et deux potions sur la table pour que le
joueur les collecte Mais cela semble plutôt ennuyeux, et comme ce sont
des objets physiques qui peuvent se déplacer, posons l'une des potions sur le sol renversé sur revenir à la scène de la santé, nous pouvons essayer d'y associer un événement d'
interaction, en utilisant un nœud en zone 3 D
et une forme de collision. Je vais utiliser la même capsule
que nos PNJ à titre d'exemple. Bien que ce système ait parfaitement
fonctionné pour interagir avec les PNJ et les portes, qui sont généralement
plus grandes et ne pivotent pas, nous pouvons maintenant constater les
limites de nos
interactions événementielles existantes lorsqu'il s'agit d'
objets plus petits et/ou objets
physiques capables de pivoter Pour cette démonstration, je vais activer les formes de
collision visibles. d'associer un événement
d'interaction à la
potion de santé la rendra inutilisable si elle se renverse
et tombe sur le sol. Puisque la
zone de collision
tournera également autour de l'
origine locale de la potion de santé Cela devient beaucoup plus difficile à cibler
de manière fiable avec une diffusion de rayons. Nous pourrions donner à la collision la
forme d'une sphère
suffisamment grande pour qu'elle soit toujours
détectable par le rayon projeté Mais utilisons une
autre solution. De nombreux jeux permettent également au
joueur de ramasser des objets derrière
lui qui se trouvent toujours
à proximité du personnage
pour des raisons de commodité. Un casting qui ne regarde vers l'avenir
n'y parviendra pas. Une autre façon d'interagir avec l'environnement peut être obtenue en utilisant un nœud en trois D attaché au personnage du
joueur, en utilisant une forme de collision sphérique ou
cylindrique, réglant le rayon sur une limite de portée
appropriée. J'utiliserai la même portée que le faisceau d'
interaction de 2 mètres. Réglez une hauteur de 2,6
mètres à la
hauteur du percuteur de personnages et
centrez-la sur le personnage
à la moitié de cette hauteur de 1,3 mètre. Mais si le personnage se trouve sur une pente descendante
et que le joueur veut ramasser des objets légèrement en
dessous, il
devrait être en mesure de le faire. Je vais donc ajouter
un demi-mètre de hauteur et abaisser le centre d'
un quart de mètre. Cette forme de collision
surveillera les objets
que le joueur peut récupérer lorsqu'il
appuie sur le
bouton d'interaction , masquant ainsi la couche six Joindre un script
à ce nœud de zone. Appelons-le pick up radius. Je vais créer un nouveau dossier pour les scripts des
joueurs et le
mettre dedans. Déplacez ensuite le lecteur et les scripts Spring Arm dans
ce dossier également. Connectez ensuite le
signal saisi par le corps à ce script pour réagir à tout corps de la couche six entrant dans
le rayon de capture. De plus, le corps a émis un signal lorsqu'il a quitté
le rayon de ramassage Ce script
devra conserver une liste de tous les objets
à portée du joueur qui peuvent être récupérés à l'aide
d'un tableau de trois D, qui sera par défaut
un tableau vide. Lorsqu'un corps entre dans cette zone, il est ajouté
au tableau Et lorsqu'il quittera cette zone, il sera effacé
du tableau Mais l'inconvénient d'
utiliser les collisions de zones de
cette manière est qu'
il n'y a aucun moyen de
détecter les obstacles entre les deux Cela
permettra en fait au joueur de ramasser des objets de l'
autre côté d'un mur. Nous devrons utiliser un autre rayon pour déterminer si ce que le joueur veut ramasser est obstrué par le terrain
ou par d'autres obstacles En ajoutant un nœud en trois D
au rayon de ramassage des objets, je le déplacerai vers le haut le long l'axe Y à
mi-hauteur du personnage, 1,3 mètre, et je ferai entrer en collision uniquement avec
le terrain ou les objets Lorsque le joueur appuie sur
le bouton d'interaction, je lui demande simplement de récupérer
l'objet le plus proche de lui. Écrivons un
algorithme qui enverra l'objet
le plus proche au
joueur se trouvant dans cette zone, renvoyant un nœud trois D.
Lorsque vous écrivez un algorithme, il est préférable de commencer par
identifier tous les cas possibles
à
prendre en compte Que se passe-t-il lorsque
le tableau est vide, c'est-à-dire qu'il n'y a aucun objet à
portée que le
joueur puisse récupérer ? Nous devrions renvoyer null,
ce qui ne signifie rien. S'il n'y a qu'un seul
élément dans le tableau, nous devrons d'abord
vérifier s'il existe un chemin dégagé entre ce nœud et le nœud de l'élément
en utilisant le ray cast La définition de la position
cible des faisceaux de rayons correspond à la différence entre les positions globales des éléments
et
des nœuds de diffusion des rayons . Le rayon pointe de
sa propre origine directement vers l'origine des objets. Après avoir modifié la direction vers laquelle pointe le
raycast, les
informations de collision ne seront pas mises à jour avant le
prochain processus physique, mais nous pouvons les forcer à se mettre à jour immédiatement avec
un appel de fonction Si le raycast touche l'
article, nous pouvons le retourner. Sinon, nous retournerons
toujours null, car le seul élément du tableau est
obstrué par le terrain Rendons ce code réutilisable en le transformant
en fonction privée. Je vais l'appeler obstrué, en acceptant l'élément
en tant que paramètre et renvoyant un booléen si le rayon a été
obstrué ou non Étant donné que ces cas concernent la grande majorité des fois où le joueur appuie sur
le bouton d'interaction, ils doivent d'abord être vérifiés et traités le plus
efficacement possible. Dans les rares
cas où il
y a deux
éléments ou plus dans le tableau, nous devrons comparer
la distance de chacun par rapport
au joueur afin décider lequel est
le plus proche, augmente
considérablement la
complexité de l'algorithme Nous avons maintenant besoin de quelques variables
supplémentaires l'indice du tableau de
l'élément le plus proche, la distance jusqu'à
l'élément le plus proche et la distance jusqu'au
prochain élément du Une fois tous nos
calculs effectués, nous pouvons renvoyer l'article à l'
index de l'article le plus proche. Lorsque vous comparez des
distances comme
celle-ci, il est mathématiquement plus
efficace d'utiliser la distance
au carré plutôt que la Puisque la distance entre deux
points dans un espace à trois D est la racine carrée de x au carré
plus y au carré,
alors d au carré est égal
à x au carré plus y au carré plus au carré Il n'est plus nécessaire de calculer la racine carrée de ce nombre, et si d un est
inférieur à d deux, alors d un au carré est également
inférieur à d deux au carré Nous pouvons commencer par
régler l'indice
sur zéro et la distance jusqu'à l' objet
le plus proche sur une valeur
supérieure au carré du rayon de
ramassage, sorte que tout objet situé dans le rayon de ramassage sera considéré comme le plus proche par défaut. Comme mon rayon est de deux,
je vais juste en utiliser cinq. Pour chaque élément du tableau, nous devons déterminer la
distance au carré par rapport à celui-ci En utilisant la
position globale de ce nœud, distance au carré par rapport à
la position globale de l'élément à l'index Comparez ensuite cette distance
à la distance la plus proche. S'il est plus petit,
vérifiez également si l'article n'
est pas obstrué Si cela est vrai, il s'
agit de la distance la plus proche
que nous ayons trouvée jusqu'à présent, et I est l'indice de l'élément
le plus proche à ce jour Notez que les opérations booléennes
sont exécutées de gauche à droite. La comparaison des distances
sera d'abord effectuée, ce qui est un calcul
mathématique assez efficace. Si la distance jusqu'à
l'élément suivant
n'est pas inférieure à la distance la
plus proche, peu importe que
l'élément ne soit pas obstrué L'opération booléenne
débutera par false,
et donc, peu importe ce que l'autre côté
se révélera être, puisque faux et tout
est toujours faux, complètement
le rayon diffusé, ce qui est un
calcul plus coûteux En choisissant soigneusement l'ordre des opérations entre les vérifications courantes
et simples et en reportant les cas les plus
complexes ou les plus rares fin où ils
risquent d'être ignorés, vous
pouvez aider vos algorithmes à
fonctionner de manière plus fluide Nous allons répéter cette opération jusqu'à ce que nous
atteignions la fin du tableau. Ensuite, nous aurons
l'index matriciel de l'objet le plus
proche du joueur et pourrons renvoyer l'objet
à récupérer. Cela ne doit pas être égal à. Le joueur a besoin d'un inventaire
pour stocker ses objets, ce qui fera partie de ses informations de
progression. Déclarons une
variable privée nommée inventory en
tant que dictionnaire et
initialisons-la pour qu'elle soit vide en utilisant des accolades au lieu
de crochets Un dictionnaire est un ensemble de paires clé-valeur,
semblable à un tableau. Si vous considérez que l'
index du tableau est la clé, mais qu'un dictionnaire peut utiliser
n'importe quoi comme clé. À condition que chaque clé soit unique. En utilisant le
nom d'affichage des articles comme clé, nous pouvons facilement empiler des articles
en utilisant la quantité comme valeur. Il s'agit d'une structure d'
inventaire très simpliste, mais suffisante pour
cette démonstration Pour le moment, nous allons créer une fonction
nommée ajouter à l'inventaire, accepte d'ajouter un objet à l'inventaire du joueur et une quantité facultative avec
une valeur par défaut de un Tout d'abord, vérifier si l'objet existe
déjà dans l'inventaire du
joueur. Nous pouvons augmenter la valeur à
cette clé par la quantité. Si l'objet n'
existe pas déjà dans l'inventaire du joueur, nous pouvons définir la valeur comme
étant la quantité, qui crée également cette
entrée dans le dictionnaire. À la fin, nous imprimerons simplement l'inventaire pour pouvoir le voir. Dans le
script du joueur, nous pouvons donner au bouton d'interaction plusieurs utilisations
contextuelles. En utilisant une référence
au rayon de collecte des objets, nous allons également déclarer une variable contenant l'
objet le plus proche du joueur Lorsque vous appuyez sur le bouton d'
interaction, nous allons d'abord attribuer à l'article le plus proche la valeur
de article
le plus proche renvoyé par le rayon de collecte à
l'aide de notre algorithme. Si le
script pick up radius renvoie un objet autre
que nul, autre
que nul, nous devons
récupérer cet objet, l'
ajouter à l'inventaire du
joueur,
puis mettre file d'attente l'objet à libérer, retirant de l'arbre de scène. Mais s'il n'y a aucun objet
à récupérer,
le script renvoie la valeur null, alors nous pouvons passer à la commande d'
interaction avec le personnage. Et si le joueur
fait face à un PNJ à qui il veut parler et qu'il
peut ramasser un objet à ses pieds ? Lorsque vous créez des commandes
contextuelles, déterminez quels
contacts sont
prioritaires et comment cela
affectera l'expérience du joueur. Dans ce cas, appuyez sur
le bouton
d'interaction pour récupérer l'objet en premier. Ensuite, le joueur
devra appuyer à nouveau sur le bouton pour
parler au MPC Parfois, il peut
être préférable
d'utiliser un autre bouton si cela
est plus pratique
pour le joueur. OK. Si nous lançons le jeu, tenons derrière le mur et
que nous appuyons sur
le bouton d'interaction, l'objet est obstrué et nous n'avons pas réussi à le
récupérer Entrer dans la pièce, appuyer sur le bouton d'interaction
sans aucune obstruction. Les deux potions de santé et la hache sont ajoutées à l'inventaire du
joueur, chacune en appuyant sur un
bouton séparé et affichées dans le journal de sortie Les potions de santé
sont également
regroupées dans une seule entrée du
dictionnaire Désormais, le joueur
récupère des objets en un bouton et
les ajoute à son inventaire. Dans la leçon suivante,
nous allons afficher l'inventaire du joueur
sur le Canvas. Je te verrai dans la prochaine leçon.
5. Inventaire: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté des objets à l' inventaire du
joueur
en appuyant sur un bouton. Dans cette leçon, nous allons afficher le contenu de l'
inventaire du joueur dans un menu. Un bon point de départ
avec les menus est de créer
une maquette des informations que vous souhaitez
afficher au lecteur. Cela peut
vous donner une idée de la meilleure
façon d' utiliser l'
espace disponible et peut-être vous faire réfléchir des éléments que vous n'auriez pas
pensé inclure autrement. Commençons par un nœud
de panneau de base et renommons-le en inventaire Nous aurons probablement besoin de
quelques nœuds d'étiquette, d'un titre pour ce panneau
indiquant
clairement au joueur à quoi il sert, ainsi que d'un nom d'objet et description de l'objet
actuellement sélectionné. Le titre indiquera simplement
l'inventaire, et j'utiliserai un texte factice pour le nom et la description de l'article Je vais avoir les deux wraps pour qu' ils ne s'épelent pas
en dehors du panneau Et aussi un conteneur, généralement un
conteneur vertical ou un conteneur en grille pour
organiser tous les articles. Quel que soit le conteneur que
vous utiliserez, il sera probablement
rempli de boutons, chacun représentant un
élément ou une pile d' éléments. Ajoutons-en un maintenant. Nous allons maintenant créer un
thème pour ce menu. Je vais l'appeler inventaire. Créez un nouveau dossier de ressources pour les
thèmes et placez-le avec
le thème existant. développant le thème dans
le panneau de l'inspecteur, je vais remplacer la police
par défaut par la
police la plus lisible que j'utilise pour mon jeu et définir la taille de police
par défaut sur 96, ce qui ne
sera pas vraiment si grand une fois le panneau réduit Dans l'onglet thème, je vais
commencer par ajouter le panneau. Donnez ensuite au panneau une
nouvelle texture de boîte de style. Cliquez sur la texture de la boîte de
style pour l'ouvrir dans l'onglet Inspecteur. Je vais utiliser l'image
carrée grise avec des marges de
texture de 128
pixels sur tous les côtés. L'image est très grande, je vais
donc la
réduire au quart. Réglez ensuite la
taille des panneaux pour doubler la résolution
de l'écran de 12 80 x 720. Il occupe la moitié de l'écran
en largeur et en hauteur. Définissez le pivot
comme centre
en utilisant la moitié de
la propriété de taille, puis en ancrant le panneau
au centre de l'écran Une fois le panneau en place, je peux maintenant ancrer
chacun des éléments à différentes
positions à l'intérieur de celui-ci. Je vais ancrer le titre
de manière à ce qu'il soit centré dans le panneau horizontalement et à
10 % du haut. Croissant dans les deux sens
horizontalement et verticalement, il est
donc centré autour
du point d'ancrage. Je vais utiliser
la police la plus sophistiquée et une taille de police plus grande de 128 Le nom et la description de
l'article, je les mettrai dans une boîte
verticale. Utilisez ensuite des ancrages personnalisés pour positionner sur le
côté droit du panneau, en
couvrant le tout de 60 à 95 % horizontalement et de 20 à 90 % Le reréglage des
décalages d'ancrage annulera les limites du contrôle
pour qu'elles correspondent aux points d'ancrage J'utiliserai un remplacement de thème pour
espacer le mode et ajouter 64
pixels les uns par rapport aux autres Le nœud d'étiquette souhaite définir une taille
minimale personnalisée Je vais
donc simplement les définir à 64 pixels de haut pour
supprimer les avertissements. Cela laisse la moitié gauche
du panneau disponible pour
la liste des articles ou la grille. Encore une fois, en utilisant des ancrages personnalisés, je vais faire en sorte que la grille
couvre 5 % à 58 % horizontalement et 20
à 90 % verticalement Je vais donner à mon exemple de bouton
une taille minimale personnalisée de 256 x 256 pixels. Modifiez également la police du nom de l'élément pour qu'il
ressorte davantage de la description. En ajoutant des boutons
au thème de l'inventaire, nous pouvons également modifier l'
apparence des boutons des objets. J'utiliserai le même cadre gris
pour les boutons que pour le panneau. J'utiliserai la même boîte
de style lorsque le bouton est enfoncé. C'est le destin quand il est désactivé. Changez le bouton en
blanc lorsqu'il est mis au point ou en jaune lorsqu'
il est survolé Je vais ajouter une texture
endommagée et une étiquette
au bouton pour afficher une
icône représentant l'objet, et un compteur indiquant le nombre d' objets
que le joueur possède
actuellement Je souhaite que l'icône conserve ses proportions et reste ancrée au
centre du bouton. En ce qui concerne le nœud d'étiquette. Je vais le mettre à 99, pour
voir à quoi il ressemble. Je vais ancrer le compteur dans
le coin inférieur droit
du bouton et
lui donner un contour épais pour le faire
ressortir de l'icône. Mais s'il s'agit d'un numéro à un
chiffre, je voudrais qu'il soit
centré horizontalement. À partir de mes icônes, je vais utiliser une feuille de sprites créée par
Shashi sur Itch Dot IO À l'aide d'une texture d'atlas, nous pouvons définir cette texture
comme un s unique provenant d'une feuille. définissant la propriété textur
comme texture Atlas, nous pouvons ensuite cliquer sur
le bouton Modifier la région, puis découper la feuille de sprites
en sprites individuels En sélectionnant une potion qui
servira d'espace réservé, je vais utiliser une potion de santé et l'agrandir pour
remplir le bouton Ces actifs sont du pixel art, qui ne devrait pas être
aussi flou Je vais devoir remplacer
le filtre de texture par
le plus proche voisin pour obtenir l' apparence
appropriée pour cette icône. Je vais régler sa taille
à 32 x 32 pixels, et il pivote pour qu'il
soit au centre, afin qu'il s'insère parfaitement
dans le bouton. Maintenant que nous avons un exemple d'article, dupliquons-le plusieurs fois pour
simuler à quoi ressemblera un
inventaire complet. Le conteneur de la grille
devra comporter plusieurs colonnes. Cinq colonnes s'intègrent
parfaitement dans l'espace. Mais nous ne pouvons toujours
conserver que 20 objets à l'intérieur du conteneur quadrillé avant qu' ils ne débordent
à l'extérieur du panneau Mémorisation des valeurs d'ancrage
que nous avons utilisées pour ce conteneur. Si nous ajoutons un conteneur de défilement, copiez les mêmes ancres pour le conteneur de défilement que
pour le conteneur de grille Ensuite, emboîtez-vous dans le conteneur quadrillé à l'intérieur du conteneur à volutes. défilement sera
automatiquement activé pour permettre de conserver un nombre
illimité d'objets Je vais réinitialiser les décalages d'ancrage
du conteneur Scroll View pour le
forcer à rester à
l'intérieur des ancrages Nous pouvons désormais supprimer tous les boutons réservés, sauf un
. Le dernier bouton doit être
enregistré en tant que scène à part entière. Un plan que nous pouvons
utiliser comme plan pour générer l'inventaire du
joueur Je vais l'enregistrer dans un nouveau
dossier de scènes pour les scènes d'interface utilisateur. Déplacez ensuite également le
menu des paramètres dans ce dossier. Ensuite, nous pouvons supprimer
le dernier bouton et supprimer tout le texte de l'
espace réservé, nous
laisse un écran d'inventaire
vide Notre panneau d'inventaire devrait également inclure un bouton de fermeture
si nous prévoyons sortir ce jeu sur
PC. Ajoutons un bouton. Re. Et ancrez-le dans le coin supérieur
droit du panneau. Notre thème possède déjà
un paramètre pour les boutons, mais nous pouvons modifier l'apparence de
ce bouton sans affecter les autres boutons
en utilisant une variation de type. Mais ajoutez un nouveau type à
notre thème d'inventaire, et cette fois, tapez simplement un nom personnalisé pour
notre bouton de fermeture. Dans le dernier onglet de notre nouveau type, nous pouvons spécifier un
type de base pour ce type, qui sera un bouton. Ensuite, en passant à
l'onglet boîte de style, nous pouvons remplacer
leurs valeurs pour utiliser boîtes de style
différentes,
spécifiquement pour les boutons fermés En utilisant le bouton X rouge préfabriqué de l'UIPac pour l'état
normal du bouton, nous pouvons ensuite sélectionner le nœud du bouton
fermé et définir sa variation de type sur le bouton
de fermeture Il utilisera ce paramètre de
thème à place des paramètres normaux des
boutons. Je vais régler sa taille à 128 pixels et le réancrer dans le coin supérieur droit. Je vais simplement utiliser la même boîte de style pour chaque état
du bouton fermé. Il s'agit de joindre un script à
notre panneau d'inventaire, le nommer inventaire et de l'enregistrer dans
le dossier des scripts de l'interface utilisateur. Il peut hériter d'un cours que nous avons écrit dans le menu essentiel du
cours. En héritant de la classe de menu, nous gérerons déjà l'ouverture
et la fermeture du menu, concentrerons sur un
élément de focus par défaut lorsque le menu s'ouvre et nous fournirons un fil d'
Ariane si nous rendons ce menu accessible
depuis un autre menu J'aimerais toutefois annuler
ces comportements afin de pouvoir désactiver le nœud joueur pendant que l'inventaire est ouvert Copier les définitions d'ouverture et de fermeture dans le script
d'inventaire et appel des
super définitions. Notre arbre de scènes devient
assez volumineux et complexe maintenant, sorte que le chemin du nœud entre le nœud inventaire et le nœud joueur nécessitera de
monter plusieurs niveaux. Lorsque vous accédez à un nœud unique
via un chemin de nœud complexe, il est préférable de
le marquer comme unique. bouton droit sur
le nœud du joueur, sélectionnez l'accès comme nom unique. Le nœud est marqué d'
un signe de pourcentage. Désormais, lorsque nous saisissons une référence
à ce nœud en utilisant add on re, le chemin du nœud est
remplacé par le signe du pourcentage et constitue désormais une référence directe à ce nœud unique spécifique. Lorsque vous ouvrez le, nous pouvons définir la propriété activée du nœud
du joueur sur Falls, afin que le joueur ne puisse ni
bouger ni sauter. Et une fois fermé, s'il n'y a plus de miettes de pain, nous pouvons réactiver
le nœud joueur afin que le joueur puisse continuer à
jouer Nous devrons également
ajouter un bouton à la carte de saisie des paramètres du
projet pour ouvrir l'inventaire. J'utiliserai la touche de retour arrière ou le bouton
de sélection de ma manette Dans le script du joueur, si vous appuyez sur le bouton d'
inventaire, nous pouvons demander au game manager
d'activer l'invention. Mais le joueur doit
être en mesure de fermer l'inventaire lorsque le nœud
joueur est désactivé Cette vérification devra
donc être séparée de la fonctionnalité de
pause. Dans le script du gestionnaire de jeu
, saisissez une référence
au menu d'inventaire. Nous pouvons l'ouvrir s'il est fermé
ou le fermer s'il est ouvert. Le script d'inventaire doit
ensuite être
capable de dire au game manager
s'il est ouvert ou non. Ainsi, en déclarant une variable booléenne, elle sera naturellement définie
par défaut sur false,
et nous pourrons la définir à l'ouverture ou à la fermeture de l'
inventaire Lorsque le
menu d'inventaire sera ouvert pour
la première fois , l'inventaire du joueur sera
probablement vide . Rien ne pourra
donc attirer l'attention. Nous pouvons ajouter une instruction if
au script de menu
pour vérifier d'abord si l'élément de focus par défaut a été défini avant de
lui demander de saisir le focus. Désormais, l'inventaire
qui n'a pas d'objet ciblé par défaut ne se donnera pas peine d'essayer de
se concentrer lorsqu'il est vide. Connectons le
signal des boutons
fermés à la fonction de fermeture du
menu d'inventaire. Et définissez la propriété visible
de l'inventaire par défaut, afin qu'il soit fermé par défaut. Essayons-le.
En ouvrant le menu, l'inventaire du joueur est vide et les mouvements
et les
sauts du joueur ont été désactivés. Mais nous pouvons toujours
fermer l'inventaire
avec le même bouton que celui
utilisé pour l'ouvrir, ce qui permet de réactiver les commandes du
joueur. Nous avons maintenant un
menu d'inventaire dans notre jeu que nous pouvons utiliser pour afficher le contenu
de l'inventaire du joueur. de la leçon suivante, nous allons
remplir ce menu avec les éléments du joueur
et permettre au joueur les sélectionner
pour obtenir plus d'
informations à leur sujet. Je te verrai dans la prochaine leçon.
6. Articles: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté un
menu d'inventaire à notre jeu. Dans cette leçon, nous allons ajouter des boutons d'
objets au menu
d'inventaire. Nos articles nécessiteront bien plus d' informations
qu'
un simple nom d'affichage, et nous ne voulons pas que ces
informations soient liées
à la scène en trois dimensions
et au modèle de l'article. Étant donné que lorsque
l'objet se trouve dans l'inventaire du joueur, il ne sera pas dessiné en trois D, mais en
deux D dans le menu d'inventaire. Nous pouvons regrouper toutes
les informations relatives à nos articles dans un script de ressources
personnalisé. Je vais le mettre dans le
dossier des ressources
personnalisées et créer un
nouveau dossier pour les éléments. Je vais le nommer élément
héritant de la ressource. Ensuite, en haut du script, nous allons attribuer à ce script
un élément de nom de classe. Ici, nous pouvons exporter toutes les variables dont
nous avons besoin pour décrire l'objet, comme son nom et sa description, ainsi qu'une texture deux D pour son icône soit dessinée dans
l'inventaire du joueur. Nous pouvons également inclure une scène en
trois dimensions de l'objet, mais nous n'en avons pas encore besoin,
et si cela n' est pas fait correctement,
nous annulerons votre projet. Pour l'instant, ajoutons
simplement un commentaire disant de l'inclure plus tard. Enregistrez le script
afin que le moteur
reconnaisse l'élément comme
une classe de ressources. En cliquant avec le bouton droit sur le dossier des
nouveaux éléments, nous pouvons maintenant créer une nouvelle
ressource de type élément et lui donner le nom de l'élément.
Je vais commencer par le At. J'exigerai
que chaque objet mon jeu ait un nom
unique et que le fichier
de ressources de cet objet
utilise également l' orthographe exacte de
ce nom pour des raisons de simplicité. La ressource doit
s'ouvrir automatiquement dans le panneau de l'inspecteur
lors de sa création. Sinon, vous pouvez l'ouvrir
en double-cliquant dessus. Nous pouvons ensuite visualiser et
modifier ses propriétés. lui donnant un nom
et une description, nous pouvons remplir l'icône
avec une texture d'atlas, en sélectionnant le
sprite approprié dans la feuille de sprites Je vais remplacer le découpage des
sprites par
une grille de 32 x 32 pixels, puis sélectionner l'icône X. Je vais également créer la ressource
d'objets de potion
de santé avec un nom, description et une icône Mais je veux que la
potion de santé soit empilable. Nous pouvons utiliser l'héritage pour
donner à nos objets
des propriétés supplémentaires. Créons une autre ressource
personnalisée héritant d'un élément
nommé stackable Ce script ajoutera
un nouveau nom de classe, élément d'extension
empilable, et il exportera simplement
une variable supplémentaire, la limite de pile de l'élément, que je fixerai par défaut à 99 En double-cliquant sur la ressource
Health potente, dans la section Rf counted, nous pouvons remplacer le
script dont cette ressource hérite par un script
empilable Nous pouvons maintenant définir la limite de taille de la
pile. Certaines autres variables peuvent voir leurs valeurs réinitialisées
lors de cette opération, et nous devrons les
remplir à nouveau Ensuite, nous devons
ouvrir les scènes des objets et modifier les anciens scripts d'objets qui leur
sont attachés. Ces scripts n'
ont plus besoin d'un nom d'affichage, mais d'une référence
à la ressource de l'article. Que nous pouvons ensuite attribuer dans
l'inspecteur pour chaque élément. Maintenant que nous disposons d'un script d'inventaire
approprié,
passons au script de progression,
rendons la variable d'inventaire publique et déplaçons la fonction d'ajout à l'inventaire vers le script d'inventaire
auquel elle appartient. Je vais le renommer pour ajouter un article, acceptant un article en tant que
paramètre au lieu d' un nœud trois d et laissant le
paramètre de quantité tel quel en revenir au script de
ressources Progress, j'aimerais autoriser
l'affichage de
plusieurs copies d' un même objet dans
l'inventaire du joueur, ce qui serait un peu plus
difficile avec un dictionnaire. Je vais donc remplacer le type
de variable d'inventaire par un tableau. Mais chaque élément du tableau
d'inventaire
a toujours besoin d'un identifiant :
le nom de l'article, et si l'article est empilable, également une quantité L'inventaire
sera donc un ensemble de dictionnaires,
chaque dictionnaire contenant le nom de l'article et éventuellement d'autres détails tels que la
quantité dans cet emplacement d'inventaire Tout détail spécifique concernant un élément qui peut être modifié et doit être enregistré
doit également
être inclus sous forme d'entrée de
dictionnaire. Si le joueur récupère 98 potions de
santé et deux haches, l'inventaire finira par
ressembler à ceci Dans le script d'inventaire, nous devrons être en mesure d'ajouter au menu
d'inventaire des boutons représentant chaque objet ou pile d'objets de l'inventaire du
joueur. Pour cela, nous aurons besoin d'un bouton
préfabriqué. Celui que nous avons créé dans
la leçon précédente et enregistré dans le dossier des scènes de l'
interface utilisateur. faire glisser un
fichier de scène dans un script tout en maintenant la touche
Ctrl ou Commande enfoncée déclarera une constante permettant de le conserver et préchargera la scène
avec un appel de fonction, renvoyant ainsi un type de scène compressé Les constantes sont classiquement
nommées en majuscules et contiennent des valeurs qui, par
définition, ne changent jamais Appelons cela un préfabriqué. Comme il contient un plan
pour un bouton préfabriqué, nous le produirons en série écrivant une fonction
qui ajoutera un nouveau bouton d'article
au menu d'inventaire, elle acceptera un article et
une quantité comme paramètres. déclarant une nouvelle variable de
bouton d'article, nous instancierons une copie
du bouton préfabriqué Modifiez ensuite la propriété de texture
des nœuds d'icônes par l'icône appartenant
à cet élément. Si la quantité est
autre qu'une, je définirai la
propriété de texte du nœud d'
étiquette du bouton comme étant la quantité
convertie en type chaîne. Et si c'est le cas, définissez sa propriété visible
sur false pour la masquer. Nous aurons également besoin d'une référence
au nœud du conteneur qui
contient les boutons. Il n'est pas nécessaire de
spécifier le type de conteneur ou d'articles, qu'il
s'agisse d'une boîte
verticale ou d'une grille Cela fonctionnera
donc si nous
voulons le modifier ultérieurement. Une fois le bouton
créé, il suffit de l'ajouter au conteneur pour qu'il soit dessiné dans le menu. Lorsque la scène de jeu se charge pour la première fois, nous devons initialiser l'
inventaire du joueur pour qu'
il soit déjà rempli avec le contenu des objets de l'inventaire du joueur En parcourant chaque objet de l'inventaire du joueur, nous ajouterons un nouveau bouton
d'objet dans le conteneur pour chaque entrée Comme la valeur enregistrée dans l'inventaire du joueur est le nom
d'une chaîne de caractères de l'objet, nous devrons
charger la ressource contenant les informations réelles sur
l'objet. faire glisser n'importe quelle ressource d'élément Le fait de faire glisser n'importe quelle ressource d'élément de l'onglet du système de fichiers vers le script
nous donnera le chemin d'accès à celle-ci Nous pouvons ensuite remplacer
le nom de l'objet dans cette chaîne par le nom de l'objet dans l'inventaire du
joueur, car ils portent tous
exactement le même nom que leur objet. Si vous souhaitez que plusieurs
articles aient le même nom mais des propriétés
différentes, la valeur stockée dans l'inventaire doit être un nom
de fichier unique, non le nom d'affichage. Nous aurons également besoin de la quantité de l'article si l'article
a une valeur quantitative. Sinon, nous pouvons simplement
supposer une quantité égale à un. Cela générera les
boutons permettant d'afficher les 98 potions et les deux axes avec lesquels le jeu a
été demandé de commencer Lorsque vous ajoutez un objet à
l'inventaire du joueur, nous pouvons d'abord déterminer s'il est empilable ou non, car le processus
sera très différent Appelez ensuite des
fonctions privées distinctes pour ajouter un article empilable
ou un seul article En ajoutant un seul objet,
nous ajouterons simplement un nouveau dictionnaire au dos de l'
inventaire du joueur. Un dictionnaire contenant
un nom, le nom de l'élément. Nous pouvons ensuite ajouter un nouveau
bouton pour cet article. Rendons la quantité facultative en lui attribuant une valeur
par défaut de un. Si l'article est empilable, le processus est beaucoup
plus compliqué Nous devons d'abord
parcourir l'
inventaire des joueurs pour trouver des
piles existantes du même objet Vérifiez si ces piles ont place pour les objets ajoutés, vérifiez si la
limite de pile est dépassée et répétez l'opération jusqu'à ce que tous
les éléments aient été ajoutés
aux piles existantes ou que chaque pile
existante soit aux piles existantes ou que chaque pile
existante S'il
reste encore des objets à ajouter, nous devrons alors créer de
nouvelles piles pour les contenir. Nous devrons parcourir
chaque pile de l'inventaire du
joueur Vérifier si le nom
des éléments stockés dans le slot I est le même
que le nom de cet élément. Ensuite, nous devons vérifier s'
il y a encore de la place dans la pile en comparant la quantité de pile
à la limite de taille de la pile. Ensuite, nous pouvons ajouter la
quantité à la pile. Ensuite, nous pouvons définir
la quantité comme étant la quantité de pile moins
la limite de taille de pile, qui est maintenant le
nombre d'articles qui dépassent la limite de taille de
pile. Donc, si la quantité est
maintenant supérieure à zéro, la limite de taille de pile
a été dépassée et nous pouvons définir la
taille de la pile à cette limite. Si la quantité dans la pile
n'a pas dépassé la limite, c'est terminé et
nous pouvons
sortir de la boucle. quantité contient désormais les objets pas encore été ajoutés à une pile, et la boucle continuera à
ajouter des objets aux piles jusqu'à ce que la quantité soit
épuisée ou que chaque pile soit pleine Une fois cette boucle terminée, s'il en reste
encore une, nous devrons générer de nouvelles piles d'
objets pour les conserver. Vérifier si la quantité est
inférieure ou égale à
la limite de pile. Nous pouvons générer une pile
de taille et de quantité. Réglez ensuite la quantité à zéro. Sinon, nous pouvons créer
une nouvelle pile complète et réduire la quantité par le montant
limite de pile et recommencer. Ajout de nouveaux boutons au menu
d'inventaire pour
les nouvelles piles Chaque fois que la quantité d'
articles d'une pile est modifiée, nous devons mettre à jour l'étiquette
du bouton pour qu'elle
corresponde à la nouvelle valeur. Créons donc une nouvelle fonction
privée qui accepte le bouton et
la nouvelle quantité comme paramètres,
le bouton ayant
le même index de tableau dans les enfants
du conteneur
que l'index d'inventaire. La quantité devra
également être
mise à jour avant de
sortir de la boucle. Définition de cette fonction,
acceptation des mêmes paramètres. Nous avons déjà
écrit ce code lors de la création de nos
nouveaux boutons d'articles. Déplaçons ce code dans notre nouvelle fonction, et
appelons-le ici également. Dans le script du joueur, nous pouvons utiliser la même méthode de nom unique
pour obtenir une référence à l'inventaire du
joueur. Ensuite, lorsque vous appuyez sur
le bouton d'interaction, ajoutez la ressource attachée à l'objet le plus proche de l'inventaire du
joueur. Pour en revenir au script
d'inventaire, pour afficher les informations sur
les articles, nous devrons également
récupérer les références au nom de
l'article et aux nœuds de
description de l'article. Écrivons une autre
fonction qui affiche informations
d'un élément sur le côté
droit du panneau, acceptant un élément
comme paramètre. lui donnant une
valeur par défaut nulle, nous pouvons également l'utiliser pour
n'afficher aucune information. Définissez la propriété de
texte du nom l'élément sur le nom de l'élément si l'
élément n'est pas nul, sinon il s'agit d'une chaîne vide,
et il en va de même pour la description. Chaque fois qu'un nouveau bouton
est ajouté au menu, nous pouvons connecter son
signal de mise au point à cette fonction. Mais la fonction nécessite
un élément comme argument, et le signal
n'a aucun argument. Nous pouvons lier des arguments à un
appelable avec un appel de fonction, en passant l'élément lui-même. Enfin, lorsque vous ouvrez
le menu d'inventaire, si le conteneur
contient des enfants, nous devons dire à l'
enfant supérieur de se concentrer. Et s'il n'a pas d'enfants, affichez les informations de l'élément,
en passant null comme argument. Essayons-le. Nous commençons avec 98 potions de santé et
deux axes dans notre inventaire, et les
informations sur les potions de santé ont attiré l'attention, affichant les
informations sur la droite Après avoir ramassé les
objets sur la table, une potion de santé a été ajoutée à la pile de 98 qui la remplissait, tandis que l'autre a créé une nouvelle pile
avec l'autre hache Comme les boutons sont focalisés, ils sont également navigables à l'aide des touches fléchées du clavier ou du pavé
directionnel de la manette L'
inventaire des joueurs est maintenant affiché dans le menu. Dans la leçon suivante, le joueur
pourra déposer ou consommer
des objets de l'inventaire. Je te verrai dans la prochaine leçon.
7. Objets durables: Bonjour, mes amis. Dans
la leçon précédente, nous avons ajouté des objets à l'inventaire du
joueur et affiché des informations sur les objets. Dans cette leçon, nous
autoriserons le joueur à déposer ou à consommer des objets
de son inventaire. Dans le menu d'inventaire, nous devrons
présenter au joueur
les options qui s' offrent à lui
pour l'objet sélectionné. Pour simplifier les choses, je vais simplement placer deux boutons sous la description de l'article organisés dans un conteneur horizontal, et les renommer
auxiliaire et Drop supprimant les boîtes de style en
remplaçant le thème du bouton, je vais juste dire
utiliser sur le bouton
gauche et supprimer sur le bouton droit Tous les objets du
jeu ne seront pas utilisables Il n'est
donc pas
logique que le bouton indique «
utiliser » lorsque la hache est sélectionnée. Il serait plus logique
de dire équiper. Ce bouton sera
sensible au contexte en fonction
du type d'élément sélectionné. Je veux que ces boutons
soient régulièrement espacés
en bas du panneau Je vais définir leur alignement
horizontal pour qu'il soit aligné avec l'expansion et le remplissage. Réinitialisez également les décalages d'
ancrage de la boîte verticale pour la maintenir
contenue dans les ancres Et dites également à la
description de l'aligner sur agrandissement et le remplissage de la
case verticale autant que possible, en appuyant sur
les boutons situés en bas du panneau. T. Dans les paramètres du projet, je vais ajouter des mappages d'entrée
pour Ue item et Drop Item Réglez ensuite le bouton X de
la manette pour utiliser et le bouton Y de
ma manette pour le supprimer. Je vais également ajouter ces
indicateurs
aux propriétés
de texte des boutons. Le joueur sait donc quel bouton de la
manette fait quoi. Les joueurs PC peuvent simplement
cliquer sur les boutons. Je supprimerais le texte X ou
Y et j'ajouterais probablement d'autres boîtes de style
pour ces boutons pour l'exportation du jeu sur PC. Dans le script de ressource de l'article, nous pouvons ajouter une
variable booléenne qui indique si un élément est
utilisable
ou non et une autre pour spécifier si l'article est
consommé lorsqu'il est Pendant que nous sommes ici, nous devrons
également accéder à la scène en trois D
contenant l'objet lui-même, afin que lorsque le
joueur dépose l'objet, nous puissions le faire apparaître dans la scène,
ou s'il utilise l'objet, nous puissions le faire apparaître
dans la main du personnage Nous ne pouvons pas à la fois donner à la scène en trois
D une référence
au fichier de ressources et également donner au fichier de ressources une référence
à la scène en trois D. Il s'agit d'une
référence cyclique et nous allons créer une boucle infinie qui interrompt toute scène
contenant l'objet T. Au lieu de cela, nous indiquerons simplement à la ressource de l'objet où se trouve la scène en trois D, lui donnant le chemin
d'accès sous forme de chaîne afin de pouvoir la
charger en cas de besoin. Ensuite, dans le fichier de ressources
de potion de santé, nous pouvons copier le chemin de la scène de potion de santé et coller dans le champ de scène Nous pouvons le configurer pour qu'il soit utilisable
et consommé lors de son utilisation. Je n'ai pas l'intention
d'implémenter un élément qui n'est pas
consommé lorsqu'il est utilisé, mais c'est une bonne idée de
rendre le code flexible. Et répétez cette opération pour
l'autre article. Dans le script d'inventaire. Nous devrons récupérer
une référence aux boutons d'action
en utilisant Add on Ready. Lorsque le bouton d'un élément est focalisé et que les informations relatives
à l'élément sont affichées, nous pouvons définir la propriété
de texte du bouton auxiliaire pour indiquer si l'élément est capable et définir sa
propriété désactivée sur false. Sinon, je vais simplement
désactiver le bouton pour le moment. Connectons les
signaux pressés sur les
boutons au script d'inventaire. J'ajouterai également une
fonction d'entrée qui indiquera au signal
enfoncé sur le bouton auxiliaire d' émettre lorsque le
bouton d'utilisation est enfoncé. Mais uniquement si le menu
d'inventaire est ouvert et que le bouton est activé. Et faites de même si vous appuyez
sur le bouton Drop Item de la manette. Normalement, je ne
mettrais pas de fonction de saisie directement dans un
script comme celui-ci, mais pour les raccourcis simples
permettant d'appuyer sur des boutons, je pense qu'il est bon de sauter l'étape consistant
à utiliser un script de
gestion des entrées distinct. Si vous appuyez sur le bouton
x à l'aide la manette ou si vous
cliquez sur le bouton
d'utilisation du menu avec la souris, cette fonction sera
appelée dans les deux cas Mais nous devons savoir
quel élément est sélectionné. Et il peut également être important de savoir quel objet spécifique se trouve dans l'
inventaire du joueur s'il possède plusieurs objets identiques. Chaque fois qu'un article attire l' attention et que ses informations
s'affichent, acceptons également
le bouton qui représente cet article
dans le menu d'inventaire lui donnant une
valeur par défaut nulle, il sera
donc facultatif, nous pouvons également lier
cet argument à l' appelable en passant le
bouton du nouvel élément comme autre argument De même, lorsque ces
boutons perdent le focus, il serait
judicieux de
ne pas afficher d' informations et de les
désactiver. Connectons également leurs signaux
sortis à
la même fonction, liant null comme arguments Si aucun élément n'est sélectionné, nous ne pouvons pas vérifier
s'il est utilisable et nous devons désactiver
les deux boutons. déclarant de nouvelles
variables privées pour contenir l'élément sélectionné et son bouton
correspondant, nous pouvons stocker l'élément sélectionné et son bouton lorsqu'
il est sélectionné. Lorsque ces
boutons d'action permettent de se concentrer à nouveau, j'aimerais indiquer au
bouton objet de rétablir
immédiatement le focus afin que le joueur sache
toujours quel
élément est sélectionné. Connecter leurs signaux
saisis focalisés, qui peuvent tous deux appeler
la même fonction. Disons que le focus du
bouton d'action est entré. Mais lorsque ces
boutons d'action entrent dans
le focus, le bouton sélectionné sort
au même moment du focus Le bouton sélectionné est désormais nul. Déclarons une autre variable appelée bouton précédemment
sélectionné qui sera définie sur le bouton
sélectionné chaque fois que la valeur du
bouton sélectionné change. Je concentre donc les modifications d' un bouton d'élément sur
un bouton d'action, le bouton sélectionné
sera défini sur null. Mais le bouton sélectionné précédemment conservera sa référence, nous pouvons
donc indiquer au bouton précédemment sélectionné de se concentrer. De cette façon, le joueur pourra
toujours voir quel élément est sélectionné
s'il clique sur les boutons
d'action. Désormais, lorsque
l'une ou l'autre action est effectuée, nous pouvons facilement accéder au
bouton sélectionné, ainsi qu'à l'objet que ce bouton représente dans l'inventaire du
joueur. Pour supprimer un élément, si
un élément est sélectionné, nous pouvons d'abord déclarer une
variable contenant une instance de cet élément et définir
sa valeur à charger, passant le chemin de la scène tel qu'il
est stocké dans le fichier de ressources des éléments
et en l'instancier Ajoutez ensuite cet élément
à l'arborescence des scènes. Vous voudrez probablement qu'il s'agisse d'un enfant du nœud de niveau qui sera automatiquement supprimé en même temps que le niveau lorsqu'
il sera déchargé Pour plus de simplicité, je vais simplement l'
ajouter au gestionnaire de jeu. Si une variable
représente une direction aléatoire
le long du plan xd, elle sera un nombre aléatoire
compris entre zéro et T. représente la
circonférence complète d'un cercle. Nous allons ensuite définir la
position globale de l'objet de manière à ce qu'elle soit proche de la position
globale du personnage du joueur légèrement au-dessus du sol, appliquant le sinus et
le cosinus à la direction pour obtenir les valeurs x et Z de la nouvelle position Assurons-nous d'abord d'avoir une référence au personnage
du joueur
en utilisant un nom unique. Et retirez l'objet déposé
de l'inventaire du joueur, en passant l'objet à retirer, une quantité d'un objet, et le bouton sélectionné qui
représente l'objet spécifique. Si le joueur appuie sur le bouton d'action
auxiliaire, si un élément est sélectionné
et que cet élément est utilisable, nous pouvons appeler une fonction
privée séparée pour utiliser l'élément sélectionné. Au fur et à mesure que d'autres utilisations du
bouton auxiliaire deviennent
pertinentes, d'autres fonctions
peuvent être ajoutées ici. Pour utiliser un objet. Si le personnage du
joueur est sur le sol et qu'il n'est pas
occupé à autre chose, j'utiliserai la variable can move, même si elle est
marquée comme privée, puis nous pouvons dire au
personnage d'utiliser l'objet. Si l'objet est consommé au moment de son utilisation, nous pouvons le retirer de
l'inventaire du joueur en passant l'objet sélectionné, une quantité d'un, et
son bouton comme arguments. Comme je vais ajouter
une animation d'objet électronique au personnage et
que je veux que le joueur la voie,
je fermerai l'
inventaire du joueur lorsqu'il demande d'utiliser un objet afin que nous puissions
voir l'animation se dérouler. Supprimer un objet de
l'inventaire du joueur revient à en ajouter
un, le comportement
étant différent
pour les objets empilables par rapport aux objets
uniques Ainsi, lorsque vous supprimez un seul article
si le bouton n'est pas nul, nous pouvons supprimer l'entrée d'inventaire dont l'index correspond à l'index enfant de ce
bouton dans le tableau des enfants du
conteneur. Et supprimez également le bouton
de l'article du
menu d'inventaire et revenez. Je vais le faire dans une autre
fonction privée afin de contrôler également correctement
les références de
boutons sélectionnées et précédemment sélectionnées. Si le bouton n'a pas été fourni, nous devrons
effectuer une recherche dans l'inventaire des joueurs
pour trouver cet objet. Une fois que nous l'avons trouvé,
nous pouvons
le retirer de l'inventaire et des
conteneurs pour enfants et le retourner. Avant de supprimer un bouton d'article, nous devons vérifier
si ce bouton a été sélectionné ou s'il a déjà été sélectionné. Et si c'est le cas, définissez ces
références sur null, afin de ne pas essayer accidentellement de référencer des boutons
qui n'existent plus. Nous utiliserons free ici
au lieu de Q free pour rendre l'effet immédiat au lieu d' attendre la fin
de l'image en cours. Ainsi, s'il est
nécessaire de
supprimer plusieurs entrées de
l'inventaire du joueur, les conteneurs
pour enfants continueront correspondre aux indices
d'inventaire. Mais en supprimant ce bouton
qui est actuellement focalisé, nous devrons indiquer à un bouton
adjacent de saisir le focus. Je vais donc appeler une
fonction privée pour passer au
point suivant
de la liste ici. manière dont cela
sera traité dépendra du nombre d'enfants que le
conteneur compte actuellement. S'il y a
moins de deux enfants, rien n'aura besoin de
nous concentrer et nous pourrons revenir. Si aucun bouton n'a été fourni
comme point de référence, nous pouvons simplement demander à l'
enfant supérieur de se concentrer. Si un bouton a été fourni, nous devrons connaître son
index enfant dans le conteneur. Si l'index suivant est valide, c'
est-à-dire qu'il est inférieur au nombre d'
enfants du conteneur, l'enfant suivant
peut se concentrer. Sinon, c'est
le dernier enfant, et nous voulons plutôt que l'enfant
précédent se concentre. Combinons cela dans
une déclaration turn re. Nous pouvons ensuite procéder
à
la suppression du bouton de l'élément maintenant qu'
il n'est plus focalisé. Le retrait d'un article empilable
sera un peu plus compliqué. Si un bouton spécifique
a été fourni, nous pouvons obtenir son
index enfant dans le conteneur. Retirez ensuite la quantité de la pile dans l'emplacement d'inventaire
correspondant. Si le résultat de la soustraction est inférieur ou égal à zéro, la pile est vide. définissant la nouvelle valeur de
quantité sur la valeur négative de la taille de pile
actuelle, cette valeur
contiendra désormais
le montant inférieur à
la quantité que le montant inférieur à
la nous
essayions de supprimer. Nous pouvons donc supprimer à
la fois la pile d'inventaire et le bouton qui la
représente dans le menu. Si le résultat de la soustraction
est un nombre positif, la pile n'est pas vide
et il suffit de mettre à jour
sa nouvelle valeur de quantité Puis revenez puisque nous avons terminé. Maintenant que nous avons fini de cocher
le bouton suggéré, s'il
reste une quantité à retirer, nous devrons parcourir l'inventaire du joueur pour trouver
d'autres piles de cet objet Nous pouvons ensuite répéter la
même logique que ci-dessus, en utilisant l'alias d'index I au lieu de l'
index du bouton. Et en supprimant le bouton correspondant dont l'index enfant correspond à
l'indice d'inventaire. Si jamais nous atteignons une
quantité nulle, c'est terminé. Dans une scène de personnage, sélection du nœud de l'arbre d'animation dans la machine à
états divers. Nous pouvons ajouter l'animation de l'
objet d'utilisation. Comme les autres
animations ici, elle commence et
se termine également par le dopose En utilisant les mêmes
paramètres de transition que pour les
autres animations, réglant
le mode avancé de transition vers
l'animation Activé et le
mode de commutation sur
Activé et le
mode de commutation
de la transition de l'animation sur Fin. Appuyer sur l'icône Play nous
permettra de
prévisualiser l'animation. Dans le script,
ajoutons une nouvelle
fonction publique pour utiliser un élément, en acceptant un élément
comme paramètre. Pour cela, nous aurons
besoin d'une référence à la main principale du personnage, afin de savoir où placer
l'objet utilisé. Ce sera également la position
principale de la main utilisée pour équiper les armes. Pour créer une nouvelle
catégorie d'équipement exportée, je vais exporter une nouvelle variable pour la position principale du
personnage avec un type d' attache
osseuse trois D. En sélectionnant le nœud racine de mon
personnage. Cet emplacement principal pour l'
équipement manuel sera le même nœud d'attache osseuse celui
qui contenait auparavant
le x. Lorsque vous utilisez un objet, nous
déclarerons une nouvelle variable contenant une instance de l'objet et lui attribuerons une valeur de charge. Passez le chemin vers les
trois scènes en D stockées dans la ressource item en tant qu'
argument et instanciez-le. Cela créera l'objet, que nous ajouterons en tant qu'enfant emplacement principal
de l'équipement manuel. Mais cet objet possède de
la physique et des collisions. Il entrera en collision
avec le personnage et sera affecté par la gravité Nous devrons définir sa propriété de
congélation sur true, afin que le moteur ignore
tout cela et la
traite comme si elle était collée
à la main du personnage. Ensuite, nous attendrons la fin de l'animation de l'objet à utiliser. Enfin, en mettant en file d'attente
l'instance
d'objet à libérer de l'arborescence de la scène, nous allons simplement supposer que la main du personnage est vide
avant que tout cela C'est là que les effets de
l'utilisation de l'élément
seraient activés, mais nous
imprimerons simplement une déclaration qui
servira d'espace réservé, afin
de savoir si cela fonctionne Corrections mineures dans
le script d'inventaire. Nous ne pouvons supprimer le bouton de l'article
suggéré qu'une seule fois. Si vous supprimez plusieurs
éléments, nous utiliserons null à chaque
fois après le premier. Et lorsque nous demandons au
bouton suivant de saisir le focus, nous ne devons pas le
mettre sur null immédiatement après. Essayons-le. En ouvrant l'inventaire,
nous avons 98 potions. Nous pouvons en utiliser une qui
ferme l'inventaire, et nous pouvons voir le personnage
tenir une potion en main, boire et elle disparaît. la réouverture de l'inventaire, nous avons maintenant 97 potions, et nous pouvons déposer certains objets, les
retirer de
l'inventaire, qui sont désormais éparpillés
sur le sol autour personnage après
la
fermeture de l'inventaire Nous pouvons même récupérer
les objets et les réajouter à
l'inventaire du joueur. Nous avons désormais des objets qui
peuvent être déposés ou utilisés depuis le menu d'inventaire du
jeu. Dans la leçon suivante, nous autoriserons le joueur à s'équiper d'
armures et d'armes. Je te verrai dans la prochaine leçon.
8. Équipement: Bonjour, mes amis. Dans
la leçon précédente, nous avons autorisé le joueur
à utiliser ou à supprimer des objets de son inventaire
via le menu. Dans cette leçon, nous allons permettre aux joueurs d'équiper leur personnage
d'objets. Chacun de nos personnages a plusieurs objets en
main, une cape et un chapeau. l'exception du
Rogue, dont le capot n'est malheureusement pas
séparé du reste du modèle, nous ne pouvons
donc pas l'utiliser comme équipement. Tous ces objets peuvent être transformés en objets selon les
méthodes utilisées dans leçons
précédentes,
que nous pouvons
récupérer et ajouter à l'inventaire du
joueur. Notez que le voleur n'a pas
d'attache en forme d'os de chapeau et que le mage n'en a pas
une en os de main. Nous pouvons résoudre ce problème en ajoutant nos propres nœuds d'attache osseuse
au personnage et en
les attachant aux bons os
du squelette. Dans la scène des personnages de Mags, nous pouvons ajouter un nœud enfant
au squelette de type « bone attachment three D et le renommer en
quelque chose comme « offhand Ensuite, dans l'inspecteur, attachez-le
à la case
« gauche »
, et ce nœud suivra automatiquement la main gauche du
personnage dans toutes les animations. faisant glisser le livre sur
cette nouvelle attache osseuse, nous pouvons voir comment il continue
de suivre la main gauche Tous les autres objets
destinés à être tenus entre
les mains du personnage peuvent être placés
dans les mains du personnage peuvent être placés les emplacements de la main principale ou non
avant d'être intégrés à leurs propres scènes afin de conserver leurs positions
et leurs rotations relatives Nous pouvons ensuite répéter
ce processus pour ajouter une attache en forme d'os de chapeau pour le personnage de la rangée
qui suit son os de tête. Je vais également réorganiser et renommer les nœuds pour qu'ils correspondent exactement
à ceux du mage La machine à chapeau Mags est également différente de celle
des autres personnages. Il est positionné plus haut
et légèrement pivoté. Pour nous faciliter la vie, ajoutons un nouveau nœud d'
attache osseuse qui suit la tête des Majes et
utilisons-le comme chapeau. faisant glisser le chapeau de son attache osseuse existante vers le nouveau, nous pourrons également connaître la position exacte et
la
différence de rotation de ce chapeau Lorsque nous créons la scène des objets du chapeau
Majes, nous pouvons faire de cette position et rotation une partie naturelle de celle-ci En utilisant ces méthodes, tous nos personnages devraient avoir les
mêmes quatre emplacements d'équipement, et n'importe quel objet peut être
équipé pour n'importe quel personnage. Les emplacements d'équipement peuvent être renommés pour des raisons de cohérence,
si vous préférez, et
les trois nœuds N non utilisés peuvent être supprimés
des scènes des personnages. Mais les cheveux
de certains personnages passeront à travers
certains chapeaux. Dans certains jeux, vous remarquerez
que
le personnage est épilé lorsqu'un casque ou chapeau est équipé pour
résoudre ce problème. Dans ces actifs, les cheveux
font partie du modèle de tête. Nous devrons donc
soit restreindre le nombre de
personnes autorisées à porter quel chapeau, redimensionner ou repositionner le chapeau en fonction de la personne qui le porte,
soit simplement ignorer le problème particulier lorsque vous utilisez
des ressources fictives, il est préférable de prendre note
des limites
et de vous assurer que les
ressources de production finales résolvent les problèmes au lieu
de les reproduire Avant de créer de
nouvelles ressources d'articles, définissons un nouveau
type de ressource d'article. Nous l'appellerons équipement,
héritage d'un objet. Cela nous permettra d'
ajouter une nouvelle variable aux articles qui entrent
dans cette catégorie, le type d'équipement
dont il s'agit, qui déterminera
comment il peut être équipé. Dans l'énumération de nos projets, nous pouvons ajouter une liste des différents
emplacements
d'équipement pour notre jeu, main
principale, main libre, tête
et dos, ainsi que tous les autres emplacements d'
équipement L'
énumération du type d'équipement peut désormais être utilisée comme type pour la variable de type d'
équipement, afin que nous puissions facilement la définir dans
l'inspecteur Passage du script
d'axe de l'article à l'équipement. Il peut être configuré comme équipement pour la machine à sous
principale du personnage. Dans le
script du personnage, nous pouvons ajouter d'autres variables pour
chaque emplacement d'équipement ou transformer la variable
en une série d' attaches
osseuses appelées douilles. Lorsque vous utilisez un objet, la
main principale est désormais la prise zéro. Attribuez ensuite chaque support de
fixation osseuse dans le même ordre dans le
tableau pour chaque personnage. Ensuite, nous pouvons ajouter de nouvelles fonctions
publiques pour indiquer
au personnage de faire ou de
faire des pièces d'équipement. enfiler une pièce d'équipement il faudra faire
référence à l'article, et pour le retirer, il suffira de l'emplacement Pour D, une pièce d'équipement
revient à peu près instancier la potion et mettre dans la main du
personnage Remplacement de la prise manuelle principale par
la prise à laquelle l'article est destiné. dopage nous oblige uniquement à vérifier si le
socket a un enfant, et si c'est le cas, à nous en débarrasser En utilisant un objet, nous ne pouvons plus partir du principe qu'
ils ont les mains vides. Déclarons une nouvelle
variable qui contiendra ce que le personnage tenait avant qu'on lui demande d'utiliser l'objet. Si la
prise principale porte un enfant, c'est ce
qu'
il tenait, et nous devrions régler
sa propriété visible Falls
pour le masquer
lorsqu'il utilise l'objet. S'ils détenaient quelque chose
avant de l'utiliser, nous pouvons redéfinir sa propriété
visible sur
true une fois l'utilisation de l'
objet terminée. Dans la ressource de progression, nous devons suivre tout ce que le
joueur a équipé. Un moyen simple de
référencer les éléments de l'inventaire serait d'
utiliser leur index matriciel L'équipement de notre joueur est donc
un tableau d'entiers chaque élément du
tableau contenant l' indice
du tableau de l'équipement
dans l'inventaire du joueur le contenu
du tableau est défini par défaut sur moins
un pour chaque entrée, nous pouvons utiliser moins un pour indiquer que
le
slot est vide Maintenant, connectons tout cela
au menu d'inventaire. Lorsque le bouton d'un article est sélectionné, nous affichons
ses informations, mais nous devons créer des cases distinctes pour les cas où il
s'agit d'un équipement. Ensuite, divisez davantage selon cet article est actuellement
équipé ou non. Dans les deux cas, le bouton
auxiliaire est activé, mais le bouton de dépôt doit être désactivé si l'
article en est équipé. Changer le bouton auxiliaire pour l'équiper ou l'équiper en conséquence. Comment savoir si l'article
sélectionné est équipé ? Nous devons connaître son indice
dans les conteneurs pour enfants, car il s'agit du
nombre enregistré dans le tableau d'équipements de
la ressource de progression. Ensuite, nous pouvons vérifier si le parc
d'équipements situé à l'index de l'emplacement
désigné par les éléments sélectionnés
correspond à cette valeur et
renvoie vrai ou faux ? Tout cela peut être fait en
une seule ligne de code. désactivation ou non du
bouton de dépôt
devra également être prise en compte
pour les
consommables et les valises nulles Lorsque le
bouton auxiliaire est enfoncé, si l'
article sélectionné est un
équipement, nous pouvons utiliser la
même condition pour déséquiper ou équiper
l'article sélectionné Pour équiper un objet,
nous allons configurer la gamme d'équipements dans la ressource de
progression à l'index de
l'emplacement de l'objet comme étant l'index de
la matrice de l'objet dans l'inventaire du
joueur. Demandez ensuite au personnage
de faire l'équipement. Je vais réutiliser l'
étiquette de l'objet,
mais en définissant son texte par
défaut sur mais en définissant son texte par
défaut un E majuscule pour l'équipement et en définissant sa propriété visible sur lors
de l'équipement Je vais également mettre à jour le texte des boutons
auxiliaires et désactiver le bouton de dépôt. Pour déséquiper un objet, nous allons régler le tableau d'
équipements situé à l'index de l'
emplacement de l'objet sur moins un, puisqu'il est maintenant vide, indique au personnage de faire ce qu'il a dans
le socket correspondant Masquez le E pour « équipé »
sur le bouton,
datez le texte des boutons auxiliaires et activez le bouton « Drop ». Mais avant d'équiper un objet, nous devons vérifier si un article est déjà équipé
dans cet emplacement, ce qui signifie que la valeur de
l'ensemble d'équipements à l'index de l'emplacement est autre
que négative Dans ce cas, nous devrions dire au personnage de faire ce
qu'il a dans ce socket Ensuite, trouvez également le
bouton dans le conteneur dont l'index correspond à celui de
la valeur du tableau d'équipements, afin que nous puissions masquer le
E pour équipé. Nous pouvons ensuite procéder à l'
équipement de l'article sélectionné. Pour que cela
fonctionne, les valeurs
du tableau d'équipements doivent toujours correspondre aux indices du tableau des objets de l'inventaire du
joueur. Mais les indices du tableau changent chaque fois qu'un
bouton d'élément est supprimé. Exigeons l'
index du tableau comme paramètre lors de la suppression des boutons des articles
du menu d'inventaire, car nous le trouvons
déjà à chaque fois de toute façon. Nous pouvons ensuite rechercher dans
le tableau d'équipements toutes les valeurs
supérieures à l'indice de l'
article à supprimer. S'il y en a, ils
peuvent être réduits d'un pour qu'ils correspondent toujours à l'
indice de l'article équipé. Dans ma ressource de progression, je vais commencer par le joueur
avec un tas de nouveaux objets dans son inventaire et j'en ai
également certains. Après avoir d'abord initialisé
l'inventaire du joueur, nous pouvons également parcourir
le tableau d'équipements Si l'emplacement de l'équipement est autre chose
que négatif, nous pouvons trouver le bouton dont l'index correspond à
la valeur enregistrée ici. Pour simplifier les choses, je vais
simplement utiliser les fonctions existantes, demandant au bouton de se
concentrer et en équipant
l'élément sélectionné Maintenant, lorsque l'inventaire
est initialisé, le joueur
est également équipé des objets tels qu'ils sont stockés dans son fichier. Essayons-le. Le personnage
commence équipé quelques objets et, en ouvrant l'inventaire, nous en avons
plusieurs parmi lesquels choisir. Nous pouvons déséquiper des objets, en
équiper de nouveaux. Si nous essayons d'équiper un
objet dans un emplacement occupé, l'article équipé n'est
pas équipé avant le changement Si nous buvons une potion, l'objet principal du
personnage est caché pendant l'animation et revient une
fois l'animation terminée Nous avons maintenant des objets
à équiper pour le personnage du joueur
via le menu d'inventaire. Dans la leçon suivante, nous autoriserons le joueur à échanger des
objets avec un PNJ. Je te verrai dans la prochaine leçon.
9. Boutique: Bonjour, mes amis. Dans
la leçon précédente, nous avons autorisé le joueur à
équiper les objets du menu. Dans cette leçon, nous leur demanderons d' acheter et de vendre des objets auprès d'un PNJ. Pour gagner du temps, je vais réutiliser le même menu d'inventaire
pour créer la boutique. Je vais renommer le
conteneur vertical en info et le dupliquer pour créer un autre contrôle avec les
mêmes ancrages et la même taille,
et le renommer en boutique Au lieu du
nom et de la description de l'objet, la boutique contiendra
un conteneur à parchemins, contenant un
contenant quadrillé contenant le
stock de la boutique , tout comme celui
contenant les objets du joueur. Le conteneur de défilement
peut remplir l'espace en appuyant sur les boutons
vers le bas. À la place du bouton
auxiliaire, j'aurai une icône représentant une pièce, le prix de l'article
actuellement sélectionné et un bouton de
transaction contextuel pour acheter ou vendre l'article
sélectionné. L'icône représentant une pièce peut conserver
ses proportions, mais elle s'adapte proportionnellement à l'
espace prévu Je vais déterminer l'espace
maximum que le prix
pourrait occuper et l'utiliser
comme taille minimale personnalisée. Le bouton peut alors utiliser le
reste de l'espace. Je vais également ajouter 32 pixels de séparation entre ces
trois commandes dans le conteneur de boîtes horizontales et modifier la propriété
de texte de la transaction en tant que tel. Remplissons le stock de la boutique avec un tas d'articles factices
pour voir à quoi ça ressemble Les colonnes de la grille doivent bien s'intégrer
dans l'espace. Pour passer de l'
affichage de l'inventaire à l'affichage de
la boutique, il suffit de basculer entre
les nœuds d'information et de boutique, et nous pouvons également modifier
le titre Lorsque vous êtes satisfait de
votre boutique sans présentation, vous pouvez supprimer les
articles factices du stock de la boutique Dans le script, je
dois mettre à jour le chemin du nœud vers le
nœud d'information pour refléter son nouveau nom. Nous aurons besoin de références
au titre,
aux informations et aux nœuds de la boutique, afin de pouvoir les
échanger,
ainsi que du conteneur qui
contiendra le stock de la boutique, l'étiquette de prix et
du bouton de transaction. Notre script d'inventaire
devient un peu volumineux. Pour
organiser des scripts plus longs
, il est utile de créer des
zones de code à l'aide de commentaires. Avec un commentaire de région au-dessus
d'un bloc de code désignant la région et un commentaire de région de
fin au bas de la région. La région peut être réduite et étendue pour mieux
organiser le script. Ajoutons une nouvelle fonction
publique qui ouvre le
menu d'inventaire en tant que boutique. Nous modifierons le titre pour indiquer
boutique au lieu de stock, définirons la propriété visible
de la vue des informations sur
False et la visibilité
de la vue de la boutique sur True. Nous pouvons ensuite appeler notre fonction ouverte
existante pour effectuer également le reste
de ces autres tâches. Nous devrons également
créer une fonction permettant d'
ouvrir le menu en mode inventaire, remettre le titre en inventaire et d' inverser la visibilité des informations et
des nœuds de boutique Le gestionnaire de jeu
ouvre le menu sous forme d'inventaire lorsque le
bouton d'inventaire est enfoncé. À l'aide du système
de gestion des événements que nous avons développé dans le cours précédent, nous pouvons associer un nœud en
zone 3 D à n'importe quel personnage de notre
scène de niveau et le renommer boutique En ajoutant une forme de collision en
trois D lorsqu'il était enfant, nous pouvons lui donner une taille
et une forme faciles à cibler
pour le joueur lors de sa refonte de l'interaction La zone 3 D n'
aura pas besoin de
surveiller quoi que ce soit
, mais elle sera surveillable sur la
couche de collision spécifiquement pour les interactions et ne comportera aucun
masque de collision Pour plus d'informations
sur les événements d'interaction, consultez le cours précédent sur le dialogue
et les événements. Créons un nouveau
script pour ce nœud, enregistré dans le dossier des
scripts d'événements. Héritage d'un événement d'
interaction. Dans ce script, nous pouvons
exporter un ensemble d'articles pour représenter le stock d'articles disponibles à l'achat. Comme tout script d'événement, nous allons écrire une fonction d'exécution d'
événements, acceptant le
gestionnaire d'événements comme paramètre, qui contient toutes
les références d'objets nos événements peuvent avoir besoin
pour faire leur travail. Dans ce cas, le responsable de l'événement
aura besoin d'une référence à l'inventaire du joueur et la boutique si vous utilisez
un menu distinct pour celui-ci. Cela permettra également au
gestionnaire d'événements d'ajouter ou de supprimer des objets de l'inventaire du
joueur
lors d' événements ou de
dialogues si nécessaire. Le script de la boutique peut ensuite demander au responsable de l'événement d'
ouvrir le menu de la boutique. transmettre une référence à
lui-même est un argument, sorte que l'inventaire
aura accès
au stock et à toutes les autres
variables publiques souhaitées. Donnons-lui un nom de
classe de boutique, afin que le script d'inventaire
puisse accepter une boutique comme paramètre lors de
l'ouverture du menu en tant que boutique. Pour utiliser la commande await
pendant l'événement, notre fonction d'ouverture en tant que boutique doit
également renvoyer
un signal d'attente. En acceptant la boutique
comme paramètre, nous pouvons enregistrer une référence à celle-ci lors de l'ouverture du menu d'
inventaire en tant que boutique. Le signal renvoyé se produira lorsque le menu d'inventaire sera fermé. Nous pouvons émettre ce signal
à chaque fois que la fenêtre est fermée, même si personne ne l'
écoute, lorsque le menu est ouvert en tant qu'inventaire
du joueur. Pour rendre nos boutiques encore plus uniques, exportons également une ligne de
dialogue destinée au vendeur en guise d'introduction et une autre en
guise d'outro Ajoutez-les ensuite à la fonction d'
exécution de l'événement sous forme dialogue
supplémentaire avant et
après l'accès à la boutique. Et dites au game manager de
mettre fin à l'événement. Nous pouvons même exporter un multiplicateur de
valeur appelé markup pour donner aux différents fournisseurs des prix
différents
pour leurs articles Je vais définir le balisage par défaut
pour qu'il soit dix fois supérieur à la valeur. Remplissons la boutique du
soir pour y inclure la
potion de santé et la hache A ainsi qu'une ligne de dialogue d'introduction et d'
outro. Dans notre ressource personnalisée, nous pouvons attribuer à chaque article une valeur sous forme d'entier avec une
valeur par défaut d'une pièce. Chaque objet du jeu peut ensuite se voir attribuer une valeur
différente, qui dans ce cas sera pour lequel le joueur peut
vendre un objet. Mais nous achèterons à
dix fois ce prix. De retour dans le script d'inventaire, il serait également utile d'
afficher les pièces du joueur. Faisons de ce nœud un
nœud unique et saisissons-le également. Nous pouvons ouvrir le compteur du portefeuille lorsque l'inventaire est ouvert et lui dire de rester ouvert
en utilisant true comme argument. Dites-lui ensuite de fermer lorsque
l'inventaire sera fermé. Contrairement à l'
inventaire du joueur où nous initialisons les
nombreux boutons lors du chargement, puis nous ajoutons ou supprimons des boutons au fur et à mesure que des objets sont ajoutés ou
retirés de l' Le stock de la boutique devra être généré chaque fois que le joueur
interagit avec le vendeur, et complètement vidé une
fois ses achats terminés est
assez simple de vider le stock, il suffit de parcourir
chaque enfant du conteneur de stockage et de
les mettre en file d'attente pour qu'ils soient
libérés de l' Nous pouvons également définir shop sur null ici ou dans la fonction de
fermeture. Nous pouvons vider le stock à chaque fois que le menu d'inventaire est fermé. Si le menu d'inventaire a été ouvert en tant qu'inventeur et
non en tant que boutique, le contenu du stock de la boutique
sera de toute façon vide. Le processus de génération du stock est à
peu près le même que celui de générer l'inventaire
initial du joueur
, de parcourir chaque article
du stock de la boutique,
puis d'appuyer sur le bouton Ajouter un article Mais nous aurons besoin d'un nouvel argument pour spécifier le conteneur auquel
le bouton est ajouté. Ajoutez ensuite le paramètre à
la fonction correspondante, en lui donnant la valeur par défaut
du conteneur d'objets du joueur. Ces informations concernant le
conteneur dans lequel se trouve ce bouton seront également pertinentes lors l'
affichage
des informations sur les articles, ainsi que lorsque le bouton de
transaction est enfoncé. Nous pouvons stocker ces informations
dans les métadonnées des nœuds. Ajoutons une nouvelle entrée
aux métadonnées de notre
nouveau bouton, avec le nom est dans l'inventaire, avec une valeur indiquant si
le conteneur auquel il est
ajouté est égal au conteneur d' objets du
joueur. Désormais, chaque bouton sait quel côté du menu de la
boutique il se trouve. Lors de l'affichage
des informations d'un article, si un bouton est sélectionné, nous pouvons obtenir ses métadonnées en utilisant le même identifiant que celui
présent dans l'inventaire. Si l'objet se trouve dans l'inventaire du
joueur, nous pouvons attribuer à l'
étiquette de prix la valeur de l'objet et définir la propriété de texte du bouton de
transaction sur x sell. Pour simplifier les choses, je n'autoriserai pas le joueur à
vendre les objets qu'il a
équipés et je désactiverai le bouton de
transaction dans ce cas. Si l'article est en stock dans
la boutique, texte du prix sera valeur de
l'article multipliée
par la majoration de la boutique Et le
texte des boutons de transaction a été changé en x par. le bouton
soit désactivé ou
non dépendra du fait que les pièces
actuelles du joueur sont inférieures au prix. Lorsque vous vérifiez si l'article
sélectionné est équipé, assurons-nous qu'
il existe un article sélectionné et qu'il s'agit également d'un
équipement. Dans la fonction de saisie, si la variable shop n'
est pas nulle, nous pouvons revenir pour empêcher la vérification des
fonctions d'utilisation de l'article ou de suppression d'un article. Si vous appuyez sur le
bouton d'utilisation de l'article, que nous réutilisons ici
pour déclencher l'action d'achat
ou de vente, tant que le
bouton de transaction n'est pas désactivé, nous pouvons émettre le signal sur lequel il est pressé En connectant le signal du
bouton de
transaction au script, je le déplacerai dans
la zone boutique. Si aucun article n'est sélectionné ou aucune boutique n'est
actuellement contactée, nous pouvons simplement le retourner Si le bouton sélectionné se trouve
dans l'inventaire du joueur, le bouton de transaction
vendra l'objet actuellement
sélectionné. Augmenter le nombre de pièces du joueur
en fonction de la valeur de l'objet et le retirer de
l'inventaire du joueur. Sinon, le bouton sélectionné doit se trouver dans le stock de la boutique, ce qui signifie que le
bouton de transaction va l'acheter, réduisant le nombre de
pièces du joueur par la valeur de l'objet multipliée
par la majoration de la boutique, en ajoutant l'objet à l'inventaire du
joueur et en vérifiant à nouveau si
le bouton d'achat
doit être désactivé ou non le bouton d'achat
doit être désactivé Une petite correction lors de la
mise à jour de la quantité sur un bouton devra définir sa propriété
visible sur true. Dans le script de progression. Je vais commencer le jeu
avec un peu d'argent. J'ignorerai également l'avertissement de conversion à
aile étroite généré par la transformation de ce
float en un entier. N'oubliez pas que le
menu d'inventaire doit commencer à fermer. Essayons-le. En parlant de la nuit,
nous sommes accueillis par une ligne de dialogue
avant l'ouverture de la boutique, qui expose également nos pièces. Le bouton de transaction affiche vente lorsque vous sélectionnez nos articles. Mais elle est désactivée lorsque l'article
sélectionné est équipé. Nous pouvons vendre des objets
de notre inventaire, ce qui nous donne plus d'or. Le
bouton de transaction affiche l'achat lorsque vous sélectionnez les articles en stock de la
boutique, mais il est désactivé lorsque nous n' avons
pas assez d'argent
pour acheter l'article. Nous pouvons acheter des objets auprès
du vendeur en dépensant notre or. Et quand nous fermons le magasin
maintenant, la nuit nous remercie. Nous avons maintenant une boutique dans
notre jeu afin que le joueur puisse acheter et vendre des
objets auprès d'un PNJ
10. Quoi faire ensuite ?: Bonjour, mes amis.
Avant de commencer, vous devriez avoir un projet avec un personnage capable se déplacer dans un environnement et
des ennemis à combattre. Vous pouvez également
avoir besoin d'un menu d'inventaire capable d'équiper des objets, y compris au moins
une arme mala, une arme arrangée et un bouclier Tout au long de ce cours, nous
ajouterons des commandes, des mécanismes et des animations à notre projet
pour fixer une cible,
attaquer, esquiver, bloquer
et tirer des projectiles