Transcription
1. Introduction aux systèmes de portes et aux portails interactifs: Bienvenue sur les systèmes de portes
et portails interactifs Unreal Engine Five Blueprint Mastery , le seul
atelier complet entièrement dédié à la création de mécanismes de
portes avancés et Il n'y a vraiment rien
d'autre comme ça là-bas. Un atelier tout-en-une complet où vous apprenez
à concevoir, construire et animer une large gamme de systèmes de portes dans un seul endroit
structuré et pratique Trop souvent, les développeurs de jeux se
heurtent à un mur lorsqu'ils essaient créer des systèmes interactifs
qui vont au-delà des bases. La synchronisation de l'animation
pour les poupées doubles, la conception d'énigmes complexes ou mise en œuvre de mécanismes de
téléportation peuvent sembler Cet atelier résout tout cela en combinant tout ce dont
vous avez besoin dans un seul cours. Imaginez apprendre étape par
étape avec tous les outils, ressources et conseils dont
vous aurez besoin pour réussir. Qu'il s'agisse de déclencheurs basés sur des collisions ou de systèmes de
téléportation à plusieurs niveaux, vous exploiterez tout
le potentiel de la programmation en boucle d'Unreal Engine Five Dans cet atelier, vous aurez
accès à 41 leçons et plus de 8 heures de contenu
exclusif que vous
ne trouverez nulle part ailleurs. Vous commencerez par les éléments essentiels tels que les interfaces en boucle et configuration
du mode de jeu
avant de passer
à des techniques avancées telles que l'animation
synchronisée, mécanismes de
verrouillage et les systèmes de puzzle
complexes Nous commencerons par
les éléments essentiels tels que les interfaces de plan et la configuration de Gamo avant de passer
aux techniques avancées,
notamment les
animations synchronisées, les mécanismes de verrouillage
et les systèmes de puzzle et À la fin, vous maîtriserez même les mécanismes de
téléportation et effets visuels
dynamiques, ce qui vous permettra de rendre
vos systèmes de portes
impeccables et immersifs Mais ce qui distingue vraiment cet
atelier, c'est la clé de niveau
modulaire exclusive à la science-fiction pour créer des projets
de qualité professionnelle. À la fin de cet atelier,
vous maîtriserez la communication par plan pour une interactivité avancée, créerez des systèmes de
portes immersifs allant de simples animations à des transitions complexes
à plusieurs niveaux,
mettrez en œuvre des états sûrs pour
garantir que vos mécanismes
persistent d'un niveau à plusieurs niveaux,
mettrez en œuvre des états sûrs pour
garantir que vos mécanismes
persistent et ajouterez des touches finales de
qualité professionnelle telles que des effets sonores et des systèmes de particules
dynamiques Que vous conceviez
votre premier projet ou que vous élargissiez votre portefeuille, c'est
l'occasion d'acquérir des compétences que vous ne trouverez dans aucun
autre cours. Participez au seul atelier complet sur
les systèmes de portes disponible et donnons
vie à vos idées avec un véritable moteur 5, systèmes de portes
Blueprint Mastery et un cours sur le portail interactif
2. Introduction à Unreal Editor et ajout du modèle de troisième personne: Bonjour et bienvenue sur de vrais portails
Engine Five Blueprint Mastery, Door Systems et
Interactive. Commençons par extraire le pack de
ressources Doors que
nous avons téléchargé En cliquant dessus avec
le bouton droit de la souris, je vais utiliser WinRAR et extraire le pack de ressources de
deux portes Maintenant, si vous avez WinZip, le processus est un peu le même Vous choisissez une destination
et il l'extrait. Maintenant, pour moi, il l'a
extrait ici sur le bureau sur lequel j'
ai téléchargé le fichier. Et avant de continuer, vérifions dans la
bibliothèque Unreal Engine sur l'onglet Unreal Engine que nous avons la version 5.4 0.4, qui est la version du projet Si vous êtes dans la
version ci-dessus, c'est cinq. Passons maintenant à notre projet. Je vais double-cliquer
et ouvrir le projet. Cela peut prendre un certain temps en
fonction de la vitesse de votre ordinateur, mais nous avons inclus le cache de données dérivées et
le dossier intermédiaire, qui hébergent les fichiers qui
facilitent ce processus. Des fichiers tels que des shaders qui ont déjà été chargés lors de la création du projet Maintenant, pour ceux qui sont nouveaux, expliquons ce que
nous voyons ici. Tout d'abord, cette
image est notre fenêtre d'affichage. Nous pouvons nous déplacer en utilisant le bouton gauche de la souris, en
déplaçant la souris vers le haut, vers le bas, à gauche et droite, et en utilisant WSAD pour nous déplacer dans l'espace mondial
comme dans un jeu vidéo Q et E élèvent
et dénivelent également. Je ne sais pas quel mot
c'est, mais de toute façon, notre personnage, notre personnage, notre
personnage, notre caméra. Maintenant, comme vous pouvez le voir,
c'est un peu lent. Donc, si j'utilise la molette de la souris
tout en maintenant le bouton droit de la souris enfoncé, je peux aller plus vite avec la molette de la souris haut et je peux aller plus lentement
avec la molette de la souris enfoncée. Cela peut être indiqué
ici par la vitesse de la caméra. Je peux également le changer en
modifiant la valeur ici, mais la molette de la souris semble
être un peu plus facile. Maintenant. Nous n'entrerons pas dans les
détails de nombreux boutons. J'en expliquerai quelques-unes, mais je le ferai lorsque
nous ouvrirons notre carte. Pour ce faire,
allons donc ici, qui est le navigateur de contenu. Et ici, nous pouvons voir les cartes et les sons de nos
actifs. Ils sont inclus dans
notre pack de ressources Doors. Maintenant, pour les actifs, nous
pouvons en voir quelques uns, mais nous les démontrerons
plus tard sur la bonne carte. ce qui concerne les sons, nous pouvons voir certains sons que nous
devons utiliser dans ce didacticiel. Et sur les cartes des dossiers, nous pouvons voir les cartes prédéfinies. Si nous les
abordons très rapidement, ouvrons la carte du didacticiel 2. C'est une petite pièce que nous
utiliserons plus tard comme salle de transfert, et nous allons passer à la carte du
didacticiel sans numéro. Et ici, nous pouvons
voir nos atouts et notre niveau que nous
utiliserons pour construire nos portes. Tout d'abord,
commençons par poursuivre
l' explication de ce que
nous voyons dans cet écran. Comme nous pouvons le constater, c'est beaucoup d' informations, mais
n'ayez pas peur. Ce sont des choses très simples. Ici, nous avons l'aperçu
qui, comme vous pouvez le voir, est à peu près
réalisé au niveau 1, niveau 2, au niveau 3,
et quelques objets supplémentaires Il s'agit de dossiers dans lesquels nous
avons classé les éléments que nous incluons dans ce sac de ressources. Dans les dossiers suivants, nous les classons en
fonction des niveaux auxquels nous
allons créer les portes Vous pouvez également voir un dossier
d'éclairage, qui contient les accessoires d'éclairage, et nous pouvons voir de nouveaux dossiers ici qui ne
contiennent rien, ainsi que le
dossier Playground qui a été laissé Alors, euh, commençons par
expliquer ces dossiers vides. Maintenant, quand j'ai un dossier qui contient quelque chose, tout d'
abord, il a une flèche et nous pouvons
voir à l'intérieur de son contenu, où ces dossiers n'
ont rien. Ces dossiers ont également un œil à côté d'eux,
qui est fermé. Si j'essaie de cliquer
dessus, rien ne se passe. Ces dossiers
sont donc un peu vides. Nous pouvons les supprimer,
nous n'en avons pas besoin. Donc, la prochaine chose à faire est de
voir notre dossier d'éléments supplémentaires. Je vais cliquer dessus, et je vais
cliquer sur l'œil. Maintenant, vous pouvez voir les objets
disparaître de notre champ de vision. Cela ne signifie pas qu'ils
ne sont pas chargés dans le jeu. Si j'appuie sur Play, nous pouvons
clairement voir les objets. J'appuie sur Play, et le jeu
est en cours d'exécution, et les objets sont là. Fermer les yeux ici ne
veut donc pas dire que nous les
perdons dans le match. Cela signifie simplement que nous pouvons
travailler sans les regarder. heure actuelle, nous allons fermer les yeux
à tous les niveaux sauf au niveau 1, car nous allons
les utiliser au fur et à mesure de notre progression éditoriale. Maintenant, pour les éléments supplémentaires, ouvrons les yeux et
voyons ce que nous avons ici. La vitesse est un peu élevée. OK. Corrigez-le avec une
molette de souris, et nous pouvons le voir maintenant. Nous avons une double porte et, selon les différentes mesures
que nous pouvons
utiliser, annuler les modifications. Nous avons un cadre,
pareil pour la porte. Je pense que c'est la porte
qui se déplace de cette façon, et nous avons une lumière au-dessus, des triangles que nous
allons utiliser pour les objets, une porte de salon que nous allons utiliser pour
notre magasin de physique, un interrupteur que nous
allons animer Un bouton que nous
allons animer, un bouton déclencheur, qui est également
composé de deux mailles, tout comme le bouton, un
portail, des boîtes et d'autres types de portes,
une vitre, c'est une étagère Maintenant, c'est un escalier. Je
pense que c'est un escalier, des murs, des sols, et c'est une petite
démonstration de tous les atouts. Oui, ce sont des pièces séparées. Mais encore une fois,
c'est à notre niveau. Maintenant, pour continuer à expliquer ce que nous voyons
ici, comme nous l'avons vu, le bouton de jeu est
utilisé pour jouer au jeu, pour démarrer ce que
nous avons créé, et le bouton d'évasion est utilisé pour arrêter. Maintenant, la prochaine chose dont je veux parler et
que nous allons
utiliser , c'est que lorsque je sélectionne
quelque chose ici, nous avons un talon détaillé Donc, lorsque j'apporte quelque chose
au monde et que je veux
voir ses propres détails, c'est par exemple parce que je
peux avoir deux étages. Si je dois utiliser Alt et que je vais faire
glisser ce R ici. Cela reproduit donc le sol. Si j'utilise ce sol
et cet étage, il s'agit du même maillage, mais ce sont des exemples. Ils ont des détails différents. Par exemple, l'emplacement de
ces deux blocs change. Il s'agit de Y 600 et de Y 980. Et si je change cela, l'échelle, cela passe à
cette instance unique. Voici donc les détails de
l'instance que je sélectionne. Il existe différents détails en
fonction de ce que nous avons sélectionné. Tout ce qui concerne les détails de l'instance sélectionnée
se trouve donc ici. Maintenant, une autre chose
qui se passe dans Outliner, c'est que lorsque je
choisis quelque chose ici, il sélectionne en fait
l'instance Et si c'est loin
ou si je ne sais pas vraiment où se trouve
ce que j'ai sélectionné ici, je peux appuyer sur F. Et il
zoomera
autant que possible sur notre maillage en moment parce que j'ai
sélectionné ce maillage. Si je sélectionne un autre acteur, il zoomera sur cet acteur. Maintenant, attention, car si
je sélectionne la sphère céleste, par
exemple, et que j'appuie sur F, cela me fera sortir de
la sphère céleste pour la sentir, pour que tout soit affiché à l'écran. Maintenant, revenons à un point. Nous allons passer à l'intérieur. Et je pense que nous avons expliqué certaines choses à propos de
ce que nous voyons. Nous sommes plus polyvalents lorsqu'il s'
agit d'utiliser Unreal. Et avant de passer à
autre chose, je vais aller dans le navigateur de
contenu et cliquer sur le bouton «
at » ici. Parce que je souhaite ajouter une
fonctionnalité ou un pack de contenu. C'est un moyen d'ajouter les
fonctionnalités et les packs de contenu proposés gratuitement par
Area lorsque
nous créons un projet. Et le contenu,
la fonctionnalité que je
souhaite ajouter en ce moment, c'est le modèle à la
troisième personne. Nous avons donc un personnage
que nous pouvons déplacer et quelques autres choses que nous
expliquerons dans la prochaine leçon. Pour l'instant, je vais
appuyer sur Ajouter un projet. Cela peut prendre un certain temps. Quand c'est fait, une fenêtre
s'ouvre. Voilà, ouvrez une fenêtre de navigateur de contenu
dont nous n'avons pas besoin, nous pouvons la fermer et nous pouvons maintenant
voir de nouveaux dossiers ici,
le dossier des personnages, le prototypage des niveaux et le dossier à la troisième personne Mais nous allons explorer
cette question la prochaine fois. Au revoir pour le moment. À bientôt.
3. Les bases de l'interface Blueprint Mode de jeu, apparition de personnages et configuration du plan de niveau: Bienvenue sur
Unreal Engine Five, Blueprint Mastery, Door Systems
et les portails interactifs La dernière fois, nous avons donc arrêté le téléchargement de notre personnage
à la troisième
personne en ajoutant à notre projet le modèle à la troisième personne. Voyons maintenant ce que
contient modèle à la troisième
personne. Nous avons un dossier de plans. Nous avons un dossier d'entrée
et un dossier de cartes. Les cartes contiennent un modèle de carte à la troisième
personne Si je l'ouvre
et que j'appuie sur Play, je peux voir le personnage à la troisième
personne. Je peux déplacer des boîtes. Je sais sauter et c'est à
peu près tout. Maintenant, lorsque nous allons sur notre
carte et que nous appuyons sur Play, il n'y a rien de tout cela. On ne voit aucun personnage
sauter partout. Nous avons juste une caméra qui bouge. Eh bien, pourquoi ça ? La raison en est qu' à l'intérieur du support à la troisième personne, nous pouvons voir les plans
pliés, dans
lesquels figurent le personnage à la troisième
personne que nous utilisions
et contrôlions,
et qu'il contient le mode de jeu à la troisième
personne BP Qu'est-ce qu'un mode de jeu ? Un
mode de jeu est un plan spécial dont les règles sont
spécifiées par niveau. Par exemple, à ce niveau, nous n'aurons qu'un seul mode de jeu. Sur le modèle de
carte à la troisième personne, nous avons un autre mode de jeu. Eh bien, nous aurons la
même chose, mais pour le moment, nous n'avons pas de mode de jeu ici, c'est
donc un mode de jeu par défaut. Il ne s'agit pas d'un mode de
jeu à la troisième personne. Alors, comment changer le mode de
jeu sur notre carte ? À côté des détails ici, nous pouvons voir les paramètres du monde. Maintenant, si vous ne pouvez pas
voir les paramètres du monde, nous pouvons aller dans Windows et activer ici, les paramètres
du monde, et il apparaîtra comme
ça quelque part sur la mise en page, ou il apparaîtra
ancré ici, ce
qui, comme vous pouvez le voir, vous pouvez l'
ancrer où vous le souhaitez Vous pouvez même l'amarrer ici. Mais c'est l'endroit le
plus utilisable. Quoi qu'il en soit, comment modifier les
paramètres du monde, le mode de jeu ? Comment le contourner
? Eh bien, il y a ce mode de jeu
optionnel ici dans lequel nous pouvons définir le remplacement du mode de jeu et sélectionner notre mode de jeu à la troisième
personne BP, et ce sera tout, en gros Si j'appuie sur Play maintenant, le
personnage apparaîtra. J'apparaîtrai en train de
tomber et de mourir. Maintenant, pourquoi n'
apparaît-il pas où je voulais ? Eh bien, je peux tout d'
abord contrôler ça avec mon appareil photo. Je peux appuyer sur Play ici, et
le personnage apparaît ici. Mais pourquoi, dans l'autre cas, la carte
apparaissait-elle toujours à
un certain endroit, même si nous n'avions pas
la caméra sur place ? Eh bien, la raison en est que mode
jeu possède des fonctionnalités
supplémentaires, des fonctionnalités
que nous allons
remplacer plus tard dans le didacticiel Mais cette fonctionnalité
consiste à faire apparaître le personnage. Et quel personnage, cela
dépend d'une autre fonctionnalité
appelée classe de pion par défaut Et ici, nous pouvons voir que
la classe de pion par défaut est le personnage BP à la troisième
personne Si je ne le dis à personne, appuyez sur Play, presque rien.
Je ne peux même pas bouger. Je vais revenir
au personnage à la troisième personne, et nous devons définir
un point de départ pour le joueur. Comment s'y prend-on ? Un nouveau
bouton apparaît ici. Eh bien, cela n'apparaît pas, mais nous allons l'
expliquer tout de suite. Je vais donc cliquer dessus,
et c' est le
bouton pour
ajouter rapidement quelque chose à votre niveau,
quelque chose à la
fenêtre d'affichage, en gros,
parce que plus tard, la
fenêtre d'affichage possède plusieurs niveaux Comme vous pouvez le voir dans mon irréel, il y a un onglet de niveau ici
, appelé sous-niveaux, mais nous n'y reviendrons pas Maintenant, allons-y et
ajoutons un joueur de départ. C'est le point de départ de notre jeu.
Voilà à quoi ça ressemble. Il possède une manette et un
drapeau et cette forme de capsule, qui est une collision, est en fait une collision de forme de capture. Je vais commencer par cette
paire quelque part ici. Je vais appuyer sur le bout, pour
qu'il touche le sol. Et je vais appuyer sur Play. Maintenant, vous voyez, nous avons
notre personnage ici, et
peu importe où il se trouve, notre caméra. C'est comme si ici, en appuyant sur Play,
le personnage était là. Maintenant, comment cela est contrôlé, nous le verrons plus tard prochains
tutoriels, car
nous allons remplacer
ses propres fonctionnalités
en ce qui concerne la façon dont le mode
de jeu
choisit le point de départ du joueur Maintenant, nous avons créé
un point de départ pour les joueurs. Nous avons ajouté notre mode de jeu
et le personnage sponsor que nous allons incarner
et tester notre code. Mais avant de
passer à la première porte, fermons à nouveau
tous les niveaux. Cela ne semble pas économiser. Cela semble être un paramètre
temporaire. Il existe d'autres moyens de masquer la visibilité par le biais
du code et des ressources, mais nous ne le ferons pas pour le moment. Donc, avant de nous plonger dans les
plans et de commencer à coder, expliquons un
peu ce que sont les plans Eh bien, Blueprints est le véritable système de
script visuel du moteur Et qu'est-ce qu'un système de script,
un système de script visuel Envisagez d'avoir des
blocs de code comportent facilement et de simplement qui
se comportent facilement et de simplement connecter cette
logique dans l'ordre vous souhaitez utiliser le code qui a
été réécrit tant de fois Il n'est pas toujours efficace
de réinventer la roue, réécrire le code qui a
été écrit tant L'URL propose un système de plan, composé de blocs de code prêts à l'emploi dans une représentation visuelle
qui font certaines choses, et nous les organisons dans un ordre
spécial afin qu'il soit
logique que la machine
sache ce que nous lui demandons de faire Cela signifie que nous avons également de nombreux types
de plans différents Par exemple, il existe un plan de
niveau que nous
utiliserons pour contrôler notre première porte Mais en plus de cela, il existe des plans de
widgets
qui contrôlent l'interface utilisateur Il existe des plans d'acteurs qui font des
choses spécifiques dans notre jeu Par exemple, notre
remplaçant sera un acteur. Il existe des
plans de personnage qui sont notre personnage que nous
utilisons et contrôlons Il existe des
plans d'animation qui contrôlent l'animation du
personnage Il y a le
mode de jeu Blueprint, qui est le
plan spécial du niveau Par exemple, quelles sont
les règles du niveau ? Il peut héberger une certaine logique
multijoueur. Il a une demande spécifique. C'est pourquoi il s'agit du
mode jeu Blueprint, le plan de la manette du joueur Je sais que cela peut sembler
effrayant pour quelqu'un de nouveau, mais c'est juste un système pour
classer les fonctionnalités Nous avons le système
pour les widgets, nous avons le système
pour les personnages. Nous avons le système
pour les animations, le système pour le
multijoueur et le gameplay. Tout est classé
en systèmes spécifiques, un
système très bien optimisé que le réel propose. Commençons maintenant par ouvrir
notre premier plan, qui serait le plan de
niveau,
un plan dédié à Je vais aller
sur ce bouton, un nouveau bouton. Mais lorsque j'appuie dessus, nous pouvons
voir certaines options pour créer une nouvelle classe Blueprint afin de
convertir les sélections
en classe Blueprint Mais ce que nous voulons, c'est un plan de niveau
ouvert. Ce n'est pas une image typique
que nous voyons sur un plan, mise en page
typique, mais elle
suffit à expliquer certaines choses Ici, nous avons
le graphe des événements, qui héberge les fonctionnalités
de notre plan C'est ici que nous
écrivons une grande partie de notre code. À côté, nous pouvons voir
le panneau de détails, qui
sélectionne actuellement la classe par défaut. Ici, nous pouvons voir le
débogage de notre plan, utiliserons lorsque
nous allons déboguer le code
que nous sommes Et sur le côté gauche, on peut voir mon onglet Blueprint Dans d'autres plans,
nous verrions un onglet composants et d'
autres onglets ici,
un script de construction, qui est utilisé pour
publier du code et de la logique lorsque nous exécutons le plan dans l'
éditeur avant la carte Nous allons démontrer
un peu cette logique. Et le belvédère, qui, en fait,
allons les voir. Parler d'eux
sans
les voir n'est pas une bonne idée. Sur le
fichier de contenu, je vais cliquer avec
le bouton droit de la souris et
créer un nouveau dossier. Et je vais nommer
ce dossier blueprints. Je vais également attribuer un code
couleur à ce dossier. Je vais
cliquer dessus avec le bouton droit de la souris, sur cette couleur et le mettre en bleu. Et dans ce Blueprints, je vais cliquer avec le bouton droit de la souris
et accéder au cours Blueprint Et ici, nous pouvons voir les différents types de plans dont nous avons
parlé plus tôt L'acteur, le pion, le personnage,
la manette du joueur, le mode de jeu basé sur
le mode de jeu, le composant acteur, les composants de
synchronisation Différents, il existe de
nombreuses classes de plans que nous pouvons créer Ce que nous allons sélectionner
maintenant, c'est juste un acteur. Je vais appeler ce test PP. Et ouvrons-le. Maintenant, comme vous pouvez le constater, c'est la différence avec
la carte du didacticiel. Ici, nous avons
juste le graphe
d'invention mon plan et mes détails Alors qu'ici, nous avons
l'onglet composants, la fenêtre d'affichage, le script
de construction et le graphe d'invention Cela a de toute façon des hochements de tête pour démontrer
certaines fonctionnalités. Et nous avons ici
l'onglet composants. C'est ce que je voulais
expliquer : dans la fenêtre d'affichage, nous pouvons ajouter des éléments
à notre plan Par exemple, nous pouvons ajouter un cube, et nous allons programmer ce tube dans ce plan
pour qu'il adopte un certain comportement Alors qu'ici, dans la carte des niveaux, parce qu'il s'agit du niveau, nous n'avons pas
ce hub de fenêtre d'affichage Et la raison en est
que la fenêtre de la carte du didacticiel
est essentiellement cette fenêtre Dans ce niveau, tout
est essentiellement un composant. Ce n'est pas le cas, mais cela peut en être
une composante. En disant cela, apportons
une copie d'une porte. Je pense que c'est
la porte avec une poignée. Je vais ouvrir cette porte. Je vais appuyer sur Alt
et l'amener ici. Et je vais le faire pivoter. Comme ça. Non, je le veux de
l'autre côté. Comme ça. 90 degrés Accédez aux détails -90. C'est bon Comme vous pouvez le constater, cela ne
fonctionne pas très bien. Mais ce que je vais
faire, c'est qu'ici, nous avons le
point de rupture à dix heures Je vais en choisir cinq, puis
aller le baisser. Et je pense que ça s'est bien passé. Oui, eh bien Maintenant, je vais accéder
à la carte du didacticiel, cliquer avec le bouton droit de la souris
et créer une référence au Prop pack EU six ou six Tu veux dire ? Maintenant, c'est
parce que j'avais sélectionné. Lorsque j'ai sélectionné quelque chose, disons, pour
cet exemple de mur, je peux cliquer avec le bouton droit de la souris et
y
faire référence dans le plan de niveau Nous n'avons pas vraiment besoin du mur. Je vais le supprimer.
Nous avons juste besoin du pack d'accessoires. C'est la porte,
appelons-la porte désormais, et c'est la première porte. J'ai renommé le mur. C'est pourquoi c'est au niveau 1. Cela
ne devrait pas être au niveau 1. C'est ce que je choisis. C'est censé
être sous forme d'articles supplémentaires. Je vais le déplacer
d'ici au niveau 1, et le glisser-déposer ici. Il serait
peut-être plus
facile de fermer le fichier et de le renommer
ici pour le porter aussi bien Ce n'est pas le bon mur. Et nous avons la porte ici. Donc, pour le moment, nous l'avons renommé. En compilant ici, vous pouvez voir que le nom a également changé ici. Alors, que voulons-nous faire de
cette porte ? Nous l'avons ici. Ce que nous allons faire, c'est
le programmer pour qu'il s'ouvre et se ferme en fonction de la
proximité du joueur. Non, c'est trop cool. En fait,
le joueur s'en approchera, la porte s'ouvrira. Le joueur se rendra
à un autre endroit et la porte se fermera. Quoi qu'il en soit, je pense que j'ai dit
trop de choses pour cette leçon. Je te verrai dans le prochain. Mais mon
4. Principes fondamentaux de la programmation Blueprint pour les débutants: Là où nous nous sommes arrêtés, c'est
en ajoutant cette porte ici. Nous l'avons copié depuis la porte, nous l'avons pressé et traîné, et nous l'avons apporté ici Nous y avons également créé une référence
, notre plan de niveau. H. Commençons par faire
quelque chose avec cette porte. Et en faisant quelque chose, je veux dire simplement le
faire pivoter pour l'ouvrir. Pour ce faire, j'ai
sélectionné la porte, appuyant sur E, et comme nous pouvons le voir, est devenu le rotateur En appuyant sur R, l'échelle Imo
passe à l'échelle Imo, et W déclenche le déplacement. Nous pouvons également voir ces
sélections ici. Ce que nous devons faire, déplacer cette
porte, c'est la faire pivoter, et il s'agit d'un acteur statique, acteur étant le mot-clé. Pourquoi est-ce le cas ? Parce que, comme nous l'avons dit, plans ont un comportement
prescrit. J'en tire un câble à
partir de notre référence la porte et je demande un acteur. Ce que nous voulons changer, c'est
la rotation donc la rotation. Vous pouvez voir que nous avons quelques
options concernant la rotation. Obtenez la rotation de l'acteur, nous pouvons définir la rotation de l'acteur. Nous pouvons définir l'
emplacement relatif et la rotation. Nous parlerons du
relatif et de la différence entre relatif et
monde dans une leçon ultérieure. Mais pour le moment,
nous allons simplement
utiliser la rotation des acteurs définis, qui est une rotation mondiale. Je vais choisir ce
nœud de rotation défini des acteurs. Maintenant, ce nœud a une
exécution et pour la sortie, notre valeur de retour, qui est rouge, rouge est le pollen, nous
en reparlerons plus tard. Une rotation, des entrées et
une physique de téléportation. Lean peut voir que
les choses sont codées par couleur, ce qui nous amène
à un nouveau sujet. Que sont les variables ? Les variables sont comme de petites cellules d'information
vides. Quel type d'information
est le type de variable. Nous avons laissé le
plan M expliqué. Alors, qu'héberge mon Blueprint ? Mon plan contient des
informations sur notre code. Comme vous pouvez le voir, il vous montre les éléments qui appartiennent
au plan,
les variables, les graphiques qui se trouvent ici, nous avons les graphiques de catégories Si nous passons à, passons aux graphiques. Vous voyez, il y a
déjà quelques événements, cet événement gris pour nous. Si je double-clique dessus, je peux être redirigé vers tous les événements. Un événement existe donc dans notre graphique, nous pouvons y accéder directement
à partir d'ici. Nous pouvons également créer de nouveaux graphiques
pour des objets, par exemple, s'agira du graphe de
bout en bout,
du graphe de mouvement ou de tout
autre graphique que nous voulions Nous pourrions donc avoir différents
graphiques avec différents événements, mais je ne peux pas avoir le
même ou les mêmes graphiques d'événements. Cliquez avec le bouton droit de
la souris et lancez l'événement de début de partie. Je peux l'apporter ici et
je peux l'avoir ici aussi. Cela ne fonctionnera cependant pas. Je fais glisser le pointeur d'ici et je
tape print string, qui est un nœud qui
imprime juste une chaîne et connecte ici et également
connectée à l'autre graphe. J'essaie de compiler,
vous verrez que je vais avoir une erreur liée à plus d'une
fonction portant le même nom. Nous ne pouvons pas avoir le même
événement dans les deux graphiques. Ils doivent avoir
un nom différent. En fait, vous n'avez pas besoin
du test du plan, mais c'est sympa de le montrer La prochaine chose dont nous avons besoin est la catégorie de fonctions.
Que sont les fonctions ? Eh bien, dans North, il existe des blocs
réutilisables codant des blocs de logique qui peuvent avoir des
sorties de retour . Les entrées peuvent être appelées plusieurs fois
depuis différents endroits. Le plan issu d'
autres plans. Elles sont idéales pour effectuer des tâches
spécifiques réutilisables. Ils ont des
règles spécifiques, mais la fonction doit compléter la logique
avant de revenir. Ils doivent terminer
tout ce qui se passe ici, sinon ils auront un résultat. Et si je clique ici pour les sorties, je veux obtenir cette valeur. Tout ce qui
se passe ici doit se terminer ou continuer à fonctionner. Par exemple, si j'amène
cette fonction
ici et que je la connecte ici,
elle devra terminer ses opérations pour que
le code continue. Le suivant. La catégorie
suivante est celle
des macros dont nous n'
aurons pas besoin au départ Nous ne nous embêterons
donc pas
avec elles. Ce sont des fonctions qui,
comme je l'ai dit, ressemblent à des fonctions,
mais plus polyvalentes, nous pouvons avoir plusieurs entrées
d'exécution Et cela nous amène
au point d'exécution. Comme vous l'avez déjà vu, j'ai
branché ce câble ici. Lorsque j'ai parlé de la rotation des acteurs
définis, j'ai dit qu'il y avait une entrée d'exécution ici
et une sortie d'exécution. Ces exécutions doivent être
connectées pour que notre code puisse être exécuté. Cela ne fonctionnerait pas
car il est vide. Et comme vous pouvez le constater, des événements tels que début du jeu n'ont qu'
une seule sortie d'exécution peuvent être considérés
comme « faire quelque chose ». Faites quelque chose, commencez à jouer, faites quelque chose sur le tic-tac
que nous avons vu ici, faites quelque chose sur l'
acteur, commencez à vous chevaucher. Nous avons également
des événements personnalisés que nous pouvons créer nous-mêmes et
les appeler dans notre code. Maintenant, nous devons déplacer notre porte
avec la rotation de notre acteur défini. Donc, notre rotation des portes, passons aux détails à -90 Arrondissez ce chiffre de
89,999 à -90. Disons que lorsque
nous commençons à jouer, supprimons la fonction. Disons que nous voulons que
la porte passe à zéro. Alors maintenant, si j'appuie sur Play, la porte n'est pas nulle. Et lorsque j'appuie sur Stop, je peux voir la raison Y
dans le journal des messages d'erreur, savoir que la mobilité de la
porte n'est pas réglée sur mobile. Je vais donc
cliquer sur la porte. Ici sur ses queues, il va passer à la mobilité
et utiliser le mobile. Alors maintenant, si j'appuie sur Play,
la porte est ouverte. Je pense que c'est tout pour celui-ci. Je vais continuer la suivante en
5. Utiliser les chronologies pour des animations fluides dans Unreal Engine: Bonjour et bienvenue
sur les vrais portails Engine Five, Blueprint Mastery Door Systems
et Interactive. Auparavant, nous nous sommes
arrêtés avec OD OpenRDOR. Nous avons utilisé notre événement
Door reference ou Begin Play, nous avons utilisé la logique prédéfinie
de rotation des acteurs définis. Et nous avons fixé la
rotation des acteurs à 000. Et lorsque nous appuyons sur Play, nous pouvons voir que la
porte est maintenant ouverte. Je voulais l'ouvrir dans
l'autre sens, je pourrais en mettre deux -180 et
il s'ouvrirait dans l'autre sens Et si je voulais
le changer à chaque fois, mais que je voulais que cela
se produise aussi, par exemple, j'avais quatre références D, et je veux qu'elles
aient toutes la même rotation. Ce dont j'aurais besoin
ici, c'est d'une variable. Pour cela, je peux
entendre le bouton plus, ou je peux cliquer
directement avec le bouton droit de la souris ici et le transformer en variable, appelée nouvelle rotation Je pourrais le renommer en
utilisant la variable ici et en modifiant la
rotation de la porte Maintenant, comme vous pouvez le voir, il est apparu ici dans l'onglet de
mon plan sur les variables de section Montrons la création
de l'autre manière. Je vais le supprimer, et je vais également supprimer
cette variable, et je vais ajouter une variable
et la faire pivoter. Si un glisser-déposer
ici me demande d'obtenir ou définir, cela signifie que
nous obtenons la valeur
de cette variable. Cela signifie que nous
allons attribuer une nouvelle valeur à la variable. Si je sélectionne Set, par exemple, nous pouvons voir des
broches d'entrée et des broches de sortie. Nous pouvons également voir qu'elle est en couleur car cette variable
est de type booléen Je clique et je vois un tas
de types de variables. Les plus
courants sont les booléens,
qui sont des « oui » ou des « non »,
qui consistent essentiellement à
coder des termes,
qu'il s'agisse de zéros Donc, un booléen, voilà ce que c'est. Un zéro et un, vrai ou faux. Ensuite, nous aurons des entiers
qui seront des nombres entiers. Par exemple, un, deux,
trois, quatre, cinq, six, ou moins un, deux, trois, quatre, cinq,
six, montant illimité. Eh bien, pas illimité.
Ils ont une limite. Je pense que la limite
est liée
au quintilion et aux flux,
qui seraient les nombres
avec des décimales.
En gros, ce au quintilion et aux flux, qui seraient les nombres
avec des décimales.
En gros, sont
les vrais Ensuite, nous avons le nom,
la chaîne et le texte. Les chaînes sont tous des caractères, et le nom et le texte
ont des règles spécifiques. Maintenant, les vecteurs, les vecteurs sont ici des
flottants à trois points, en gros Si j'apporte un vecteur, si
je crée un vecteur ici, changeons le type de variable. Nous pouvons voir qu'il a XY
z. Il est à trois points. Je peux le diviser ici, cliquer avec le bouton
droit sur le nœud de
l'épingle ici et le diviser, voir trois flotteurs, en gros C'est ce qu'est un vecteur. Cela peut devenir une couleur. Cela
peut devenir un mouvement. Cela peut devenir tout ce que
trois points représentent. Cela peut devenir un lieu. Et nous avons ici
un vecteur spécifique
, appelé rotateur Si je vais ici et que je
sélectionne un rotateur, qui se trouve en dessous du vecteur, et que je change le type de variable Je ne veux pas le configurer. Je veux me le procurer. Maintenant, un raccourci rapide
serait que si je glisse
et que je dépose ici avec la touche
Ctrl enfoncée, j'obtiens un getter. Si je glisse et que je dépose ici
avec une touche Alt enfoncée, j'obtiens un setter. Maintenant, si je le connecte ici, je compile, je dois toujours
compiler et enregistrer, et je vais accéder à
la variable et la changer , disons, -60 Maintenant, empilez à nouveau et appuyez sur Play, et nous pouvons voir que la
porte est à moitié ouverte. Bien sûr, si je m'en approche
, rien ne se passe. Et maintenant, nous avons une variable pour modifier la
rotation de la porte. Donc, si nous avions beaucoup de
portes, par exemple, nous pourrions utiliser cette
variable ici pour modifier
la rotation. Si nous voulons
que
cela se produise, nous pouvons le retarder. Il s'agit d'un nœud qui crée
un style temporel dans notre code. Par exemple, il attend le montant
que nous avons défini en termes de
durée pour terminer et
passer au code Disons donc que nous
attendrons 2 secondes avant que
cela ne se produise. Revenons à la carte. Jouons. Regardons la porte.
Et en 2 secondes, la porte s'est déplacée et s'est ouverte. Il s'agit donc d'un nœud
de retard lié au temps. Donc, comme notre code fonctionne par
blocs, comme nous pouvons le voir en logique,
il serait logique de logique,
il serait logique prévoir un
petit délai ici, modifier
un peu la rotation, mettre un petit délai, de
modifier la rotation, mais de mettre quelques petits délais que l'œil ne pourrait pas
détecter, par exemple. Eh bien, il existe un comportement
scripté. Il existe
déjà un comportement écrit pour cela pour nous. Comme dans de nombreux
langages de programmation et dans les plans, eh bien, de grands programmeurs
ont créé des outils Ces comportements
sont
donc faciles pour Ce que nous ferions pour
obtenir cet effet, c'est ce que l'
on
appellerait une chronologie à
chaque petit mouvement. Nous allons
rechercher une chronologie
et appuyer sur Ajouter une chronologie. Comme vous pouvez le constater, il s'agit d'un nœud plus
compliqué par rapport au simple retard ou même par rapport à la rotation
définie de l'acteur. Il possède de nombreuses entrées. Jouez, jouez depuis le début, arrêtez, inversez, inversez
depuis la fin, définissez une nouvelle heure, nouvelle heure, le montant
que nous fixons, puis mettez à jour,
terminez et une direction. La direction a une nouvelle couleur, et nous ne
la voyons pas ici. On dirait que la morsure que cela pourrait se
traduire par une morsure, pour être honnête. C'est pourquoi ils
ont des couleurs similaires. Mais il s'agit, comme nous pouvons
le voir lorsque nous couvrons, d'une direction temporelle E AM. Le E au début
commence pour EAM, abréviation
d'énumération En gros, il s'agit d'une liste
prédéfinie que nous
avons créée et qui ne peut pas être
modifiée pendant l'exécution. C'est une liste de ce que nous voulons. Il est certain que le nœud spécifique s'appelle direction, et si nous faisons un nœud égal. Equal Enum, nous pouvons voir ici les options dont il dispose en
avant et en arrière Il existe de nombreuses
façons d'utiliser les nombres. Le plus courant est celui d'
un interrupteur dont vous pouvez voir qu' il active la direction de la
chronologie E, du même nom que l'énumération ici car ils sont
énumérés Ils doivent avoir la même
énumération connectée à eux, qui comporte un avant
et un arrière Cela peut être connecté, par
exemple, à la mise à jour, ce qui signifie que tant que la chronologie est
en cours d'exécution, faire quelque chose, ou elle peut être connectée
pour terminer lorsque la chronologie a fini de
faire ce qu'elle
fait, ont-ils fini d'avancer ou
ont-ils fini de revenir en arrière Nous allons bientôt l'utiliser
. Ou maintenant, nous allons simplement le supprimer parce que nous
n'en aurons pas besoin. Ce dont nous aurons besoin, c'est de
connecter la rotation des acteurs définie lors de la
mise à jour de la chronologie . Supprimons. En fait, ne
supprimons pas. Connectons-nous simplement depuis la
fin pour jouer. Lorsque le délai est
terminé, jouez la chronologie et déplacez
notre acteur, faites pivoter notre acteur. Mais à quoi jouons-nous ? Il n'y a rien. Nous n'avons rien
configuré pour jouer. Nous n'aurons pas affaire à
une nouvelle époque et nouvelle époque, car c'est
un peu plus avancé que ce que nous
faisons actuellement. Ce que nous devons faire,
c'est entrer dans la chronologie. Comme vous pouvez le constater, il s'agit
d'un nœud très spécial. Donc, si je double-clique dessus, nous l'ouvrons ici,
et ici, nous avons le
graphique des événements, et voici la chronologie, le port spécifique. Nous avons un camion dont nous
allons voir ce que c'est. Cela va
ajouter quelque chose comme système
Tessian,
comme, par exemple, un camion de flux.
Nous allons utiliser ce que je
vais faire, c'est appuyer sur la touche Shift
et cliquer ici pour
créer un point, puis cliquer sur Shift pour créer un point Maintenant, ces deux points
ont un temps et une valeur. Si je mettais le temps à
zéro et la valeur zéro, ce serait le milieu
de notre système cartésien Si je passe à la suivante
et que j'appuie, disons combien de temps il faudrait pour ouvrir la
porte. Supposons le point 0,5
et la valeur de un, nous pouvons voir que cela est passé à
la valeur un dans le temps 0,5. Nous avons maintenant une pente avec laquelle nous
pouvons conduire quelque chose. Comme vous pouvez le voir, le reste des boutons est le bouton de longueur
qui, si je fais un
zoom arrière en 5 secondes, arrête la chronologie. Je pourrais régler ce paramètre sur 2,5, et cela arrêtera
la chronologie ici. Mais il y a un autre bouton
ici, utiliser la dernière image-clé Même si j'ajoute un camion
plus gros en 5 secondes, remarquerai que
la dernière image-clé est à 0,5 et cela arrêterait
la chronologie Maintenant, s'il y avait encore
plus de pistes, il faudrait prendre la dernière
image clé de la piste la plus longue. Maintenant, bien sûr, il existe
certaines options comme la lecture automatique, comme la boucle et d'
autres options à faire, dont nous n'aurons pas
besoin pour le moment La seule chose que nous
allons devoir
faire est de nommer cette nouvelle piste, cliquer et d'appuyer sur F deux ici, et je vais activer
cette rotation de porte Alpha. Je vais économiser. Je
vais clore la chronologie parce que nous
n'en avons plus besoin. Assurez-vous que nous avons utilisé la dernière image-clé si
vous avez 5 secondes, et je vais fermer ceci Nous avons donc maintenant une nouvelle épingle, la rotation de la porte Alpha. Il s'agit de la valeur
0-0 0,5 secondes 0-1. Cela fonctionnera pendant 0,5 seconde. Il sera mis à jour
pour ce montant, et cela correspondra à une
valeur de 0 à 1 pendant cette période de 0,5 seconde. Maintenant, comment puis-je
connecter cela ici ? Il n'y a pas d'épingle verte. Eh bien, ce que je peux utiliser, c'est, encore
une fois, un nouveau nœud avec un
comportement prescriptif appelé nœud d'alerte, qui est un
nœud mathématique, un larp, qui est une interpolation
de A à B, en
gros, et je peux
connecter le B ici, qui est ma destination
et ma rotation initiale,
qui était de -90, qui était de -90 Ensuite, je peux connecter
cet Alpha ici. Je peux également choisir le chemin le
plus court si nécessaire, mais cela peut
parfois gâcher les choses. Ainsi, en fonction de vos rotations, vous pouvez choisir de
cocher cette case ou non Je vais aller sur Mar
Map et appuyer sur Play. Et c'est à -60. Mettons-le à moins 180 parce que nous voulons ouvrir
vers l'intérieur. Mais ça a marché.
Nous l'avons vu fonctionner. Oui, la porte s'
ouvre d'elle-même, attend 2 secondes, et cette chronologie
anime notre porte Je pense que c'est
suffisant pour celui-ci. Je te verrai dans
le prochain. Au revoir.
6. Créer des ouvertures de portes interactives avec des déclencheurs de collision: Bonjour et bienvenue
sur Unreal Engine Five, Blueprint Mastery Door Systems
et les portails interactifs Précédemment, nous avons
expliqué quelques points concernant la chronologie
et son fonctionnement. Nous l'avons ajoutée au plan
cartographique de notre didacticiel. Nous utilisons l'événement Begin Play. Nous avons utilisé le délai et nous avons
joué la chronologie pour définir la rotation de l'acteur en
fonction du larp d'un rotateur Nous avons créé une variable
pour notre nouvelle rotation, et nous avons également
créé, dans la chronologie, un flow truck
0-1 en 0,5 seconde. Nous avons également cliqué sur la dernière
image-clé, sorte que la longueur de la chronologie n' aucune importance par rapport à sa durée Il faut la dernière image-clé. Maintenant, cela se produit
lorsque nous commençons à jouer. Mais ce que nous voulons
faire, c'est que cela se produise lorsque le joueur
s'approche de la porte. Comment ferions-nous cela ? Nous avons ce système de détection de collision, ce qui signifie que nous avons un système pour comprendre
quand un objet, disons, par exemple, un joueur entre en collision avec quelque chose Par exemple, le mur, pourquoi ne
pouvons-nous pas sortir de ces murs ? Ce n'est pas qu'ils soient
solides ou quelque chose comme ça. Nous indiquons au
programme que pour notre pion,
pour ce personnage, il se comporte comme solide, par
exemple, cela
m'empêche de me déplacer Alors, comment est-ce que cela se passe ? Passons à notre bouton Ajouter rapidement
au projet et
recherchons un déclencheur. Boîte à gâchette
Apportons-le ici, et vérifions-en les détails. Je l'ai
agrandi un peu pour que nous puissions
voir certaines choses. Lorsque nous recherchons les détails, il existe un onglet spécifique appelé
collisions. C'est ici. Et dans cet onglet, nous pouvons voir
ces préréglages de collision. Ainsi, chaque objet dans Unreal, comme le mur, le déclencheur de
collision, la capsule,
sur lequel le joueur apparaît,
possède ses propres Nous avons un moyen d'attribuer un type d'objet qui
définit quel est le type d'objet que nous lui avons défini (voir
celui-ci est dynamique par mots). Mettons cela sur mesure. Nous pouvons donc changer un
peu cela. Personnalisé, je peux modifier le
comportement de ce déclencheur au-delà de son préréglage
d'origine Comme si le
préréglage d'origine était un déclencheur, je pense que c'est un déclencheur. Et avec la coutume, je peux
dire : Non, tu sais quoi ? Vous allez
bloquer les statiques des murs ou vous allez bloquer des pions. Si j'appuie sur Bloquer
les pattes, sur Play, nous le trouverons ici.
Oh, oui, c'est ici Tu vois, je ne peux pas le dépasser.
Il bloque l'étang. Alors que s'il
chevauchait l'étang, je le traverserais simplement Laissez-moi voir où se
situe la collision. Faisons en sorte que cela soit visible. Si je vais ici et que je donne de la visibilité à la
presse. Non, en fait, il est caché dans le jeu. Si je déclique dessus, je peux le voir sur la carte Il se trouve donc que vous
travaillez en même temps. Nous ne l'avons pas encore programmé. Une autre chose à propos des collisions est qu'elles
sont généralement invisibles. Ils sont toujours cachés dans le jeu. Donc, par exemple, notre porte, nous avons ce déclencheur
devant elle. Et il sera
responsable de l'ouverture et, en fait, pour simplement ouvrir la porte, agrandissons-la un
peu. Déplaçons-le ici. Peut-être un peu
plus grand, plus large. Oui, je pense que c'est
un bel endroit. Utilisons donc cette collision. J'ai sélectionné le déclencheur, je vais passer au plan des
niveaux Je vais cliquer avec le bouton droit de la souris et créer une référence
à la boîte de déclenchement. Je vais compiler. Maintenant, comment
utilisons-nous cette boîte de déclenchement ? Eh bien, comme nous l'avons vu sur les préréglages de
collision, il existe trois réponses principales :
superposition, blocage et ignorance. Remettons cela en place pour déclencher déjà les paramètres de collision
par défaut Donc, ce que nous voulons, ce
n'est
pas lorsque nous ignorons, ni lorsque
nous bloquons parce que nous ne nous soucions pas de
ces chaînes et qu'elles sont quasiment activées. Mais lorsque nous nous
recoupons, nous voulons faire quelque chose où le
joueur est probablement impliqué Nous pouvons vérifier que les joueurs
se chevauchent. Revenons à
notre boîte de déclenchement et tapons drawable et tapons overlap Et nous pouvons voir un tas
de commandes pour cela. Nous pouvons avoir des acteurs qui se chevauchent. Nous pouvons avoir des
composants qui se chevauchent, ce qui est différent de celui des acteurs Nous pouvons nous chevaucher d'acteurs. Nous pouvons nous demander s'il y a un
chevauchement avec notre joueur. Mais nous pouvons voir d'autres choses assigner et lier ici, assignées au début du chevauchement d'un acteur, assignées à la fin du chevauchement d'un acteur, événement à un acteur au début du chevauchement et d'un événement
à la fin du chevauchement d'un acteur. Il n'y a pas
vraiment de différence entre assigner et lier. Ils utilisent tous les deux essentiellement la liaison. Appelons d'abord Assign. Attribuer à un acteur, commencer le chevauchement. Et appelons également bind. Donc, liez le chevauchement. Liez l'événement en cas de chevauchement de
début réel. Comme vous pouvez le voir, ils appellent
tous les deux bind. La différence est qu'un panneau crée également un événement pour nous. Eh bien, si nous appelons bind, nous devons créer
l'événement nous-mêmes. Et pour ce faire,
nous nous basons simplement sur événement pour créer un événement personnalisé. Pourquoi nous nous appuyons sur un événement Parce que la
liaison sur une boîte de déclenchement
nécessite des entrées spécifiques. Il ne s'agit pas
d'un événement personnalisé comme les autres. Il s'appelle événement personnalisé,
mais il ne s'agit pas d'un événement personnalisé. Vous pouvez voir qu'il a
ces deux entrées ici, comme il a également celle-ci. Si je crée moi-même un
événement personnalisé, vous verrez qu'il n'a rien. Je dois créer
ces entrées moi-même. Mais si je
crée ces entrées, comme si j'ajoutais deux entrées, elles devraient être de type ou de référence
à un objet. Vous verrez que je suis
maintenant capable de le connecter ici. Je peux compiler et cela
fonctionne parce que cela nécessite essentiellement ces
deux références d'objets acteurs. Donc, depuis que je
les ai créés, tout va bien. Si je les enlève, laisse-les faire. Donc oui, vous voyez, il n'a pas les entrées, donc il ne peut pas déléguer. Ce n'est pas compatible. Quoi qu'il en soit,
continuons
à expliquer quelles sont ces deux références à des
objets acteurs. L'acteur de superposition désigne
notre boîte de déclenchement, gros, quelle que soit la collision de
boîte de déclenchement que nous avons utilisée. L'autre acteur est celui
qui s'est superposé. Donc, ce que nous devons faire maintenant, c'est supprimer tout cela et commencer à jouer un
peu plus loin. Nous allons le déconnecter. Je vais utiliser Alt et
cliquer pour le déconnecter, et je vais le
connecter ici. Lorsque le jeu commence, liez quelque chose à cette
boîte de déclenchement lorsqu'elle commence à se chevaucher. C'est donc quelque chose.
Qu'est-ce que ça devrait être ? Tout d'abord, nous devons nous demander si l'autre acteur
est le joueur. Pour ce faire, pour vérifier si l'
autre acteur est le joueur. Il existe différents moyens. le moment, nous allons le
faire avec un nœud de casting, qui est un peu plus
cher que les autres solutions, mais c'est un bon moyen de
montrer le casting. Alors, qu'est-ce que le casting ? Appelons-le d'abord. Je vais appeler le
casting à la troisième personne. Personnage. En gros, c'est
demander, êtes-vous cela ? L'objet entrant
est celui que
nous demandons. Nous sommes donc en train de le lancer. La raison pour laquelle nous y optons
est généralement parce que nous voulons obtenir
des informations sur cet objet. Encore une fois, il existe d'autres
moyens que casting pour le faire
à plus grande échelle, mais pour nous pour le moment, cela
ne posera aucun problème. Ainsi, par exemple, si je voulais connaître la vélocité
du personnage, je pourrais taper ici
vélocité contre vélocité, et j'obtiendrais la vélocité du personnage à
la troisième personne
ou quelque chose de plus précis. Comme si je voulais
vérifier la collision d'une capsule.
Composant Apsu Voici com, qui est spécifique
à un personnage. Nous savons que chaque
personnage possède une capsule, donc je peux obtenir ces informations
auprès du personnage. Maintenant, si nous avions quelque chose spécifique
instantané
dans ce personnage, par
exemple, si nous avions un PV, nous pourrions obtenir les PV de
ce personnage à partir d'ici. Alors que si nous ne le faisions pas, je ne pourrais pas me procurer,
disons, de nouveau une capsule. n'y a pas de
composant get capsule car l'autre acteur peut
être n'importe quel type d'acteur. Mais avec le casting, nous
demandons aux acteurs de passer à la troisième personne. Êtes-vous un personnage à
la troisième personne ? Et si c'est le cas, donc si
le casting réussit, nous pourrons en tirer des
informations Si le casting échoue, cela signifie que ce n'est pas ce que nous demandons. Nous allons donc nous demander c'est ce qui entre en collision avec
l'autre personnage,
le personnage à la troisième personne Si c'est le cas, nous
allons simplement jouer la chronologie, et ce serait tout. Compilons. Allons près de la porte et
la porte s'est ouverte. Je pense que c'est
suffisant pour celui-ci. Au prochain, nous allons fermer la porte. Nous allons mettre quelque chose
ici pour entrer ici, nous ouvrons la porte, nous marchons
ici, nous fermons la porte. Mais c'est pour celui-ci. Je te
verrai le prochain. Au revoir
7. Techniques de collision avancées dans Unreal Engine: Bonjour, bienvenue sur
Andrea Engine Five, Blueprint Mastery, Door Systems
et les portails interactifs. Lors de la dernière leçon, nous nous sommes
arrêtés en créant cette collision : lorsque le joueur s'approche,
la porte s'ouvre. ce faire, nous avons utilisé
le plan de niveau et nous avons créé l'événement de liaison dans notre boîte de déclenchement
au début de
Overlap Ainsi, lorsque notre joueur
se chevauche, nous déclenchons cet événement Nous sommes en train de vérifier s'il s'agit de notre
joueur, car cela aurait
pu être autre chose
avec notre nœud de distribution, puis nous
déclenchons notre chronologie. Maintenant, mettons un
peu d'ordre dans les choses. Et créons un
système similaire pour fermer la porte. Je vais donc
sélectionner notre déclencheur. Je vais le copier-coller, contrôlez bien le contrôle C. Et je vais le
déplacer ici. En fait, j'aurais pu
faire de même en
utilisant simplement le t et en le
faisant glisser depuis une flèche Donc, copier/coller ou Alt et
faire glisser serait la même chose. Maintenant, je vais
le réduire un peu. Je vais l'avancer un peu. Maintenant, je vais créer une référence en le
sélectionnant dans la fenêtre d' affichage et en revenant à notre plan de
niveau,
je
vais cliquer avec le bouton droit de la souris et créer une référence
pour déclencher la case 2 Maintenant, encore une fois, nous devons utiliser l'événement de liaison sur
Actor begin overlap. Je vais donc utiliser cet
événement, copiez-le ici. Je vais connecter
le déclencheur
car c'est la cible. Target fait référence à
qui, par exemple, je lie cet événement et
à partir de l'événement, je vais créer
un événement personnalisé. Disons que c'est terminé
, fais Tigger. Je vais l'apporter ici. Je vais copier le casting pour le personnage à
la troisième personne. vais le placer ici et je vais relier
ces deux invertis Alors allons-y et jouons. Et quand on s'approche de la porte, elle ouvre la porte. Si je vais ici, ça
va fermer la porte. Peut-être qu'un déclencheur est
un peu plus gros, mais c'est bon.
Ouais, ça marche Donc, ce que nous faisons,
c'est essentiellement le même calendrier, nous faisons marche arrière à partir du
moment où le calendrier est Par exemple, si nous allons
directement dans cette case,
rien ne se passera. C'est aussi une belle façon de
démontrer quelque chose. Si j'appuie sur Alts, je m'éjecte dans la fenêtre d'affichage Veillez à ce que cela ne
fonctionne que sur cette fenêtre. Si je lance un jeu autonome, si je joue sur le nouvel
éditeur Window Pie, si j'appuie sur Alts,
cela ne fonctionne pas Je ne peux pas m'éjecter d'ici, mais je peux m'éjecter d'une fenêtre d'affichage Jouons donc simplement dans la fenêtre
sélectionnée, d'accord. Maintenant, je vais utiliser alts et
éjecter depuis cette fenêtre, et je vais apporter la carte du
didacticiel ici, le plan de la carte du didacticiel En fait, un peu plus grand, non ? Nous en avons besoin. Et c'est un véritable
moyen de déboguer visuellement les moyen de déboguer visuellement Vous êtes en train de sélectionner le plan que
vous souhaitez voir fonctionner. Parce que si j'avais deux de
ces plans sur notre carte, je ne pourrais pas avoir de plans à
deux niveaux,
mais s'il s'agissait d'un autre
type de plan
et que j'en avais deux fois ou 100 fois, ils
apparaîtraient tous
ici mais s'il s'agissait d'un autre
type de plan et que j'en avais deux fois ou 100 fois, ils
apparaîtraient tous J'ai donc besoin de savoir
lequel je suis en train de déboguer, lequel je vois pour déboguer Je vais donc sélectionner la carte
du didacticiel. Et dézoomons un peu le
code, apportons-le ici,
et je vais revenir
à notre jeu
en appuyant sur F huit. Maintenant, je n'avais pas vraiment besoin
de m'éjecter, mais c'était une bonne
occasion de montrer l'éjection Bref, F huit, revenons
à notre personnage. Maintenant, je déplace le personnage. Et je vais passer en revue celui-ci. Vous pouvez voir que c'est en train de se déclencher. Ça se chevauche. Il fonctionne, mais rien ne se passe. Rien ne se passe parce que
c'est déjà fini. Cela déclenche donc pendant
une fraction de seconde,
une image pour vérifier
que c'est bien à la fin. Où, si je vais ici, ça se déclenche tout le temps. Si je vais ici maintenant, ça se
déclenche pour tout le temps. C'est ainsi que
vous pouvez voir votre code, comment il s'exécute,
où il s'arrête, où il pose un problème. Parfois, cela vaut la peine d'avoir
deux écrans pour cela, et le même écran peut être un peu compliqué, mais c'est faisable Quoi qu'il en soit, nous allons
le remettre ici, appuyez sur Stop. La prochaine chose que nous allons faire est de dire d'une manière ou d'une autre au
joueur de marcher ici, marcher sur cet endroit
pour fermer la porte. Donc, pour le faire facilement, je pourrais simplement apporter un texte ici
, juste du texte, texturner actor, ici, nous
allons l'amener
quelque part où je peux le voir, je dois faire une rotation de 90 et l'
amener peut-être ici Et si j'en viens aux détails, comme nous l'avons dit, chaque élément
a ses propres détails. Maintenant, le texte possède
son propre détail
, appelé texte. Tout ce que je tape ici,
nous pouvons le voir sur la carte. Alors viens ici pour fermer la porte. Si je voulais le mettre sur une ligne différente,
continuons à mettre
en majuscule chaque
lettre, chaque première lettre Ce que je pourrais faire, c'est aller ici, je peux simplement appuyer sur Entrée, et nous passons à la ligne en dessous. Je suis désolée, c'est gênant. Il faut que je
l'agrandisse. Ainsi, avec un alignement horizontal, l'alignement
vertical peut
également manipuler notre texte. Je vais le laisser au centre
et au bas du texte. Je
trouve que ça a l'air bien. Je vais juste le déplacer comme
ça et
peut-être le réduire un peu 24. Eh bien, 20, 20, ça me va. Et je vais le
déplacer. Non, c'était bon. C'est donc une façon de
voir du texte. Viens ici pour fermer la porte. Mais si je voulais faire apparaître le
texte au-dessus de la porte, dans un certain temps, j'aurais tout de même besoin d'une
boîte de collision pour le faire. Maintenant, nous pourrions remplir
le monde de boîtes de déclenchement et en utilisant le plan des niveaux,
nous pourrions les acheter. Et si je voulais
simplement avoir une boîte de déclenchement avec laquelle je pourrais faire plein de choses, et en fonction de mes besoins, je pourrais modifier ses
fonctionnalités. C'est là qu'un
plan d'acteur entre en jeu. C'est la différence
entre le plan de niveau, qui est un plan
responsable de l'ensemble du niveau, et nous avons le plan de l'acteur, qui est
responsable de lui-même et fait ce qu'
il est censé faire Passons donc à nos plans. Créons-en
un nouveau, sans utiliser le test. Choisissons la classe Blueprint. Choisissons un Noctor et
appelons ce texte de tracé PP. Entrons dans ce plan. Comme nous l'avons dit, le plan de niveau est responsable de
l'ensemble du niveau Ses composants
pourraient donc théoriquement être l'ensemble du niveau. Mais ce plan a ce point de vue, et
comme nous l'avons décrit, c'est là que nous pouvons voir visuellement certaines parties
de notre plan, quoi
consiste notre plan, par exemple Et là où nous les plaçons, c'est
le talon du composant ici. Donc, pour ce plan, nous allons avoir besoin d'
une boîte de déclenchement. Une boîte de déclenchement dans les plans, cependant, ne s'
appelle pas une boîte de déclenchement. C'est ce qu'on appelle une collision entre
boîtes de collision une collision entre capsules
ou une collision entre sphères. Il s'agit des
classes par défaut dont nous disposons. Ils sont presque identiques à 99 %. Ils sont presque les mêmes, mais ils ne sont pas les mêmes. C'est pourquoi on les
appelle boîtes de déclenchement, et c'est ce qu'on appelle des
boîtes de collision. Quoi qu'il en soit, avançons
en choisissant une collision de boîtes. cas où nous sommes dans
ce plan, je n'ai pas besoin de faire référence à la collision de boîtes d'une manière ou d'une autre car elle se trouve à l'intérieur
du plan, alors que dans le plan de niveau, je dois faire référence à cette boîte de
déclenchement heure actuelle, si j'insère ce
plan sur la carte, nous pouvons voir la collision entre les boîtes Mais je n'ai pas besoin d'y faire
référence ici car cela fait partie
de ce plan Lorsque je dois l'appeler
dans mon graphe d'événements, je peux simplement le
glisser-déposer à partir d'ici ou je peux le glisser-déposer à partir de
variables et de composants. N'oubliez pas les variables, les composants
sont également des variables. Et puisque nous
pensons au comportement de la
boîte de déclenchement, examinons le comportement
de la collision entre boîtes. Comme vous pouvez le voir, il y a un talon de
détail très différent ici Et si je vais dans Viewport
et que je le sélectionne,
il est plus proche l'autre,
avec quelques différences, comme par exemple,
ces événements ici avant que nous ayons besoin d'
appeler Bind on event Nous pouvons donc également le faire
à partir d'ici. Alors, liez en cas de superposition. Et nous pouvons voir que ces
événements qui existent ici commencent
également à se chevaucher, à se
chevaucher et à tout le reste. Mais comme cela figure dans
le plan, Areal nous propose ces événements
que nous pouvons directement utiliser Par exemple, je souhaite qu'un
composant commence à se chevaucher. Je peux cliquer dessus pour créer l'événement, donc je n'ai pas besoin de le lier. Quelques informations supplémentaires si je l'
appelais à partir d'un autre
plan, par exemple, si j'avais une référence
à ce sujet,
disons que cette case est sélectionnée, j'apporte une référence
ici à cette case Maintenant, à partir de cette boîte, je peux obtenir le mien à partir de
ce plan, je peux obtenir le composant de la boîte Je parcourt la liste, je trouve la boîte, je peux la relier ici, parce que si je clique ici, nous pouvons voir qu'il n'y a aucun événement
tel qu'il était dans le plan Donc, si je veux lier cette boîte depuis
un autre endroit, je dois quand même me lier comme ça. Laissez-moi terminer la démonstration. Je vais donc lier le superposition, puis
créer un événement personnalisé. Et comme vous pouvez le constater, il offre plus d'options que
la boîte de déclenchement. C'est pourquoi je dis que
ce n'est pas exactement pareil. Quoi qu'il en soit, ce ne sont que
des informations supplémentaires. Revenons à notre plan et je vais
supprimer cette boîte. Nous n'en avons pas besoin
car cet événement est prêt pour nous. Et entre parenthèses, vous pouvez voir de quelle case il s'agit Par exemple,
cinq autres cases indiquaient qu'il s'agissait de la case
15, 15 cases supplémentaires. On voit qu'il s'agit de la case 15. Maintenant, je pense que c'est un bon point d'
arrêt pour celui-ci. Je te verrai
le prochain. Au revoir.
8. Contrôler le texte et les lumières avec la programmation Blueprint: Bonjour et bienvenue
sur Unreal Engine, cinq systèmes de portes
Blueprint Mastery
et portails interactifs Nous avons donc déjà commencé à créer notre acteur
Blueprint en texte réduit Nous avons ajouté ce
plan à la carte, et nous avons ajouté un cube de collision, une collision de boîtes
dans la fenêtre d'affichage, à l'intérieur
des composants du Et nous avons démontré un peu le lien entre le
début et le chevauchement des composants, la
case 15, par rapport au nœud
de déclenchement, qui était un peu plus simple. Maintenant, poursuivons l'
élaboration de ce plan directeur. Les prochains composants dont
nous aurons besoin sont un point lumineux et un texte. Rendu du texte. Maintenant, la ligne de pointage, nous devions rendre le texte un
peu plus visible, qu'il soit masqué ou non, qu'
il ne soit pas masqué, qu'il ne
soit pas visible à la lumière. Et bien,
fais-le ressortir un peu mieux. Et le texte d'appel d'offres
serait le texte que nous ajouterons à notre texte, la même manière
que nous avons ajouté l'
étape ici pour fermer la porte, que nous devrions apporter. Je vais utiliser Alt et
faire glisser une surface ici. Et OK. Mets-le peut-être un peu plus bas. Le joueur sait donc
où il est censé marcher. Rendons-le également un
peu plus petit. C'est bon C'est bon ici. Ouais Et maintenant, nous devons placer
ce texte au-dessus de la porte pour dire « rapprochez-vous de
la porte » pour qu'elle s'ouvre. Comme nous voulons l'utiliser
de nombreuses fois, nous allons utiliser le script de
construction,
qui, encore une fois, est propre
à la classe Blueprint Eh bien, pour la plupart des classes de plans, comme nous l'avons dit, le
plan est différent de celui
d'un plan simple La plupart des classes de blueprint possèdent
le script de construction. Construction Sprint est utilisé pour effectuer des tâches dans l'éditeur. C'est très bon à utiliser pour génération
procédurale
et la randomisation, personnalisation des actifs Par exemple, à l'heure actuelle, nous devons personnaliser notre texte. Comme chaque exemple de ce plan que nous allons
présenter au monde,
si je le reproduis Nous voulons que le texte dise autre chose dans un cas et d'autres choses dans
l'autre. Il s'agit donc du même plan, mais nous avons deux instances
avec un texte différent Une façon de le faire serait d'utiliser ce script
de construction. Nous allons télécharger notre tendance
textuelle ici, il
suffit de le glisser-déposer Un petit conseil à ce sujet serait que si je
maintenais la touche Ctrl enfoncée et
que je fais glisser et déposer, j'obtiens un getter. Si je tiens le coup, je vais trouver un passeur. Comme vous l'avez vu, je le fais glisser et déposer d'ici,
c'est pareil. C'est notre texto trender. Si je renomme ce textnder M, vous pouvez voir qu'il est également
renommé ici Donc onglet composants,
liste des composants dans les variables. Nous n'allons pas nous embêter
avec un setter, oui. Nous allons juste
utiliser le seul getter, et nous allons définir le texte La différence entre
ce texte défini et l'obtention ce rendu de texte défini M serait que cela
fait référence à la valeur, laissez-moi choisir le rendu du texte. La valeur du texte lorsqu'elle fait référence à l'entité
du rendu du texte. Donc, cela changerait
si je
lui avais prédéfini des variables avec des rendus de texte, je pourrais le changer comme ça Quoi qu'il en soit, c'est un peu confus. le moment, nous allons
simplement définir la valeur du rendu du texte. Encore une fois, des
détails différents lorsque je suis ici, détails
différents lorsque je le
sélectionne ici. Je n'ai pas besoin d'être sur le viewpod, ce
serait pareil,
mais des détails différents d'
un point de vue variable et détails
différents du point de vue des
composants Maintenant, nous allons continuer. Script de construction, nous devons
modifier la valeur de notre texte. Je vais donc en
faire une variable. Et il l'a déjà nommée «
valeur pour nous ». Nous allons ajouter le
texte qui le précède. Valeur du texte. Et ce que nous allons faire, c'est
utiliser ce bouton ici, modifiable
par instance, ou
le trouver ici et utiliser
le I ici Vous pouvez le voir
cliquer automatiquement sur Instance modifiable avec le e ici Nous allons également l'exposer
lors du spawn au cas où nous créerions
ce plan Eh bien, nous n'
allons pas le créer, mais si vous voulez créer
ce plan, vous devez l'exposer Maintenant, nous allons compiler
et enregistrer, puis revenir à notre carte et montrer
ce que nous venons de faire. Nous avons cette valeur de texte et toute valeur que nous
mettrons ici sera notre texte. Pour le moment, il est vide. Donc,
si nous allons dans notre fenêtre d'affichage, nous pouvons voir qu'
il n'y a pas de texte Il a en fait disparu.
Si j'appuie ici sur un, deux, trois, nous pouvons
voir un, deux, trois. Ainsi, quelle que soit
la valeur que nous ajoutons à cette variable, nous pouvons en fait l'amorcer
correspondant à notre rendu de texte, et cela se fait par le
biais d'un script de construction. Cela signifie que cela se produit
avant que le jeu ne démarre
avant que je n'appuie sur Play. Et une autre chose est que nous avons appuyé sur instance Edit
et expose on span. Donc, si nous cliquons sur ces plans et passons
aux détails ici, laissez-moi les agrandir un
peu Nous pouvons voir sur la catégorie
par défaut une valeur de texte. Pour être plus sûr,
saisissons la valeur de mon texte. Et nous pouvons voir que cela
a changé la valeur du nom. C'est donc notre variable. Donc, quoi que j'écrive
ici,
bonjour , bonjour, ça
deviendra le nouveau texte. Et ici, nous pouvons voir la
définition de l'instanciation, comme si un plan disait bonjour, l'autre Et tapez bonjour et
celui-ci dit bonjour, et celui-ci dit bonjour. Ainsi, le fait de rendre la variable publique
ou de l'exposer réellement modifiable en instance nous donne la possibilité de modifier
la variable ici Maintenant, la catégorie par défaut,
c'est autre chose. Lorsque nous examinons la
variable elle-même, nous pouvons voir qu'il y a un
tas de détails ici. L'un des détails
est la catégorie. Nous pouvons catégoriser nos variables et continuer comme si
celles-ci étaient des composants Ils sont sur des composants comme une liste. Si j'ajoute celui-ci à une catégorie
appelée disons texte, nous pouvons
maintenant voir qu'il
appartient au texte de la catégorie. De plus, si je vais à l'extérieur d'
ici et que j'ai besoin de compiler
pour voir ce changement, nous pouvons voir qu'au lieu
du texte par défaut, il est écrit du texte. Nous pourrions effectuer un tas de réglages ici pour définir la position
du point lumineux, du texte et de la boîte, mais nous n'irons pas aussi
loin dans le script de construction. Ce que nous pouvons faire, cependant, serait de mettre en lumière
le point
et de régler l'intensité. Et disons, donnez-lui une valeur
par défaut de 1 000 et promouvez-la
maintenant en variable. Repartons
avec
une nouvelle intensité. Changeons également la
catégorie en lumière et définissons également la couleur. Vous souhaiterez peut-être
configurer une couleur différente. Réglons la
valeur par défaut sur le blanc. Oui, blanc, blanc,
non. Et
faisons-en une variable, une couleur de lumière et une
nouvelle instance
modifiables également et une nouvelle catégorie. Maintenant, au lieu
de changer de catégorie ici
, je peux simplement la
glisser-déposer ici et elle entre dans
cette catégorie. Maintenant, apportons ça ici. En fait, je peux juste le
dupliquer. Maintenant, il est également valide d'avoir cette
option au lieu d' une et de faire glisser un autre
câble Cela ne pose aucun problème. Cela permet même de savoir un
peu plus clairement ce qui est quoi. L'autre chose que je
voulais expliquer est pourquoi j'ai appuyé sur une valeur par défaut ici
, puis je l'ai promue en variable. Eh bien, quand je le fais de cette façon, si je compile, la variable
promue, new intensity conserve la valeur que j'avais par défaut, et la couleur
serait également le blanc. Alors maintenant, si j'y vais, je n'ai pas cliqué dessus
pour que l'instance soit modifiable Exposons-les lors du spawn, peut-être pour une
utilisation plus avancée, compilons-les et enregistrons Passons à notre carte,
et maintenant nous pouvons voir la catégorie de texte et la catégorie de
lumière ici. Nous n'avons pas vraiment
besoin des deux. Nous n'en avons besoin que d'un pour le moment, et réglons un
peu le positionnement. Alors, que
voulons-nous réaliser ici ? Si je l'ai sélectionné, je peux choisir les composants
de ce plan Si je choisis cette porte, je peux choisir les composants
de ce plan Si je choisis le mur,
je peux choisir dans les détails les composants
de ce que je choisis. Ce que je vais faire,
c'est choisir la boîte. Ainsi, lorsque le joueur se dirige vers la porte parce qu'il n'y a
nulle part où se déplacer, cette case se déclenche. Je pense que c'est un
bon endroit pour le mettre. Il se peut que le joueur saute. Alors allons-le un
peu plus haut. Ils vont donc passer
par cette boîte. Allons chercher le texto. Allons faire des cerceaux. Je vais me
le procurer à partir d'ici. Une rotation de 90, et
définissons un texte. Disons aussi de t'approcher pour ouvrir la porte. Rien n'a changé. OK, c'est mon erreur. Je ne dois pas
faire ça au rendu du texte. Je dois le faire sur le plan, fermer la valeur de
mon texte
pour ouvrir la porte Très bien. Et déplaçons
ce texte au-dessus de la porte. Et raccourcissons
un peu la phrase. Nommons-le simplement
approche à ouvrir. Encore une fois, c'est une erreur. Cela
devrait figurer sur le plan, pas sur le rendu du texte, car nous
annulons ce rendu de texte à partir d'
ici Donc, pas grand-chose de l'
approche « Non » pour ouvrir. Je pense que l'ouverture a besoin d'un
P. Donc, approche de l'ouverture. Sélectionnons à nouveau le
texte ultérieurement. Placez-le un peu mieux. Et apportons également
la lumière au-dessus. Cela oblige donc le joueur
à regarder le nouveau point lumineux qu'il a repéré. Je pense à le configurer.
Voyons à quoi ça ressemble. Génial. La prochaine chose que nous devrions faire est d'apporter un peu
de fonctionnalité, mais je pense que c'est un bon point d'
arrêt. Nous l'avons mis en place. Nous avons créé les autres composants, nous les avons mis en place sur la carte, et je pense que c'est un
bon point d'arrêt. Je te verrai
le prochain. Au revoir
9. Conseils d'interaction de programmation avec des plans: Bienvenue sur
Unreal Engine Five, Blueprint Mastery, Door Systems
et les portails interactifs Auparavant, nous avions créé
notre texte de flux BP. Nous avons en fait ajouté quelques composants
supplémentaires et créé le
script de construction qui contrôle le texte, la couleur et l'intensité. Nous l'avons ajouté à notre carte et nous avons utilisé les
composants eux-mêmes. Nous avons choisi le plan,
puis, à partir des détails, nous avons choisi les composants que
nous voulions et les avons déplacés dans l'espace correspondant
à nos besoins Continuons avec
la partie codage. Lorsque le joueur se chevauche, demandons à nouveau s'il s'agit de notre
joueur ou de l'autre acteur. Cette fois, nous allons
faire les choses un peu différemment. Nous allons accéder à
notre navigateur de contenu, nous allons passer
à une troisième personne,
puis nous allons accéder à
nos plans de dossiers
et ouvrir notre BP à la troisième personne À la troisième personne, il y a le code qui déplace
le joueur. Il y a le
script de construction et le viewpoard. Le panneau d'affichage se compose
du maillage des caractères, de la capsule, d'une caméra Boom****
et de la caméra, ainsi que d'un composant de mouvement du
personnage Maintenant, ce que nous voulons, c'est utiliser la capsule, accéder aux
détails, rechercher Tug et ajouter le Tug P maintenant. Que sont les tags ? Les tags sont de simples étiquettes ou
identifiants, si vous le souhaitez, qui peuvent être attribués à des acteurs ou à des composants du
plan et aident à catégoriser et à identifier les objets
dans le monde du jeu, facilitant ainsi le filtrage recherche ou le déclenchement de
comportements spécifiques Par exemple, pour l'instant,
ce que nous allons faire, c'est enregistrer et compiler.
Revenons à. Nous allons demander s'il
ne s'agit pas de l'autre acteur, mais du composant que nous avons superposé Est-ce qu'il a l'étiquette ?
Possède en fait une étiquette. Le composant a une balise,
et nous allons
choisir car c'est la balise
que nous avons saisie ici. Je vais fermer ça. Nous
n'en avons plus besoin. Et si le composant qui se chevauche avec
la boîte porte le tag P, nous utiliserons une branche, qui est un nœud I. Donc, en gros, si
c'est correct, si c'est vrai, la condition, notre condition en ce moment c'est que le composant a une balise,
ça passe de vrai. Si ce n'est pas le cas, cela passe de faux. Il s'agit donc d'une instruction
Is avec une condition. Et bien sûr, il
faut l'exécuter. Si nous avons la balise de composant P, nous lançons la vraie branche. Dans le cas contraire, nous virons
la fausse branche. Si c'est vrai, nous
aurons besoin
du moteur de rendu de texte et
nous aurons besoin de
la lumière ponctuelle Nous allons dessiner
une visibilité définie. Maintenant qu'il s'agit d'un
nœud qui contrôle la visibilité d'un composant, nous devons le convertir
en vrai, accéder à nos informations dans le rendu du texte
et rechercher la visibilité. Et transformez-le en pouls, et nous le faisons
de même pour la lumière ponctuelle. Comme vous le voyez, j'ai
changé l'entité, le composant sur lequel je clique, et le tag est resté ici. C'est donc très utile. J'essaie d'éteindre la lumière, d'éteindre le rendu, de compiler et de sauvegarder. Cela transformera donc la
visibilité des deux en réalité. Allons le tester. Si je vais
jouer, je ne vois rien. Je passe ici, je m'approche pour ouvrir. Parfait Cliquez ici pour
fermer, approchez pour ouvrir. Faisons en sorte que notre deuxième
niveau soit visible. Je vais cliquer sur l'
œil au deuxième niveau, et maintenant c'est visible. Et en fait, si nous
entrons dans cette pièce,
dupliquons cela. Je vais simplement le sélectionner
et le faire glisser ici sélectionner
également l'élément du bas et le faire glisser ici, peut-être un peu plus
loin. Je pourrais également
copier le texte pour le faire pivoter et avec alt, je vais le dupliquer
et le faire glisser ici. Donc oui, je pense que c'est bon. Allons sélectionner notre nouveau déclencheur, accéder à la carte de notre didacticiel, apporter la référence
et la connecter ici. Ce serait donc ça. Maintenant, nous associons également
ce déclencheur à cet événement. Donc, si je veux jouer, je peux
aller ici, m'approcher pour ouvrir. En fait, approchez pour ouvrir, et je vais passer
ici et fermer, ouvrir, fermer. Génial. Notre prochaine porte
sera celle où nous
appuierons sur E, et elle s'ouvrira. Amenons donc notre acteur de
collision ici. En fait, je vais
en apporter un nouveau. Flux de texte ici. Passons à ce que le texte presse pour ouvrir D. Mettons de l'espace ici. Encore une fois, si je voulais
changer l'apparence du texte, je pourrais
sélectionner un rendu de texte. Je pourrais modifier les options ici. Je pourrais changer la couleur, mais nous n'avons pas exposé
toutes ces variables. Nous avons simplement exposé ce que serait
le texte. Où voulons-nous entrer en collision ? Disons que lorsque le joueur a parcouru la moitié de la pièce, disons quelque part ici. Encore une fois, pour le déplacer, je le
sélectionne simplement dans les détails. Mettons la lumière
quelque part ici. Et apportons le
texte. Quel est le texte ? Oh, ce n'est pas visible. C'est pour ça que je ne vois rien. Je vais donc passer
à la recherche de visibilité dans les détails du texte. Ça va devenir vrai. Et maintenant j'ai le texte. Je n'aime pas du tout ça, alors je vais juste
modifier certains paramètres. Je vais l'envoyer au centre et à
côté du centre. D'accord. Je pense que ça a l'air mieux. Oui, cet endroit est bien. On pourra le peindre
en grand une autre fois. Maintenant, voyons si
je dois le remettre en mode
invisible, c'est-à-dire sur la visibilité. Hein ? Nous allons le tester. Passons à cette porte
et il n'y a pas de texte. Je ferme la porte.
Et ça m'a semblé génial. Maintenant, il ne nous reste plus
qu'à ouvrir pour ouvrir cette porte. Commençons donc par
créer le plan. Cliquez avec le bouton droit de la souris, accédez à classe
Blueprint et
sélectionnez unactorblueprint, car nous n'avons pas besoin de le
posséder , nous n'avons pas C'est juste une entité dotée de
certaines fonctionnalités. Donc Actor Blueprint,
appelez-le PP One Way Door. Oups. Peut-être une façon de le faire. Ouvrons donc ce plan. En fait, créons
un dossier pour les portes. Créons un dossier appelé
doors inside the blueprints, et je vais le
glisser-déposer ici Et mettons-le au monde. Nous allons le régler par
la suite. Et une autre façon d'
ouvrir le plan plus de double-cliquer ici
serait de choisir le plan à partir du plan, choisissant le plan que je souhaite modifier. Si je l'ai
mis dans le monde entier, je peux simplement cliquer ici,
Modifier le plan, ou
je peux simplement sélectionner Ouvrir l'éditeur de plan en sélectionnant l' Je vais donc l'ouvrir. Et pour ce plan directeur, nous allons avoir besoin de
trois composants Ajoutons une boîte de collision. Cela détectera si le joueur
est à portée ou non, afin qu'il puisse ouvrir la porte ou non. Et nous aurons également
besoin d'une flèche pour savoir où se trouve
la porte, c'
est-à-dire la face avant
puis la face arrière, et nous aurons
besoin d'un treillis statique Donc pour le
maillage statique, en fait, parce que je ne veux
pas rechercher les actifs. Puisque nous l'avons ici,
je peux simplement sélectionner ce navigateur jusqu'à ce que je
regrette, pas cette flèche. qui est des détails, je
vais réduire la visibilité, et je vais
sélectionner la porte. Et sur le maillage statique, je peux voir quel maillage statique est l'entité
du maillage statique. Je vais y aller, et
voici la porte. Maintenant, je vais revenir à mon plan et
ajouter un maillage statique, et la porte a déjà
été sélectionnée pour moi Génial. Maintenant, c'est un
peu un P boot. Cela n'a pas vraiment d'importance.
Je vais juste l'
apporter ici. Et pour le reste, nous pouvons nous déplacer à partir de la carte elle-même
en sélectionnant le plan Cela fait une rotation de 90 degrés car le mouvement
se fera dans un espace relatif Maintenant, qu'est-ce que cela signifie ? Lorsque je fais pivoter la porte ici, tout d'
abord, je fais pivoter
l'ensemble du plan Donc, même si je tournais la
porte d'une autre façon, ce serait dans l'espace local
et mondial Cela signifie que je le fais pivoter
en fonction des coordonnées et du
système cartésien de la qui est basé sur
l'axe XY Z de la carte et sur les endroits où
nous pouvons tout voir. L'emplacement et la rotation
seraient donc relatifs aux
coordonnées de ce système. Mais ce que nous allons faire, c'est
faire pivoter cette pièce, que j'ai en fait
associée à la flèche Maintenant, assurez-vous que ces
éléments ne sont pas parentés, et si cela se produit, ils n'ont pas de
flèche ici, il
suffit de les glisser-déposer jusqu'à la racine Nous l'attachons. Nous ne
créons pas une nouvelle racine. Tout est donc une
entité à part entière. Par exemple, si j'
attache la flèche à la porte et que je déplace
la
porte, je déplace
la flèche avec elle. Si je le détache, tu
peux le faire aussi. si quelque chose est attaché, si vous le glissez et déposez
sur lui-même, il se détache Donc maintenant, si je déplace la porte, la flèche, comme vous pouvez
le voir, reste là. Maintenant, je vais
déplacer cette porte dans un emplacement relatif, dans une rotation
relative. Différent de la rotation définie de
l'acteur. Comme vous avez pu le voir, lorsque
je déplace l'acteur ici, le point pivot était le centre,
le centre de l'acteur. Alors que je veux déplacer
la porte en fonction son propre point de pivot sur la rotation
relative du plan Mais je crois que je fais une digression. Je pense que nous devrions le voir en action, et nous laisserions
celui-ci pour le prochain cours, le prochain cours. Alors je
vais te voir. Au revoir
10. Travaux de base pour l'interaction des joueurs avec les portes: Bienvenue sur
Unreal Engine Five, Blueprint Mastery, Door Systems
et les portails interactifs Auparavant, nous avions terminé la
configuration de notre texte de flux BP, nous avions ajouté du code selon lequel, si l'autre acteur
qui se chevauche possède un composant portant la balise P, et c'est ce qui se chevauche, alors activez la visibilité Pour ce faire, nous avons ajouté une balise à notre composant
capsule de personnage. Donc, à la troisième personne,
le plan du personnage à
la troisième personne de BP BP Dans le composant de la capsule,
nous recherchons une étiquette. Et j'ai ajouté le tag
P. Un autre endroit où tags
pourraient être ajoutés
dont nous avons discuté est également celui de l'acteur. Nous ne l'avons pas démontré, mais si nous utilisons les valeurs par défaut des classes
et que nous cherchons à nouveau les balises, nous pouvons constater que l'acteur
possède son propre onglet pour les balises, où nous pouvons également voir les
balises des autres composants Alors, fermons ça. Ensuite, nous avons
configuré le texte du flux BP
pour la pièce suivante, et nous avons commencé à
créer la nouvelle porte, qui est la porte à sens unique BP. Donc, dans ce plan, nous avons légèrement
décalé la rotation Je peux voir. Cela devrait être zéro. Pas moins zéro, mais zéro. Nous avons
légèrement modifié l'emplacement car le pivot est
légèrement décalé, et nous avons expliqué que nous
allions déplacer la porte en fonction du
distem cartésien de ce plan, qui est l'espace
relatif local
et non le et non le Donc,
rotation et échelle de la localisation dans le monde. Oui, c'est une très
grande différence. L'emplacement mondial et
l'emplacement relatif, la rotation du monde et
la rotation relative. Il s'agit bien sûr d'une échelle très
importante, qu'il est important de faire la
distinction car, par exemple ,
si nous faisions pivoter,
disons, correctement, la porte dans le mot « emplacement », disons qu'elle pivote
correctement, par
exemple, nous
pourrions déplacer la porte De cette façon, il pivote correctement
avec l'acteur, et il s'ouvre ainsi
en utilisant la rotation du monde Eh bien, cela signifierait que cette porte ne
s'ouvrirait que de cette façon. Si je voulais qu'il en soit ainsi, cela ne marcherait toujours pas. Ça ne marcherait pas comme ça. Cela dépendra de la
rotation mondiale que nous avons définie. Il est donc important
de faire la distinction. Alors revenons ici. Réglons ça quelque
part entre les deux. C'est bon. Maintenant, qu' allons-nous faire pour
animer cette boutique Nous allons passer à la carte de
notre didacticiel. Nous allons voler
la chronologie d'ici. Nous allons le copier et
en fait juste une chronologie, puis nous allons
accéder à notre graphique et le coller ici. Puisque nous le copions et le
collons, nos valeurs sont comprises entre
0-0 0,5 0-1 Voici donc notre lecteur Alpha. Maintenant, pour établir la
position relative par rapport au monde, et c'est pourquoi je
ne l'ai pas copiée, qui consiste à définir la rotation des acteurs, et nous fixons une cible en tant qu'acteur et
lui donnons une nouvelle rotation, nous devons obtenir notre porte, qui est une porte arrière,
et définir une rotation relative C'est un nœud très similaire. Comme vous pouvez le constater, il a
également été téléporté car celui-ci ne peut que se téléporter, mais cela signifie qu'il balaie
s'il ne se téléporte pas Et nous allons le
connecter ici. Dans le cas précédent, nous avons percé un rotateur Mais dans ce cas, je voudrais juste cliquer ici avec le bouton droit de la souris
et diviser le rotateur, et je vais
juste me lancer à flot. Donc je vais faire du
larp ici à partir de 02, je pense qu'il faut aller à la porte Faisons-le pivoter.
Je crois qu'il fait -90 Ouvre vers l'intérieur -90. OK. On aurait pu voir
la flèche ici aussi. Si original, donc de
zéro à -90 de A à B. Maintenant, comment appelle-t-on ça Dans l'autre plan, nous utilisons simplement la
collision ici, et nous avons appelé la porte ouverte Encore une fois, nous aurions pu
utiliser la collision. Remettons-le dans une boîte afin de pouvoir même faire en
sorte que les
collisions commencent à se chevaucher. Et nous pourrions simplement dire
que lorsque le personnage a P. Ensuite, nous remettons
une branche. La façon dont j'ai amené
la branche si rapidement était de sélectionner B et de cliquer. Cela amène une branche. Donc, si c'est vrai, alors joue. Et puis nous avons de nouveau une porte de
collision. Mais quand on entre en collision avec
elle, elle devrait s'ouvrir. Nous ne voulons pas faire ça.
Nous voulons appuyer sur E. Donc, comme nous n'allons pas créer un système complet pour les entrées permettant modifier les liaisons, d'
ajouter des liaisons et tout le reste, nous utiliserons simplement
E pour ouvrir des portes Nous pouvons simplement utiliser
la manette du joueur. Je vais donc acheter une manette de
joueur. Je vais expliquer dans une seconde et activer la saisie depuis
le contrôleur du joueur. La cible doit être elle-même et la manette du joueur doit
être sur la manette du joueur. Maintenant, pour le déplacer, je le déplace en appuyant sur Troll et en le
glissant et en le
déposant où je veux Si j'appuie sur Alt et que je clique,
il le déconnecte. Si j'ai quelque chose
en rapport avec le contrôle, je peux le connecter ailleurs. Maintenant, qu'est-ce qu'une manette de joueur et qu'est-ce qui permet la saisie ? Dans
Unreal Engine, une manette de joueur est une partie du jeu qui traite les entrées du
joueur, telles que actions de la manette du
clavier, et les
traduit en commandes destinées
au personnage du joueur ou à tout autre objet du jeu Il agit essentiellement comme un lien entre le joueur et le mot du
jeu. Normalement, le contrôleur
ne reçoit que des entrées directes, mais nous pouvons activer les entrées sur d'autres acteurs pour leur permettre de
réagir à des actions spécifiques. Par exemple, ici, nous
allons attendre que l'action E ouvre la porte. Pour y parvenir, nous allons donc utiliser notre
collision ici. Je vais me déconnecter
en appuyant dessus et
en cliquant sur ces éléments. En fait, j'en ai besoin, donc je vais couper et coller. Et je vais le
connecter ici. Donc, si notre joueur
entre en collision avec un cube, nous activerons la
saisie ici, Ops, mistake Cela devrait être là. cible doit être soi-même. Nous autorisons l'entrée de cet acteur par
cette porte et le contrôleur du
joueur est le contrôleur du joueur. Mais lorsque nous quittons cette case, nous voulons ne pas activer la saisie
pour la désactiver en gros. Je vais donc sélectionner la case. Je vais cliquer
sur le chevauchement des extrémités des composants. Cliquez rapidement. Je vais le copier-coller.
Je vais le connecter ici. Et je vais
également copier et
coller le contrôleur et appeler Disable Input. Je vais régler la cible sur self et connecter la manette
du joueur. Alors maintenant, comment activer E lorsque l'on appuie sur
E ? Eh bien, c'est facile. Si je clique et que je tape sur le clavier, nous pouvons voir qu'il y a pratiquement
tous les boutons du clavier , et si j'appelle E, , et si j'appelle E,
trouvons E. Le voici. C'est ce que j'appelle, ça crée
un événement à lui tout seul. Donc, puisque nous avons activé la saisie, cela fera quelque chose. Démontrez-le pendant une seconde. Mettons une chaîne d'impression ici. Ça dit bonjour. Je
vais donc jouer sur la carte. Si j'appuie sur E
maintenant, cela ne fait rien. Si je vais à côté de
la porte, que j'entre dans cette collision et que j'
appuie sur E, le message « bonjour » s'affiche. Si je pars, ça ne fera plus
rien. Cela ne fonctionne donc que tant
que la saisie est activée. Maintenant, si nous avions d'autres
exécutions avec E, nous aurions la liaison
parent override, qui remplacera tout ce que fait
EE dans d'autres domaines, et consommera également Il y a aussi des modificateurs, comme si vous voulez avoir
shift et E en même temps, de
toute façon, il y a beaucoup de choses à ce sujet Mais il s'agit essentiellement
d'un nœud d'entrée. Pour animer notre porte, nous pourrions simplement la
connecter directement ici Mais alors nous ne
pourrions qu'ouvrir notre porte. Si je fais comme ça et que j'appuie sur E, je ne peux que l'ouvrir.
Je ne peux pas le fermer. Mais je pense que c'est un bon point d'
arrêt pour celui-ci. Je
te verrai bientôt. Au revoir.
11. Codage du système de porte d'interaction des joueurs: Bonjour et bienvenue
sur Unreal Engine Five,
Blueprint Mastery, Door Systems
et les portails interactifs Auparavant, nous avons
parlé un peu des rotations
relatives, puis nous avons terminé notre chronologie et défini la rotation
relative
en faisant un tour sur un flotteur car le X et le
Y ne changeront pas Seul l'axe Z, l'
axe Yo apprendra de zéro à -90 pour définir la rotation
relative Et ce
sera toujours le cas lors de cette rotation. Nous avons donc la flèche qui
nous indique où se trouve la façade et vers
laquelle la porte s'
ouvrira. Si nous voulions l'
ouvrir de cette façon, la seule chose que nous
aurions à faire
serait de changer cette valeur de -90 à 90 degrés, et elle s'ouvrirait à
90 degrés. La prochaine chose que nous avons faite a été d'
activer la saisie avec la manette du joueur par le
biais de ce plan et de le désactiver lorsque nous commençons et que la fin se chevauchent lorsque notre
joueur commence et la fin se
chevauche à l'aide de
la balise de composant P. Ensuite, nous avons
fait la démonstration d'
un nœud d'entrée que la fin se
chevauche à l'aide de
la balise de composant
P. Ensuite, nous avons
fait la démonstration d'
un nœud d'entrée,
le bouton E , qui
fonctionne et ouvre notre porte Continuons à faire en sorte que la porte puisse s'
ouvrir et se fermer. Il y a quelques leçons, nous avons parlé un peu
des énumérations, fait qu'il existe des listes prédéfinies qu'elles ne peuvent pas
modifier pendant Allons en créer une,
car celle que nous avons montrée existe déjà dans
le moteur d'Unreal, et c'est une question de direction Nous pourrions l'utiliser, mais
rendons-le également un
peu plus avancé pour
d'autres utilisateurs. Nous allons cliquer
et nous allons accéder à Blueprint et
à partir de Blueprint, nous allons
choisir Maintenant, nous allons appeler
cette porte E state, et je vais l'ouvrir. Ici, nous avons le bouton
qui ajoute des énumérateurs. Comme nous l'avons dit, il s'agit
essentiellement d'une liste, et comme vous pouvez le constater, elle les nomme différemment
car elle ne peut pas avoir deux fois le même énumérateur Si je le mets à zéro
, une erreur apparaîtra. Numérateur zéro, le nouvel énumérateur
zéro est déjà utilisé. Allons ouvrir. Fermer. Ouverture. En fait,
un P, et des fermetures. Maintenant, je vais enregistrer et
je vais fermer ça. Maintenant, j'ai cette liste ici, mais comment puis-je apporter
le plan Je ne peux pas simplement le
glisser-déposer ? Il ne peut pas créer un clin d'œil à partir de ce type d'actif. Pour ce faire, je vais accéder à
notre talon de variable et appuyer sur le
bouton plus ici pour créer une nouvelle variable, passer
au type de variable ici et rechercher l'état E D. J'aurais aimé taper et voici dans la catégorie énumérations
IAM,
c'est notre énumération c'est notre énumération Je vais cliquer dessus
et je vais nommer la variable également door state. ce faire, je l'ai fait en
cliquant ici ou vous pouvez toujours appuyer sur F deux
pour passer à Renommer Apportons-le ici
et explorons un nouveau nœud. Ce nœud est le nœud du commutateur. Comme nous l'avons dit précédemment, le nœud de commutation doit être connecté à une énumération
spécifique, l'
énumération switch on, essentiellement, parce qu'il existe des commutateurs
basés sur des entiers, par
exemple, basés
sur Si nous tapons switch on, vous pouvez voir que tout ce qui est marqué d'
un E est une énumération Beaucoup de choses à Niagara, mais il y a de nombreuses
variables à activer. Le plus utilisable est en fait
le switch on string. Nous pouvons donc personnaliser nos étuis. Comme s'il s'agissait d'une affaire ouverte. Par exemple, nous pourrions
l'avoir avec des chaînes, et nous pourrions l'avoir ouvert. Et puis cela dépendrait ce qui provient d'une chaîne. Encore une fois, une chaîne est un
type de variable qui peut bien accepter, essentiellement du texte, n'importe quel texte. Cela peut être un chiffre
, une lettre, un symbole,
tout ce qui est un texte. Il existe également une variable de texte, mais elle est conçue pour un
autre type d'utilisation, davantage pour la localisation de contenu Il est optimisé pour afficher différents types de textes
s'ils nécessitent une traduction et un formatage pour
différentes langues. Mais pour nous en ce moment, ce n'est qu'un exemple car nous allons
utiliser une énumération Donc, lorsque j'appuie sur E, je veux que cela fasse quelque chose différent en fonction de l'
état de la porte. Maintenant, nous devons définir une
valeur par défaut pour cela. État. La première valeur que nous avons
dans notre énumération est ouverte, ce que nous ne voulons pas Nous voulons qu'il soit fermé. Je vais donc le dire pour le
fermer et le compiler à nouveau. Ainsi, l'état par défaut lorsqu'
il est pressé est fermé. Donc, quand la porte sera fermée, nous jouerons depuis le début. Lorsque la porte sera ouverte, nous
allons faire marche arrière depuis le bout. Pendant que nous jouons, nous pourrions en fait changer l'
état ici et dire que nous pourrions le
connecter ici, puis ici, puis je vais le
dupliquer et le connecter
ici et ici, et cela se fermerait
et cela s'ouvrirait. Ainsi, lorsque nous appuyons sur E, si nous sommes en état ouvert, nous fermons la porte et nous inversons
l'animation Si nous sommes proches, nous ouvrons la porte et jouons correctement l'
animation. Mais je veux démontrer
le nœud Do Once. Donc, comme nous l'avons dit, cette mise à jour de la
chronologie s'exécute en permanence. Cela signifie que cela exécute
chaque image, en gros. Chaque image exécute tout ce qui sort de
cette fin d'exécution. Si je le fais une fois ici, cela signifie qu'il
effectuera cette exécution, et une fois qu'il aura atteint ce point, il s'arrêtera là
après l'avoir fait une fois. Pour le faire à nouveau, faudrait effectuer une réinitialisation. Et si j'ai cliqué sur le bouton
Démarrer Fermer ici, cela signifie qu'il devra être
réinitialisé avant de le faire une seule fois, peu importe ce que nous avons
ici et que nous terminons. Cela signifie donc que si, par
exemple, nous voulons
changer, laissez-moi y mettre fin. ouverture permet de faire l'inverse depuis la fin et la fermeture
permet de jouer depuis le début. Donc ça s'ouvre
et ça se ferme. Ouais Maintenant, je vais
le coller ici. Si je voulais modifier cela
pendant que la chronologie s'écoule, je devrais le faire une fois, et je devrais le réinitialiser fois la chronologie terminée. Je vais donc mettre un nœud de
lecture ici. vais également mettre un nœud de lecture ici et je vais
le connecter ici Maintenant, je peux utiliser cette
énumération au lieu de celle-ci pour simplement déterminer où la porte se
ferme ou s'ouvre Je vais donc
changer de chronologie. Et si c'est en avant, cela signifie que nous
ouvrons la porte. Si c'est à l'envers, cela
signifie que nous sommes en train de fermer la porte. Et cela ne s'exécuterait qu'une fois, et une fois la chronologie
terminée, il sera réinitialisé. Vous pourrez donc le refaire gratuitement
la prochaine fois. Allons tester ça.
Allons jouer. Nous approchons de la
porte. Nous déménageons ici. Appuyez dessus pour ouvrir,
appuyez dessus pour fermer, et rien ne se passe. Et la raison est assez
simple, car au final, nous n'avons pas précisé si nous
avions ouvert ou fermé. Donc, ce que je vais
faire, c'est accéder à un nœud de séquence. Maintenant, qu'est-ce qu'un nœud de séquence ? Il semble qu'il va
faire certaines choses dans un
ordre, ce qu'il fera, mais cela ne signifie pas qu'il
attendra la fin
d'une ligne pour passer à la suivante. Il exécutera toutes les
quilles simultanément dans un ordre, mais elles se déclencheront
presque simultanément Par exemple, si j'avais une
chaîne d'impression ici qui dit bonjour. Et j'avais aussi une
chaîne d'impression ici. Cela dit, en fait,
numérotons-le. Un, deux Déplaçons ça un
peu plus haut. Je vais mettre un délai ici. Et je vais mettre
une autre ficelle ici. Supposons que ce soit trois
et que ce soit quatre. Donc, ce que nous sommes censés voir ici serait un,
deux, trois, quatre. Mais ce qui va se passer, c'est que
nous en verrons un, deux, quatre, trois parce que les trois
ont un petit retard. Faisons en sorte que cela dure 1 seconde. En fait, 0,2 était prédéfini Je n'ai
pas de chiffre exact, mais imaginez si le rendu d'une image prend
16 millisecondes et qu'il effectue tous les
calculs du jeu Imaginez la rapidité avec laquelle
chaque nœud fonctionne. 0,2, c'est donc beaucoup de temps. Allons le tester. Appuyons sur Play, et je dois me rendre à la
porte pour le tester. Vous en voyez un, deux, quatre, trois. Vous pouvez le voir à nouveau dans le journal, un, deux, quatre, trois. Cela nous indique que
cela n'attend
pas fin d'une exécution pour exécuter la suivante, puis une, puis deux, puis trois. Je vais supprimer tout cela
parce que ce n'est pas vraiment nécessaire. Et je vais supprimer certaines épingles d'exécution.
Il nous en faut juste deux. Et connectons
celle-ci à la réinitialisation, et dupliquons cette
fonctionnalité ici. Connectons également
la direction à l'interrupteur et changeons vers l'avant, il sera ouvert, et vers l'arrière, il
sera fermé Maintenant, nous devrions pouvoir
voir la porte s'ouvrir et se fermer. Ouaip. Il y a cependant quelque chose qui
manque. Le joueur doit être informé qu'il peut ouvrir
et fermer la porte. Et pour être honnête, nous sommes tout près de la porte
pour commencer à ouvrir. Comme si la collision
était très faible. Donc, quand je suis ici, cela se produit. Je pense donc que ces deux
choses seront abordées dans la prochaine leçon, et je
vous verrai ensuite. Au revoir
12. Concevoir un simple widget d'interface utilisateur dans Unreal Engine: Bonjour et bienvenue sur le moteur
Unreal, les cinq systèmes Blueprint Mastery Door et les portails
interactifs Auparavant, nous avions terminé
l' ouverture et la
fermeture de la porte. Nous avons créé un État. Ainsi, lorsque nous appuyons sur E, nous changeons en fonction de l'état de la porte en utilisant cette
énumération : état de la porte E, que nous avons ouvert,
fermé, ouvert et fermé Et lorsque la porte est fermée, elle inverse la chronologie
ou lorsqu'elle est ouverte, elle la joue depuis le début Nous avons démontré à un nœud
que pendant son exécution,
nous n' effectuons cette
action qu'une seule fois et nous la réinitialisons une fois
la chronologie terminée,
et lorsque la chronologie
est terminée,
nous réglons l'
état de la porte pour qu'elle et lorsque la chronologie
est terminée, soit ouverte ou fermée Nous avons dit que la boîte
de collision ici est un peu petite. Maintenant, au lieu de
changer de porte, je vais simplement me rendre
ici et je vais sélectionner cette case, et je vais
l'étendre un peu plus. Cela semble bien. Peut-être un peu plus parce que je ne veux pas que ce soit trop, car
si c'est trop, le joueur pourra
ouvrir la porte à une
distance plus grande que celle souhaitée. Nous pourrions demander à d'autres
mécaniciens de vérifier cela, mais pour le moment, cela suffira. mécanismes plus complexes
incluraient donc des tracés linéaires
et des vérificateurs
de distance par rapport à des points spécifiques Considérons que c'est réglé. La prochaine chose à
faire est de trouver un moyen de
dire au joueur que vous
êtes à portée et d'ouvrir
ou de fermer la porte. Nous allons donc utiliser un widget. Nous allons créer
un widget de plan que nous ajouterons
à notre fenêtre d'affichage,
et lorsque le joueur se
trouve près d'une porte, et lorsque le joueur se
trouve près d'une porte, il indiquera « ouvrir » ou « fermer » en
fonction de l'état de la porte Commençons donc par
créer un nouveau dossier dans le dossier de contenu
que nous appellerons UI. Et je vais le
coder en bleu clair. Génial. Maintenant, ici,
je vais cliquer, je ne vais pas
accéder aux plans
parce qu'il n'y a pas de plan d'
interface utilisateur Dans une catégorie différente, une catégorie unique
appelée interface utilisateur, laquelle nous pouvons voir la police, ardoise, le pinceau et d'autres éléments. Mais ce que nous voulons, c'est
un plan de widget. Comme pour les autres plans, il existe de nombreuses classes que nous pouvons prédéfinir et parmi lesquelles
nous pouvons choisir Mais ce que nous voulons, c'est
le widget utilisateur. Nous allons cliquer dessus
et le nommer WG door W JD, je
pense que c'est pourquoi Et je vais l'ouvrir. Maintenant, instantanément, nous pouvons voir qu'il ne s'agit pas d'une interface de
plan habituelle C'est quelque chose de différent. Eh bien, pas exactement, car
nous sommes dans l'onglet designer. Ici, il y a un onglet graphique, qui est
plus familier que celui du concepteur. Nous avons cependant une différence d'événements. Nous devons préconstruire et
construire au lieu de commencer le jeu. Par exemple, si nous allons ici, nous
avons le début du jeu et l'acteur de l'événement commencent à se chevaucher
et le tic-tac est le même. Maintenant, prebuild est un peu comme le script
de construction C'est comme exécuter ça, mais pas vraiment aussi. Trop de détails, je pense. Concentrons-nous sur l'onglet
concepteur pour le moment, et nous passerons
au code un peu plus tard. Alors, que voyons-nous ici ? Ici, nous voyons essentiellement
une représentation visuelle des résolutions et de l'apparence de notre
widget sur celles-ci. Il ne se bloque pas pour le moment car nous
n'avons rien dans le widget. La deuxième chose que nous voyons est le talon
détaillé et une palette. Une palette comporte des
éléments d'interface utilisateur tels qu'une bordure, un bouton ou une case à cocher. Ce sont les plus
courants, les sliders, le texte. Il possède également des fonctionnalités plus avancées, telles que la
saisie de zones de texte, de zones déroulante, de listes, de méthodes
pour configurer les visuels L'un d'eux est la toile. Qu'est-ce qu'une toile ? En bref, cela nous permet de définir un emplacement et une échelle dans la fenêtre d'affichage à la taille
d'écran que nous voulons Cela ne signifie pas qu'il doit nécessairement occuper tout
l'écran. Il peut s'agir d'un canevas qui
est un widget plus petit, mais c'est une référence
basée sur l'espace. Disons, par exemple, que
si j'apporte un bouton ici, je peux dire où il se trouve
et quelle est sa taille. Alors que si je n'avais pas
le canevas et que je n'
apportais qu'un bouton,
il n'y aurait le canevas et que je n'
apportais qu'un bouton, aucun point de
référence. Il s'agit simplement d'une annulation de résolution. Je vais supprimer le bouton. En gros, c'est
ce qu'est une toile. Il a beaucoup plus de détails
et de caractéristiques, mais en bref, c'est ce
que c'est Dans notre cas, nous utiliserons quelque chose de très simple en
plus du canevas. Nous n'utiliserons pas de
boutons ou quoi que ce soit d'autre. Nous n'utiliserons que du texte. Et pour donner à ce texte
une certaine forme, nous allons utiliser une boîte horizontale car nous voulons mettre
deux éléments de texte, l'un qui pourrait être le
bouton sur lequel appuyer et l'autre qui serait le texte
qui dit « ouvrir » ou « fermer ». Donc, même le fait de les séparer nous
aiderait si nous devions changer
le bouton, et bien sûr, pour changer le texte « fermer » ou «
ouvrir », alors que nous devions
taper à chaque fois pour
taper « ouvrir, fermer ». Il ne nous reste plus qu'à
taper « ouvrir » ou « fermer ». une petite différence, mais
à plus grande échelle, cela ferait une différence. Maintenant que j'ai
la boîte horizontale et que je veux
l'ancrer à un certain endroit, j'ai ici une sorte de fleur
qui indique au moteur essayer de la placer quelque part ici. Les ancrages comportent beaucoup, beaucoup plus de
fonctionnalités, comme le fait de placer l'ancre
au milieu et
de décaler ensuite le boîtier en le plaçant au milieu Il y a la taille de la
boîte, comme nous le souhaitons. Pour le moment, ces choses ne nous
dérangeront pas. Nous allons juste faire en sorte que
ça ait l'air correct. Ce serait tout,
rendons la résolution
un peu plus correcte, car je l'ai laissée entrer dans une résolution aléatoire qui n'
est pas très valide à chaque fois. Je vais donc le mettre ici. C'est la résolution. Je pense que si vous considérez que le joueur
est quelque part ici, je pense que s'il apparaît peut-être plus au
centre gauche, vers lequel il apparaît. Oui, je pense que cet
endroit est bien. Et je vais
déplacer cette ancre. Je vais également casser
l'ancre dans les coins et la poser
ici. Oui, c'est bon. C'est très bien. Où
devraient apparaître l' ouverture ou la fermeture et le
bouton que nous utilisons. Nous avons notre boîte horizontale, et nous devons
y mettre des éléments. Je vais choisir un texte. Je vais l'ajouter à
la case horizontale, et je vais en
ajouter une autre. Le premier texte serait simple. Je dirais juste E. Le deuxième texte, en fait, mettons également ce symbole ici et un espace et
un espace avant le symbole. Oui, c'est plus beau
avec ce symbole. Maintenant, la prochaine chose devrait être « ouvrir » ou « fermer ». Disons ouvrir et fermer. Ça a l'air d'aller bien. Nous ne
pouvons pas le laisser tel quel, mais jouons-en un peu
avec. Disons que je
veux être un
peu plus à gauche. Ce que nous allons
faire au lieu de changer les tailles pour le remplissage les alignements horizontaux
et tout le reste, nous allons simplement
aller ici, la transformation du rendu
et la déplacer un
peu vers la gauche. Par 20, 20, cela semble bien, peut-être 15 pour le rendu C'est l'option,
et cela la déplace légèrement vers la gauche
ou la droite, de haut en bas. Vous pouvez le redimensionner, le
sceller, l'incliner. En fait, cela oriente tout parce que je n'ai pas choisi cela. Cela doit changer 15. Oui, je pense que ça a l'air bien. Allons le voir en action. Allons l'ajouter
à notre page d'affichage. Je vais compiler, enregistrer
et voir notre widget. La question qui se pose est comment intégrer un
widget, bien sûr, à mon affichage, qui ne contient
que quelques notes et il est là L'autre question
qui se pose est la où dois-je mettre ce code ? Où puis-je utiliser un code qui
met en jeu un widget ? Eh bien, on pourrait le
mettre sur la porte. Cela signifie que chaque porte
doit créer un widget. Ce n'est pas un comportement optimal. Je pourrais le mettre sur
le plan de niveau. Cela signifie que ce widget
existerait à ce niveau et qu'il serait
créé uniquement ici. Mais nous allons avoir
un niveau vers lequel nous sommes en
train de passer, et nous avons besoin de ce widget pour maintenir là,
avec les deux niveaux Je pourrais donc utiliser une instance de jeu, qui s'applique à
l'ensemble du jeu. Mais si j'avais des menus principaux, si j'avais d'autres niveaux
où je n'utiliserais pas
ce widget, cela signifie que
ce widget
serait toujours dans l'instance. Donc, le dénominateur commun que je peux utiliser entre
deux niveaux en ce
moment avec ce à quoi nous avons affaire
serait le mode de jeu, parce que ce niveau utilisera
ce mode de jeu, le niveau de transition utilisera
ce mode de jeu Il est donc
logique de mettre le code ici dès maintenant pour cet exemple. Je vais donc accéder à
notre mode de jeu depuis les paramètres du monde. C'
est la troisième personne. Nous pourrions également le trouver ici. Donc, dans le mode de jeu à la
troisième
personne, Blueprints , à la troisième personne, s' il s'ouvre comme
ça, ce n'est pas un problème Il s'agit simplement
des paramètres par défaut du plan du mode de
jeu Si nous allons, par
exemple, à notre porte et que nous accédons aux valeurs par défaut de
notre classe, nous pouvons voir ces détails ici Donc, comme nous n'avons pas
ouvert le plan, il s'agit que de données Nous n'y avons
rien fait d'autre. Il affiche uniquement les valeurs
par défaut. Nous pouvons cliquer ici, ouvrir l'
éditeur de plan complet, et aujourd'hui,
nous pouvons voir le
script de construction, la fenêtre d'affichage,
qui, en mode jeu, a utilisations
très spécifiques et nous ne nous
laisserons pas embêter Et ce dont nous avons besoin, c'est
du graphique des événements. Et ce que nous allons faire
s'appelle l'événement de début qui se déroule
au début du jeu, et nous allons
créer un widget. Maintenant, pour la classe, nous
allons sélectionner la porte du widget, et pour le joueur propriétaire, nous allons obtenir la manette du
joueur. Nous pourrions avoir différents widgets appartenant à un flic local, par
exemple, et leur propriétaire changerait en
fonction de l'index des joueurs. Si je le laisse sous la forme e, nous ne pourrons pas
voir le widget car nous venons de le créer. Nous venons d'en faire une
variable. Selon nous, elle n'a pas été
invoquée. Pour ce faire, nous devons ajouter à viewpot afin que
notre widget soit visible Je vais donc compiler et enregistrer accéder au
verrouillage du didacticiel et appuyer sur Play. Et ici, nous pouvons voir notre widget. En gros, ce que nous
vérifions, c'est s'il bien placé lorsque nous
voulons ouvrir et fermer la porte. Je pense que si ça apparaît
juste là, c'est bon. Vous pouvez le placer
où bon vous semble. Et je pense que
c'est tout pour celui-ci. Je vous verrai bientôt où
nous mettrons en œuvre le mécanisme pour
afficher et masquer le widget. Au revoir.
13. Programmation de la visibilité des widgets UI en fonction des actions des joueurs: Bonjour et bienvenue
sur Unreal Engine Five,
Blueprint Mastery, Door Systems
et les portails interactifs Auparavant, nous avions fini par terminer la
partie conception de notre widget, que j'ai fermée. Donc non, je n'ai pas entendu ça. Nous avons créé un plan de widget. Nous l'avons appelé WG Door. Nous avons ajouté un panneau
de toile à notre hiérarchie. Eh bien, c'est un point
que je n'ai pas bien expliqué. Ici, nous avons
la hiérarchie, qui nous indique quels éléments se
trouvent à l'intérieur du widget. C'est un peu comme l'
onglet des composants dans les plans,
mais pour les widgets, la hiérarchie ici
nous indique quel widget est le premier, le
second, lequel appartient
à qui en gros De plus, je n'ai pas
beaucoup expliqué la boîte horizontale. Je pense que c'est assez
explicite. Il permet de disposer les
widgets horizontalement. Si nous survolons le
widget, cela permet de disposer le widget
dans un flux horizontal, si nous couvrons quelque chose, si nous le sélectionnons
et le survolons,
cela nous donnera une infobulle à ce sujet Allez, fais le truc. Je n'en ai tout simplement pas envie. Donc oui, en gros,
dans la palette, il est plus facile de voir
les infobulles ici. Cela doit se trouver sur l'icône elle-même. Nous avons créé le widget. Nous l'avons ajoutée à notre
fenêtre d'affichage en la
créant et en l'ajoutant à la fenêtre d'affichage via
le mode jeu Lorsque l'événement commence à jouer, nous avons créé le widget, puis nous l'
avons ajouté au viewpod Maintenant, nous l'avons
intégré au mode jeu parce qu'il sera
partagé entre les niveaux, et nous voulons que ce widget
existe dans tous les niveaux. Mais nous ne voulons pas ajouter le widget
dans la fenêtre d'affichage au
début du jeu Nous voulons l'ajouter à la
fenêtre d'affichage lorsque nous l'appelons. Ce que nous allons faire, c'est le promouvoir
en tant que variable, qui est notre référence de widget. Lorsque nous créons, nous
obtenons une valeur de retour, qui est une référence
à ce que nous avons créé. Et je vais nommer
ce wg point Rep. Comme vous pouvez le voir, le thème
avec les références est un peu important
dans Appeler des références, trouver des moyens faire référence à quelque chose
comme dans le plan de niveau selon lequel
nous faisions référence aux cases de déclenchement lorsque nous
avons la référence à
l'autre composant, auquel nous demandons s'il possède une balise Les références existent. Les références sont l'
Alpha et l'Oméga, si vous voulez, de la programmation
orientée objet. Nous avons maintenant enregistré une
référence du widget. Nous allons donc
créer un événement personnalisé. Je vais appeler cela Widget. Je vais le connecter
à la fenêtre de sortie, et je vais apporter
la référence
ici et la connecter
à la cible Parce que si nous
sortions juste de la fenêtre d'affichage, cela déclencherait probablement
une erreur ou ne ferait rien car il n'y aurait pas de cible car la cible elle-même
signifie un mode de jeu Ce n'est pas un widget, il
ne peut donc pas l'ajouter à la fenêtre d'affichage. Mais la référence au widget dans Cam a été ajoutée à la fenêtre d'affichage et
cela fonctionnera correctement. Maintenant, la prochaine chose que
nous faisons est de créer un autre événement personnalisé et d'
appeler ce widget de suppression de points. Je vais faire glisser un câble depuis la référence du widget et
dire supprimer du parent. C'est ainsi que nous supprimons les widgets de la fenêtre d'affichage,
l'une des méthodes Utilisons donc
ces deux fonctions. Allons à notre porte à sens unique. Passons au graphique des événements. Passons à notre collision. Ainsi, lorsque nous entrons en collision
et que nous commençons à nous chevaucher, nous devons afficher notre widget Pour appeler cela, je dois avoir
accès au mode jeu, donc j'ai besoin d'une référence
au mode de jeu. Heureusement, Unreal Engine propose un bon moyen d'obtenir le mode de jeu C'est ce qu'on appelle le mode de jeu G. Mais cela renvoie
une valeur générique. Nous avons un mode de jeu spécifique. Nous avons le mode de jeu à la troisième
personne, ou nous avons le mode de jeu Doors ou nous pouvons avoir n'importe quel
type de mode de jeu. Cela renvoie uniquement une référence d'
objet basée sur
le mode de jeu
générique . Pour vérifier si c'est notre mode de jeu, nous allons devoir lancer. Nous allons donc passer au jeu à la
troisième personne. Comme nous l'avons dit, le casting
demande quelque chose êtes-vous ce truc, en gros, est-ce que cet objet est ce
genre d'objet ? Je vais donc passer
à un moulage pur, qui supprime simplement
l'épingle d'exécution et facilite un
peu les choses. Si nous y parvenons et que notre
mode de jeu est le mode de jeu car le succès est comme
s'il s'agissait d'un lancer impur, lancer
échoué ou d'un casting réussi Nous avons maintenant un BolLont qui
nous indique s'il a réussi ou non. Donc, si nous y
parvenons, nous pourrons obtenir
des informations. Nous pouvons obtenir certaines fonctions et événements à partir du mode de jeu à la troisième
personne. L'événement que nous voulons pour le
moment est d'ajouter le widget. Ici, je peux simplement
faire glisser un autre câble et dire supprimer le widget à points et de le
connecter ici. Je vais compiler,
enregistrer et tester. Je vais aller à la première porte, elle s'ouvre, à la deuxième porte, nous avons un widget, et
il est en train d'être retiré. Sympa. Mais le fait est que
notre widget ne
correspond pas à ce
qu'il devrait dire. Par exemple, pour le moment, il devrait
indiquer ouvert et pour l'instant, il devrait indiquer fermé, ce qui est correct, mais ce n'est correct
qu'à 50 %. Ce
n'est pas toujours correct. Alors réglons ce problème. Et pour cela,
nous allons passer
à notre mode de jeu à la troisième personne, et nous allons
créer une fonction. Alors, qu'est-ce qu'une fonction ? En gros, il s'agit d'un ensemble
d'actions ou de logiques, si vous voulez, qui est réutilisable. Il peut être utilisé plusieurs
fois et peut être appelé simultanément
plusieurs fois, et il exécutera des
tâches spécifiques à chaque fois. Comme un événement s'
il est appelé à nouveau, s'agit généralement de
vous le nouvel appel, alors que les fonctions s'
exécuteront simplement à nouveau. pratique, par exemple,
les collisions multiples
se chevauchant , par exemple,
de nombreuses balles
vous frappent en
un seul instant Cela sera indiqué dans l'ordre,
lequel activera le premier et
lequel sera le second, et cetera. S'il s'agissait de fonctions, elles seraient toutes
exécutées immédiatement Ils seront empilés et exécutés
immédiatement. Donc, en gros, nous
aurions pu créer un événement, mais pour ce scénario, nous avons créé une fonction. Maintenant, une autre chose à propos des
fonctions est que, bien sûr, elles ont des entrées, comme nous
pouvons le voir dans leurs détails, mais elles peuvent aussi avoir des sorties. Par exemple, si je
voulais que quelque chose sache s'il a réussi ou non, je pourrais avoir la sortie d'un
Bollian et, comme vous pouvez le voir, cela créerait un nœud de retour Et ce booléen peut
être vrai ou faux, par
exemple, si quelque chose que je
n'ai pas entendu réussit ou Je vais le supprimer
et je vais supprimer le bon de retour car
nous n'en avons pas besoin. Nous allons compiler et enregistrer peut-être un autre détail sur les fonctions et
ce sera tout. Des fonctions, elles ne peuvent pas
contenir de choses temporelles. Ils peuvent appeler des choses de
l'extérieur, mais ils ne peuvent pas
être retardés ici. Nous ne pouvons pas avoir de calendrier ici, ne
pouvons pas avoir de minuteries. Le temps est donc quelque chose qui
ne peut pas avoir de fonction. Maintenant, notre fonction,
que devons-nous faire ? Appelons cela une mise à
jour, un widget, un texte. Et nous allons avoir besoin d'une
nouvelle entrée de type chaîne. Je vais l'appeler
par jet text. Maintenant, ce que cela va faire, nous allons obtenir notre référence au
Widget D. Je vais le mettre ici,
et je vais recevoir un texto. En fait,
passons à notre widget. Allons voir notre designer. Maintenant, nous voulons changer
ce texte ici, le texte qui dit « fermer ». Si nous le voyons au-delà
des détails, il y a un nom que nous pouvons mettre ou
nous pouvons réellement le mettre ici, mais je vais
choisir d'être ici. Appelons cela le
texte du widget. Le texte de mon widget. Maintenant, à côté, il y a un bouton
appelé Is variable. S'il n'est pas cliqué, cela signifie
qu'il est statique Il ne peut pas être modifié, alors que si je clique sur une variable, il peut être modifié par le biais du code. Il y a de nombreuses raisons pour lesquelles cela se produit dans les
coulisses, mais n'entrons pas
trop dans les détails. Revenons à notre mode de jeu, et non au graphique des événements notre mode de jeu dans la
fonction Mise à jour du widget, et nous allons
obtenir le texte de mon widget. À partir de là, je vais
définir le texte comme nous l'avons fait avec les rendus de texte dans
le texte du flux BP Je vais le relier à, c'est un texto. Nous pouvons transformer cette
chaîne en texte. Et peut se connecter directement. Si je le laissais ficelle,
cela n'aurait pas d'importance. Je le traduirais automatiquement
en chaîne de texte. Mais pourquoi ne pas rendre cette partie
un peu plus claire, et je vais
simplement la remplacer du texte et la relier ici. Nous avons donc une fonction
qui modifie notre texte. J'ai besoin de compiler le widget car nous rendons ces
deux variables. J'avais besoin d'être compilé, c'est aussi sauvegardé, et
maintenant c'est bon. Je pense que c'est un
bon point d'arrêt. Nous allons continuer
dans le prochain implémenter cette nouvelle fonction. Au revoir pour le moment.
14. Mise à jour des widgets d'interface utilisateur avec des entrées de plan externes: Bonjour et
bienvenue sur les systèmes
de portes Unreal NGinfb Blueprint
Mastery Door et les portails interactifs. Auparavant, nous avions ajouté
la fonctionnalité permettant d'ajouter le widget de porte ou de supprimer le widget de porte en
fonction de l'éventuelle collision
avec la porte Pour ce faire, nous avons créé
deux événements personnalisés, et nous avons utilisé le viewpod at retirés du parent
et les avons connectés à la référence
du widget que nous avons stocké
au début de la partie. Ensuite, nous nous sommes dirigés vers notre porte à sens unique
BP, et lors des événements de début de
chevauchement et de fin de chevauchement liés à la collision, nous avons ajouté le widget ador et
supprimé la porte en conséquence. En passant au mode jeu et en passant à notre mode de jeu à
la troisième personne. Ensuite, nous avons créé une fonction dans le mode de jeu à la troisième personne, que nous avons appelée
update Widget text. Maintenant, cette fonction avait
une entrée de texte du widget, et elle définit le texte
par le biais de la référence
du widget de porte, et nous en avons obtenu
le texte de mon widget. Continuons maintenant en créant le système qui mettra
à jour le texte du widget. Pour ce faire, allons à notre porte à sens
unique et créons une autre fonction
que nous appellerons à
nouveau le widget de mise à jour. Texte. Dans cette fonction, nous
aurons notre mode de jeu, et nous pouvons passer au mode de jeu et au
mode de jeu,
et nous pourrions lancer le mode de jeu à deux à la troisième personne et le
convertir en mode pur. Mais ce que nous pouvons faire, étant donné que nous l'utilisons si souvent
dans ce plan, nous pouvons commencer à jouer Nous pouvons copier ce code d'ici. En fait, je vais juste
couper ce code à partir d'ici, commencer à jouer, le coller ici. Je vais le connecter en
tant que nœud de casting cette fois. Et je vais en
faire une variable. Et comme vous pouvez le
constater, Area l'a
déjà baptisé BP
Game Old à la troisième personne, très pratique. Je vais compiler, et il est
indiqué qu'il ne peut pas compiler parce que la cible de ces deux fonctions
a été déconnectée. C'est ce que je voulais dire auparavant cible fait référence à qui
est censé le faire. Et pour le moment, Self n'
a pas de fonction de
widget ador. Même si c'était le cas, la cible que la
cible prédéterminée de cette fonction serait la
tension artérielle à la troisième personne. Donc, même si je crée un événement
personnalisé, ajoutez le jet. Vous pouvez voir que cela produira
toujours un message d'erreur car la cible est P. Nous l'avons appelée
depuis le mode jeu. Pour que l'erreur disparaisse, nous allons simplement apporter notre référence
à partir de nos variables ici et nous allons la
connecter ici et la
connecter ici. Et je pense que cette
variable de chaîne n'est utilisée nulle part. Nous pouvons toujours trouver des références. Mon nom Non, il
n'est utilisé nulle part, donc je vais le supprimer, et je vais le compiler à nouveau, et maintenant l'erreur a disparu. Revenons au texte de notre
widget de mise à jour du widget. Maintenant, nous n'en avons pas besoin
. Nous pouvons simplement apporter notre référence au mode de jeu car il s'
agit essentiellement de stocker le mode de jeu, cette instance du mode de jeu, et nous allons
mettre à jour le texte rigide. Maintenant, nous avons notre
fonction ici, nous devons renseigner le type de texte qui apparaîtra Donc, pour ce faire, nous allons obtenir l'état de la porte. Nous allons activer
l'état Dor car c'est ce qui contrôle et nous pouvons réellement
montrer un autre nœud. Ce serait bien mieux. Connectons-le ici. Il existe un autre nœud dans lequel nous
pourrions créer du texte
, puis y ajouter le texte
et définir ce texte. Nous pourrions faire comme une chaîne de
caractères ou, cette fois, un texte. Et nous pourrions avoir un tas de
setters basés sur le switch. Nous pourrions donc avoir celui-ci sur ce cas,
celui-ci sur ce cas, celui-ci sur ce cas, puis connecter ce texte ici. Maintenant, l'autre chose que nous pouvons faire, c'est qu'
il existe un autre nœud
que nous pouvons utiliser sur des variables
spécifiques, appelé select. Les nœuds sélectionnés ont
un index générique, ce qui signifie qu'ils peuvent devenir
certains types de variables Donc, si j'appuie ici, nous pouvons voir les types de
variables que cela peut devenir. Et comme vous pouvez le constater, cela peut
devenir une énumération. Cela signifie donc que je peux le
connecter ici, et cela me donne le choix pour
chaque élément pour chaque
énumérateur, Ainsi, lorsque l'énumérateur est
ouvert, il me donne ce choix. Quand il est fermé, il me
donne ce choix. Voyons maintenant ce dont
nous avons besoin pour chaque cas. Pour ouvrir, il faut fermer. Pour fermer, nous devons ouvrir
et pour les deux autres, nous n'avons besoin de rien car nous
n'interagissons pas avec
la porte à ce moment-là. Nous allons donc compiler, enregistrer et tester. En fait, non, nous devons d'
abord le coder, car le simple
fait de le créer ne signifie pas le coder. Quand le widget doit-il être mis à jour ? Bien sûr, avant de l'
ajouter à la fenêtre d'affichage. Je vais donc simplement
partir des fonctions, je vais le
glisser-déposer ici et le connecter ici. Je vais également le copier-coller
et le connecter ci-dessous. Et le widget devrait
également être mis à jour lorsque, en gros, les prochains points que nous devrions mettre à jour
sont chaque fois que nous changeons d'état, puisque notre état
affecte le widget, ce que le widget est
censé dire. Je vais donc le
glisser-déposer ici et je vais connecter
les deux câbles ici. Et comme vous pouvez le voir, je peux avoir deux exécutions
connectées à un nœud. Maintenant je vais faire de même. Je vais le copier et le coller ici dans ces deux exécutions. L'une serait la mise à jour, l'
autre la fin. Maintenant, allons le tester. Aucune pression, le jeu ne s'ouvre. Nous avons ce E là-bas qui ne
fait pas exactement
ce que nous voulons. Il ne disparaît pas. Mais, euh oui, réglons ça. Ce que nous allons
faire est donc assez simple. Au lieu de mettre à
jour le widget lors de la mise à jour des chronologies, nous
allons supprimer le widget Je vais donc copier
ce code ici, en mode de jeu à la troisième personne de
BP, mode de jeu à la troisième personne de
BP supprimer Door et le
coller à la fin de la chronologie de
la mise à jour de la chronologie. La prochaine chose que nous devons faire
est qu' après avoir mis à jour le texte de
ce widget, nous devrions également
l'ajouter au portagym
de vues de Cypress Paste Je vais appuyer sur Copier, et je vais le coller
ici et le connecter ici. Et cela devrait
fonctionner. Allons tester. Et ça marche. Génial. Je pense que
c'est tout pour celui-ci. Je te verrai
le prochain. Au revoir.
15. Programmation d'un système de porte battante bidirectionnelle: Bonjour et bienvenue
sur Unreal Engine, cinq systèmes de portes
Blueprint Mastery
et portails interactifs Auparavant, nous avions fini avec
notre système de widgets pour afficher la fermeture ou l'ouverture
selon que notre porte devait s'
ouvrir ou se fermer. Nous avons donc créé cette fonction, à jour le texte du widget dans notre porte unidirectionnelle VP qui
appelle la fonction créée
dans la leçon précédente, à jour le texte du widget depuis
le mode jeu et rempli le texte correspondant
à l'état de la porte. Maintenant. Comme nous avons ce petit E
ici sur le widget, nous avons fini par ajouter du code pour supprimer le
widget de porte lorsque la porte ouvre ou
se ferme et également l'ajouter lorsque la
porte est ouverte ou fermée, lorsque l'animation est
terminée depuis la chronologie Passons maintenant
à la porte suivante. Je vais donc rendre
le niveau trois visible et me rendre ici. Cette porte doit s'ouvrir en face de
l'endroit où le joueur regarde. Pour ce faire, nous allons dupliquer
notre porte actuelle. Mais économisons également. Vous avez vu ce petit
astérisque ici, cet astérisque blanc.
Permettez-moi de faire un changement. Où est la porte,
voici la porte. Tu vas y aller ici. L'astérisque apparaît donc. Vous voyez que cet
astérisque ici signifie que quelque chose a changé
dans le plan et qu'il doit être enregistré, que cet actif n'a pas été C'est ce que signifie cet
astérisque. Je vais enregistrer à nouveau, Control Shift S pour tout enregistrer, et je vais
dupliquer ce plan Je vais l'appeler BP, l'
opposer au joueur D. L'orthographe est peut-être
correcte, peut-être pas. Nous ne le saurons jamais. Je vais donc ouvrir ceci, et c'est le même plan Il s'agit d'une version dupliquée
du plan que nous avions. Mais avant de commencer
à apporter quelques modifications, ce ne sera pas grand-chose. Passons à la carte du didacticiel et ajoutons une nouvelle version du texte flottant. Et sélectionnons
notre point lumineux. Amenons-le
ici, ici. Je pense que c'est bon ici. De plus, la collision entre les boîtes de
collision s'aggrave. C'est très bien Et
enfin, le texte. Mais remplissons d'abord le texte. Nous allons sélectionner le plan. Passons à la valeur de mon texte. Cette porte s'ouvre
en face du joueur. C'est bon. Et maintenant,
sélectionnons le texte. Je ne vois pas le texte. C'est parce qu'il est invisible. Oui, au lieu de le
faire à chaque fois, modifions simplement une chose sur le plan.
Ouvrons le plan Au début de la partie,
ramenons le texte et définissons la visibilité sur False. Passons au
rendu de mon texte et à la visibilité. Vrai Compilons et
sauvegardons de nouveau sur notre carte. Maintenant, nous pouvons voir le texte, et lorsque le jeu commencera,
il disparaîtra. Je vais apporter ça ici. Je vais revenir
au plan, aller au
texte pour le mettre en forme Augmentons un peu la taille
ici. Donc, Shift, entrez ici. Shift entre ici, et
Tada est à nouveau sélectionné. Oui, c'est bon. Peut-être
un peu plus petit. Maintenant, comme cela
prend la forme d'un segment, essentiellement d'un point de capture, je peux le désactiver d'
ici, le
faire et le réactiver pour
activer les points de capture Apportons donc également notre nouvelle
porte ici. Donc, à l'opposé du joueur,
allez l'apporter ici. De quel côté dois-je
le tourner dans cette direction ou dans cette
direction, dans cette direction. Gardons le même robot. Oui, ça a l'air bien. C'est bon
Passons donc à la fonctionnalité. Peu de choses vont changer. Trouvons la porte. Nous allons fermer
les autres plans dont nous n'avons plus besoin. Je n'en ai pas besoin.
Enregistrez le mode de jeu. Oui, juste à la porte d'en face, et ce sera tout. Maintenant, ce que nous voulons changer
concerne essentiellement la chronologie, que cet angle soit de -90 ou 90 en fonction de
la position du joueur Nous pourrions avoir plusieurs
collisions et vérifier de chaque côté si le joueur est de ce
côté ou de ce côté. Mais il existe un autre moyen
plus rapide et plus facile de le faire. Nous allons créer une fonction
pour calculer la direction. Et dans cette fonction, nous allons localiser
nos acteurs, alors localisons-nous. Et nous avons
également besoin de l'emplacement du joueur. Pour faire participer le joueur
à ce scénario, nous pouvons simplement le ramener
chez lui et à partir de là, nous pouvons également dupliquer et nous connecter ici. Nous avons donc deux emplacements, celui du joueur et celui de la
porte. Maintenant, la porte a une face avant
parce que nous avons la flèche. Et si nous ouvrons le lecteur, celui-ci
possède également une face avant. Revenons maintenant à
notre direction de calcul. À partir de ces deux endroits, nous devons trouver la direction entre la porte et le joueur. C'est derrière moi ou
c'est devant moi ? Donc, pour obtenir la direction, un vecteur de
direction unique unique à partir de deux. Cela produit un résultat vectoriel, ce qui signifie qu'en
fonction de ma position, Y, X et Z peuvent
être négatifs, voire positifs. Démontrons cela. Je
vais imprimer une chaîne. Je vais le connecter
ici et allons jouer. Mettons-le ici. Maintenant, franchissons la
porte. Celui-ci s'ouvre. J'ai oublié de connecter
cette fonction. Connectons-le en
appuyant sur E, en fait. Je vais donc calculer la
direction. Ici. Donc, lorsque j'appuie, vous voyez que toutes les variables
sauf Z sont négatives. Mais si je vais ici,
ils seront encore une fois négatifs. Eh bien, maintenant le X est positif, parce que je suis
d'un autre côté, si nous prenons les centres
en considération, ici, le X est plus, alors qu'ici, c'est moins. Je ne peux donc pas vraiment dire
lequel devrait être celui-ci. Si je passe de l'autre côté, le Y changera également. Si j'avais ce magasin ici, le Y aurait un moins, le Y un plus ici. Donc ça ne
termine pas vraiment le travail. Ce que nous devons faire, c'est
créer un produit à points. Et qu'est-ce que le retour d'un produit ? Cela n'
explique pas vraiment grand-chose. Alors, qu'
est-ce qu'un produit à points ? C'est une façon de comparer
deux directions. Nous avons ici la direction
de notre acteur, et la prochaine direction
serait le vecteur avant. Vecteur Get forward. C'est ici. Pas celui-ci. Désolée. L'acteur en avant, voilà, faites avancer l'acteur en vecteur. Donc, en gros, c'est
le devant de la porte. Nous avons donc cette
direction et nous avons la direction entre la
porte et le joueur. Nous avons donc cette direction
et l'avant de la porte. Maintenant, sur la base de ces
directions, le produit ponctuel, il nous indique dans quelle mesure
ces deux vecteurs, ces deux flèches pointent
dans la même direction. Si le produit à points est un nombre positif
élevé, ils pointent dans
la même direction. S'il s'agit d'un nombre négatif, ils pointent dans la direction
opposée. Et si c'est zéro,
ils pointent à angle droit l'un par rapport
à l'autre. En gros, il
calcule le cosinus de l'angle qui les sépare C'est ce que fait le produit à points, et il nous donne un flottant sous forme de
rendement négatif ou positif. Et c'est ce que nous
allons utiliser pour vérifier s' il est supérieur ou égal à zéro. Et s'il est supérieur
ou égal à zéro, nous allons créer
une nouvelle variable. Je vais appeler cela un angle ouvert. Nous allons le changer
en flotteur. Je vais faire venir un
setter ici. Et encore une fois, nous allons sélectionner
un nœud, sélectionner un flottant. Maintenant, vous voyez, si
je fais glisser le câble, sélectionne, je reçois
celui-ci, je sélectionne Float et je fais sélectionner celui-ci. Celui-ci a la carte blanche, tandis que l'autre a
un lingot par défaut Je vais donc le
connecter ici. Je vais relier
le résultat de notre plus grande erreur égal à
zéro à notre produit à points. Et ce serait, je pense que A serait
-90 et B serait 90 avant que la
porte soit positive, donc elle s'ouvre en face Oui, je pense que c'est ça. Maintenant, où allons-nous connecter cette direction de
calcul ? Si nous le connectons
au début ici, nous n'
allons pas le faire. Je vais calculer
la direction à chaque fois. Donc, quand je vais en face de
la porte pour la fermer,
elle s'éteint. Je vais changer de direction. Mais si je ne le connecte que
lorsque la porte est fermée, connectons-le pour jouer
dès le départ et, bien sûr, ramenons l'angle ici. De cette façon, il ne
calcule que le moment où la porte est fermée, et lorsqu'elle passe
de l'ouverture à la fermeture, il utilisera le même angle que celui qu'il avait calculé auparavant. Maintenant, allons le tester. Nous pourrions amener le
joueur à commencer par nous. OK, il s'ouvre de cette
façon, se ferme correctement. Il s'ouvre de cette façon,
il se ferme correctement. Nous avons donc maintenant une porte
qui s'ouvre et se ferme. OK, je passe en revue
la physique des jeux. Maintenant, nous avons une porte
qui s'ouvre et se ferme, comme celle que le joueur
regarde. OK, je pense que c'
est tout pour celui-ci. Nous allons continuer par
la porte double suivante. Ce sera pareil mais le
double lors de la prochaine leçon. Au revoir pour le moment.
16. Créer et synchroniser des portes doubles avec des plans: Bonjour et bienvenue sur les Blueprint Mastery,
Door Systems et
Interactive d'
Unreal Engine Door Systems et
Interactive Auparavant, nous en avions fini
avec notre porte à double sens, gros, le contraire
de la porte ouverte par le joueur. En gros, nous avons
créé une fonction de direction calculée qui, en
fonction la position de l'acteur
et de la position du joueur, a obtenu une direction unitaire. Nous avons calculé le produit
scalaire avec notre vecteur acteur vers l'avant, et nous avons comparé s'
il était supérieur ou égal à zéro pour calculer
le nouvel angle. Ensuite, nous avons ajouté ce nouvel angle à notre larp dans notre
chronologie en tant que cible Maintenant, faisons les
quatre mêmes choses à double porte. Faisons en sorte que le
niveau quatre soit visible. Et en fait, je peux apporter celui-ci. Oui, je peux apporter celui-ci.
Apportons-le ici. Déplaçons la lumière dans
cette direction cette fois. Et aussi le texte. Renommons le texte. Nous allons sélectionner le plan.
Je ne vois rien. Je n'ai pas sélectionné le plan.
J'ai sélectionné la racine. Il s'agit donc d'une double loi. Non Déplaçons-le un peu. Nous devons également nous occuper de l'
entrée. Nous sommes une variable. Oh,
je me suis cachée. Je pense donc que c'est bon. Et créons notre nouveau plan de
porte,
et nous reproduirons le
contraire de celui du joueur Maintenant, appelons cela une porte BPW. Et ouvrons-le,
compilons-le et sauvegardons. Donc, ce que nous devons faire
ici est assez simple. Nous allons dupliquer
ce maillage ici. Je vais cliquer
et dupliquer ou je pourrais copier-coller,
et c'est tout. Ensuite, ce que nous allons faire c'est placer ce maillage ici. Il va nous falloir un peu d'espace. Je vais donc le déplacer
ici. Je vais dupliquer cette rotation relative
définie relative, et le larp, et nous allons le
connecter ici Et nous avons besoin de l'Alpha. Nous devons connecter la cible, qui est le nouveau maillage. Et ce que nous devons également faire,
c'est multiplier cela par moins un, car nous allons
annuler la rotation Nous devons donc également corriger les messages
statiques ici, et il est temps de
sélectionner la nouvelle porte. Je vais donc
compiler et enregistrer. Je vais retourner sur la carte. Je vais me rendre à
notre porte Tuggle
ici . Je vais sélectionner
la première partie. Je vais le trouver dans
le navigateur Condat grâce cette
option de maillage statique ici, appuyant sur ce bouton,
et le tour est joué Je vais revenir
à notre plan, sélectionner la première porte et
utiliser l' actif sélectionné dans le navigateur
de contenu Maintenant, nous allons faire de
même pour le prochain. Sélectionnez le
magasin suivant et importez-le. Maintenant, d'après ce que je
vois, il y a un peu le contraire ici. Donc ce serait celui-ci
et ce serait celui-ci. Je pense qu'ils sont bien espacés. Déplaçons-les maintenant au
centre du plan. Oui, c'est bon.
Augmentons également la taille de la collision. C'est bon là-bas. Et testons-le parce que je pense qu'il
faudrait peut-être faire le contraire. Retournons donc dans notre
chambre et introduisons la nouvelle porte faire pivoter. Il y a de fortes chances
que nous assistions une animation amusante parce que
j'échange les portes. Mais si nous ne
testons pas, nous ne le saurons pas. Je vais donc demander aux
joueurs de recommencer ici afin que nous ne parcourions pas tout
le niveau. Qu'est-ce que la boutique ?
Oh, j'ai dû supprimer par
accident, apportez-le ici. D'accord. Quoi qu'il
en soit, commençons ici. Jouons. Il s'agit d'une
double porte ouverte, fermée. Oui, il s'ouvre en face. Elle s'ouvre vers moi
au lieu de s'éloigner de moi. Ouais Nous pourrions donc le
laisser tel quel ou
simplement échanger les deux. Je suis sûr qu'il y avait un moyen
de le faire plus rapidement. Moins de clics. Mais de toute façon, ouais. Et nous avons une double porte. Maintenant, c'est bien que nous
ayons une porte double, mais commençons à ajouter
des sons à nos portes. Ajoutons un son d'ouverture
et de fermeture. Donc, à partir de l'état ouvert, nous
voulons transmettre le son à D. Il s'agit d'un nœud qui émet un son dont
nous pouvons définir le son, mais que nous ne pouvons
pas manipuler par la suite. Il n'a pas de sortie
pour enregistrer le son. Il y a donc très
peu de paramètres ici. Nous allons utiliser
le multiplicateur de tonalité, et pour le son, nous
allons trouver la porte ouverte. Porte ouverte à celui-ci. Maintenant, pour ce que nous allons
faire avec le pitch, nous allons faire un flottement
aléatoire dans la plage pour augmenter légèrement le ton d'
ouverture , normal à supérieur. Et le plus élevé serait
d'un point, disons 15. Et nous allons
dupliquer ce code. Que je le mette après
le calcul ou
avant, peu importe, mais je le
mettrai après. Faisons de la place ici. Et au lieu de
multiplier le pitch par des flottants aléatoires
de un à 1,5, nous allons faire une Donc, disons 0,8 à
0,99, ce qui donnerait l'impression que
c'est plus lourd,
comme une tonalité plus basse, en gros Alors testons cela. Ouaip. Il y a un
bruit dans notre porte. Du pain. Je pense que c'
est tout pour celui-ci le suivant, nous
allons commencer par notre porte de raccourci.
Au revoir pour le moment.
17. Programmation d'une porte raccourcie pour un accès plus rapide: Bonjour et bienvenue
sur Unreal Engine Five, Blueprint Mastery Door Systems
et portails interactifs La dernière fois, nous avons donc fini
avec notre double porte. Maintenant, ouvrons l'œil suivant. Nous voici sur notre porte de
raccourci, qui sera une porte qui, d'
un côté, ne s'ouvre pas. C'est écrit « verrouillé ». Et
lorsque vous passez de l'autre côté, vous pouvez déverrouiller. Pour ce faire, nous devons
effectuer un très petit travail préalable. Nous devons revenir à notre état d'
énumération I Dor, et nous devons ajouter
un énumérateur,
et disons qu'il est verrouillé.
Je vais économiser. Mais comme cela ne
changera rien aux portes précédentes,
le fait changera rien aux portes précédentes,
le avoir verrouillé ici ne
sert rien car cette
porte ne peut pas être verrouillée. Mais même sur le widget Update, il ne tape pas non ici. Je m'attendais à dire
non à quelque chose comme ça, mais il semblerait que cela
le laisse vide. Cela n'a donc pas vraiment eu d'effet. Mais peut-être que dans d'autres systèmes, il n'est pas recommandé d'
ajouter des énumérateurs
après les avoir utilisés Maintenant, nous avons ajouté la
catégorie verrouillée dans un énumérateur. Passons au dossier de la porte, et dupliquons à nouveau le
contraire de celui du joueur. Appelons cela une porte
raccourcie BP. Ouvrons-le. Encore une fois, nous devons changer
certaines choses, mais pas beaucoup. La première chose que nous allons faire est donc séparer l'animation et le son d'un événement à
part
entière, afin que nous puissions l'appeler. Je veux juste mettre ça ici. Et je vais
créer un événement personnalisé
et l' appeler animation de porte. Et connectez-le à l'interrupteur. Nous voulons également changer l'état de la porte
par défaut en verrouillé. Compilez et enregistrez. Et maintenant, nous devons créer un mécanisme pour vérifier si la porte est verrouillée. Et c'est assez simple. Nous allons apporter
notre dénombrement. Nous allons utiliser un nombre égal,
pas un opérateur égal parce que
nous le transformons en octet, et nous voulons que ce
soit un nombre égal, afin de pouvoir choisir parmi
les énumérateurs Je vais donc choisir verrouillé. Je vais
replacer une branche avec B et cliquer. Et quand on appuie dessus, je vais vérifier
s'il est verrouillé. Il nous faut de la
place ici. C'est bon. Ensuite, si elle n'est pas verrouillée, nous allons simplement
animer la porte. Animation de porte. Nous allons
jouer l'animation de la porte. Mais s'il est verrouillé, nous devons créer un
mécanisme ou les règles de verrouillage. Nous allons donc créer
un événement client. Appelez ça Short-Cut
Dog Lock Mechanic. Déjà. Et nous
devons l'appeler ici. Donc, raccourcissez, verrouillez, mécanicien. Maintenant, chaque fois que nous appuyons sur E, nous vérifions s'il est verrouillé, s'il est verrouillé, le
mécanicien joue. Vérifie si le joueur
est sur la face avant. Et ce que nous pouvons utiliser, c'est essentiellement
la direction de calcul. Nous avons juste besoin de la
cheville qui est calculée. Mais je veux démontrer autre
chose. Je veux copier ce
code ici, qui nous indique que s'il est
supérieur ou égal à zéro, c'est devant, s'il est inférieur, c'est au verso. Et ce que je vais faire, c'est
créer une autre fonction. Et je vais
appeler cette fonction is front side, point d'interrogation. Et je vais rendre
cette fonction pure, et les fonctions pures ont
toujours besoin d'une sortie. Et je vais renommer
cette sortie en front side. Je vais coller le
code que nous avons copié. Et connectez ce résultat à
cet opérateur ici, et nous avons cette fonction. Maintenant, allons appeler
cette fonction. Je vais aller voir notre mécanicien de portes
plus courtes et apporter cette face avant. Comme vous pouvez le constater, c'est vraiment différent
des autres fonctions. Voyons la direction du
calcul. Il possède une entrée d'exécution
et une sortie d'exécution. Celui-ci est juste vert. C'est comme la manette Get
Player. C'est comme si le composant avait une
étiquette. Ça ressemble à ça. Cela est dû au fait que les fonctions pures n'exécutent que certaines opérations sans définir quoi que ce soit à l'intérieur de
définir une variable ou
quoi que ce soit à l'intérieur. Comme vous pouvez le voir, il s'agit simplement d'une fonction
d'expression mathématique pure, dont le résultat
est un booléen Nous ne fixons rien. Nous pourrions définir des variables
locales parce que les fonctions ont ces variables
locales ici qui n'existent que dans
la fonction pendant exécution, puis elles disparaissent presque, mais chaque fois que
la fonction s'exécute, crée ces nouvelles variables, et chaque fois qu'elle les utilise, elle les libère ensuite, ce qui est très optimal. Les fonctions pures ne devraient donc pas avoir d'éléments définis à moins
qu'il ne s'agisse de variables locales. En voici le résumé. Et bien sûr, ils ne nécessitent
pas d'exécution, et ils ont le résultat
d'une action. Je vais donc
appuyer sur une branche ici, vais le connecter
ici, et nous vous demandons si nous
sommes au premier plan. Encore une fois, cela pourrait être fait
si les angles étaient de -90, nous aurions été
à l'avant. Je voulais donc simplement démontrer
cette fonction pure. Et on peut aussi mettre un « not » ici et non un
bullan et un négatif Donc, le vrai signifiera déverrouiller, et le faux
signifiera ne pas déverrouiller. Si c'est faux, nous sommes
au recto. Si c'est vrai, nous
ne sommes pas au premier plan. Nous sommes à l'arrière parce que
nous l'avons mis ici et non ici, ce qui en fait le contraire
bullien Si c'est vrai, nous voulons
définir l'état de la porte. Et ce serait fermé car une fois que nous l'avons déverrouillée,
la porte reste fermée Ensuite, nous pouvons émettre un son. Jouez du son Je crois que cela s'
appelle Dog and Lock. Ouaip. Et comme cette porte
est censée être verrouillée, allons-y et nous
devons la montrer au joueur d'une manière ou d'une autre. vais sélectionner une porte, et je vais changer le matériau
pour que je pense que c'est la première porte verrouillée. Ouaip, c'est ici. La
première porte est verrouillée, elle est donc rouge. Et quand on le déverrouille,
il devrait changer de couleur. Je vais aller voir le graphique ici quand nous l'avons réglé pour qu'il se ferme, que nous émettons le son déverrouillé et que
nous allons ouvrir notre porte Nous allons installer le matériel. Ensuite, nous allons
sélectionner la première porte. Et comme vous pouvez le constater, il
existe un index des éléments. Si DR avait plus de matériel, je pourrais sélectionner l'indice
approprié à modifier. Mais comme nous n'avons qu'un seul matériau, nous changeons simplement
l'indice zéro de l'élément. La prochaine chose à faire est de mettre à jour le widget,
car il
passera de
verrouillé à ouvert. Et nous devons également indiquer ici
qu'il est écrit « verrouillé ». Lorsque la porte est verrouillée,
le widget indique qu'elle est verrouillée. Mais que se passe-t-il si je suis sur
un site que je peux déverrouiller ? Ça devrait dire « déverrouiller ». Pour ce faire,
nous allons donc faire une sélection. Je vais créer un texte sélectionné. Comme vous pouvez le voir, nous avions
déjà cette option, celle avec un
Bleian si B, choisissez A, si A est vrai, et
celle qui est select, qui a le nœud sauvage Assurez-vous d'utiliser celui avec
un booléen. Je vais à nouveau apporter
la façade est. Je vais le connecter ici. Et si c'est la
face avant, disons, semble verrouillée de
l'autre côté. Et si nous sommes de l'autre côté, cela devrait indiquer « déverrouillé Maintenant, compilons et sauvegardons. Donc, que nous mettons à jour correctement. Il ne reste plus qu'à faire quelque chose lorsque le
joueur essaie de l'ouvrir, appuie sur E, la porte est verrouillée et elle se trouve
du mauvais côté. Nous allons donc créer
une animation de cliquetis de porte. Mais c'est
ce que nous allons faire dans le prochain. Je pense que c'est
suffisant pour celui-ci. Je te verrai alors. Au revoir
18. Ajouter des effets visuels à une porte raccourcie: Bonjour et bienvenue
sur Unreal Engine, cinq systèmes de portes
Blueprint Mastery
et portails interactifs Auparavant, nous avons commencé
par notre porte de raccourci. Nous avons ajouté un énumérateur, un nouvel énumérateur à notre état de porte,
l'état verrouillé Nous avons constaté que cela ne changeait rien à notre
code car il n'est pas recommandé d'ajouter de
nouveaux énumérateurs après l'avoir déjà utilisé
à plusieurs endroits,
mais cela n'avait pas d' importance pour nous car nous avons
un très petit code, et nous avons mis à jour le
widget pour indiquer, pas dans la double porte de
la nouvelle porte de raccourci Nous avons mis à jour pour indiquer que s' il se trouve à l'avant
du joueur, il
semble verrouillé, s'il se trouve à
l'arrière, il est déverrouillé Et nous avons créé cette fonction es
front side pure avec le code que nous avons utilisé
dans le sens du calcul. Nous avons également séparé l'animation de la porte de l'appui sur E, ce qui permet de vérifier
si la porte est verrouillée. S'il est verrouillé, il joue avec
notre mécanisme Tracetlock. Si ce n'est pas le cas, il
joue l'animation. Lorsque nous sommes à l'
arrière de la porte, nous déverrouillons la
porte et nous changeons le matériau parce que nous avons réglé
le matériau de manière à ce qu'il
ait une lueur rouge, mais maintenant, lorsque nous la déverrouillons, ce sera le matériau normal Mais nous l'avons laissé de côté sans
créer de hochet. Créons donc le hochet. Créons un nouvel événement personnalisé. Appelons ce hochet de porte personnalisé pour un
événement. Et ici, nous aurons à nouveau besoin
d'un calendrier. Je vais juste copier
cette chronologie ici, et je vais appuyer sur
Play depuis le début. Mais je pense que nous avons
un son pour un hochet, donc je vais d'abord
jouer du son avec di, puis jouer
du début à la chronologie Et je pense que le son s'
appelle un hochet. Oui, un cliquetis de porte. Nous y voilà. Maintenant, trouvons
une solution. Combien de temps la
porte doit-elle claquer ? Je pense que 0,5 c'est bien. Allons-y un
peu plus. Disons 55. Pas 0,55, pas seulement 55. Je cliquetais pendant 55 secondes. Eh bien, cela dépend de la personne
qui essaie de l'ouvrir. Disons 0,55, et
mettons la valeur à zéro car au
début et à la fin, elle doit être sur
la même position Comme si le joueur essayait de l'
ouvrir, mais n'y arrivait vraiment pas. Maintenant, comment allons-nous
créer le tirage au sort ? Eh bien, pour moi, la solution
actuelle est assez simple, mais le hochet
ne sera pas vraiment parfait, mais ce sera un hochet Je vais juste
persister et cliquer sur points
aléatoires en dessous de un et au-dessus moins un et peut-être les rapprocher
un peu plus Disons qu'il pousse. Et voyons voir, il
tire ici, puis il fait un gros effort. Et il continue à pousser cette direction, puis il relâche,
puis il fait glisser à nouveau, puis il pousse
à nouveau, une dernière Je ne sais pas,
quelque chose comme ça. Tu peux beaucoup jouer avec. Ce que nous pouvons faire pour le
rendre un peu plus fluide pourrait être
la fonction automatique, qui, comme vous pouvez le voir, le
rend plus fluide. Mais à mon avis, avoir des allers-retours
sévères pourrait être préférable pour quelqu'un qui
essaie d'ouvrir une porte. Je vais laisser les choses
comme ça. Si vous le souhaitez, vous pouvez tous les sélectionner
et procéder automatiquement, en les
sélectionnant et en effectuant interpolation
automatique
entre les points Maintenant, que faisons-nous lors de la
mise à jour avec cette version alpha ? Bien sûr,
nous allons faire du larp. Je vais faire du larp. Ce
sera Alpha 0-1 0,5 C'est une virgule 1.5. Y zéro à 1,5. Ce sont donc les degrés
de rotation. Je vais juste copier
également
le nœud de rotation et celui-ci, le treillis de porte, également,
la référence de la porte. Maintenant, je vais le
connecter ici. Maintenant, comme j'ai utilisé valeurs
négatives
ici, moins par rapport à zéro, ce 1,5
sera également compté comme un point négatif, comme
un point de consigne imaginaire
sur la valeur négative. Cela va donc aller
et venir à partir de cela. Et s'il y avait plus de degrés, je pense que ça n'aurait pas l'
air très beau,
pas que ça va être
très beau en ce moment, mais c'est plus normal d'avoir de
petits diplômes ici. Maintenant, une dernière chose
avant de faire le test, connectons le
hochet de porte ici Appelons ça du hochet compilons
et
sauvegardons, et allons-y jouer Je n'ai pas ajouté la
porte sur la carte. Il devrait y avoir
quelque chose qui manque. Ajoutons-le sur la carte. Maintenant,
c'est la double porte. C'est la porte de raccourci. Où est la
flèche avant ici ? Nous pourrions changer la couleur de la flèche pour qu'elle ne corresponde pas au gadget, celui ici ou la
rendre un peu plus grande
et plus épaisse, mais c'est et plus épaisse, mais Pour ce faire, il vous suffit d'accéder
aux composants du plan, sélectionner la flèche, d'
accéder à ses détails Maintenant, pour moi, cette configuration a été créée
pour quelque chose de différent. Je vais juste le
modifier pour améliorer le gameplay. Une porte de raccourci
est plus logique. Je vais sélectionner tout ça. Je vais les pousser ici. Cela va
les rendre un peu plus grands et les pousser vers le haut. Je vais le supprimer
. Je vais apporter ça ici. Peut-être par ici. Dans ce cas,
tu n'as pas à le faire. C'est juste pour moi, il est plus logique d'utiliser un raccourci pour embêter le joueur
qui contourne les choses Il est donc plus important de devoir parcourir cette
distance par rapport à cette distance. Alors le joueur pense : OK, peut-être que je devrais verrouiller
la porte comme si cela valait
vraiment la peine de la
déverrouiller, d'aller d'ici à ici, instantanément puis de faire
le tour complet Quoi qu'il en soit, des problèmes de développement. Progressons.
Amenons le joueur ici. Testons la porte.
OK, ça fait du bruit. On dirait qu'il est bloqué de
l'autre côté. Oui, je vais par ici. Si on fait tout ce chemin,
puis-je sauter d'ici ? Non OK, je le déverrouille. Je ne recommencerai plus jamais comme ça. Je vais juste aller directement dans la pièce
d'à côté. En fait, tout
est débloqué en ce moment, donc je ne peux pas gagner la partie Quoi qu'il en soit, je pense que c'
est tout pour celui-ci. Nous allons passer à
la suivante en créant un interrupteur et une porte qui
s'ouvre avec cet interrupteur. Au revoir pour le moment. À bientôt.
19. Créer un plan de levier pour débloquer des portes: Bienvenue sur
Unreal Engine Five, Blueprint Mastery, Door Systems
et portails interactifs Auparavant, nous en avions fini
avec notre porte de raccourci. Nous avons créé un événement personnalisé,
puis nous avons émis un son, puis nous avons créé une nouvelle chronologie, et sur la base de cette chronologie, nous avons redéfini la
rotation relative. Et nous appelons cet
événement ici. Il est maintenant temps d'
approfondir un peu ce projet. Nous allons ouvrir le niveau 6, et c'est l'heure de notre porte qui communique
avec un interrupteur, juste quelques informations supplémentaires
avant de continuer. Tout ce que nous avons
créé est un objet. Et lorsque nous avons créé
un nouveau plan, nous avons sélectionné une classe Il s'agit d'une porte de classe BPW. Il s'agit de la porte à sens unique de classe
BP , etc. Il en va de même pour cela, pas pour l'énumération L'énumération
n'est qu'une variable. C'est une énumération. Alors pourquoi est-ce que je
parle de cours ? Une définition intelligente serait
qu'il s'agit d'objets dotés propriétés
et de comportements
spécifiques qui permettent aux développeurs de
créer plusieurs instances. Cela signifierait que nous
pouvons avoir deux portes de cette porte. Ils ont le même comportement, les mêmes propriétés et ce sont des
instances complètement différentes de cette classe. disant tout cela, ce que
nous avons fait jusqu'à présent, par
exemple, au
début ici, nous avons utilisé les références de classe pour faire quelque chose dans
le plan de niveau Nous avons utilisé la classe Door
ici pour faire alterner cet acteur. Dans d'autres exemples, nous n'avons pas vraiment appelé d'autre acteur. Mais encore une fois, un exemple serait le casting que nous faisons pour
le joueur impliqué dans les collisions. En fait, nous ne faisons pas de casting. Nous avons fait du casting
au début ici. Encore une fois, cela nécessite le cours. Il demande le cours. Êtes-vous la classe de personnages à la troisième
personne de BP ? Si vous êtes de cette classe, je vais obtenir des
informations de votre part. Ce dont l'étape suivante a besoin, c'est de
cette porte que nous
appelons une interface de plan Je vais arriver,
cliquer et aller Blueprint et accéder à
Blueprint Interface Je vais appeler ça BI Ds. Maintenant, qu'est-ce qu'une interface de
plan ? Il s'agit essentiellement d'un moyen d'exécuter des fonctions sur différentes classes qui peuvent implémenter
leur propre code. Pas vraiment courant, mais je
peux les appeler à n'importe quelle classe qui implémente, je
pense qu'il serait préférable de le montrer à titre d'exemple. Encore une chose, c'est l'un des moyens
les plus optimaux de communiquer sur un
plan directeur Par exemple, un plan doit
communiquer avec
un autre plan et ils ne se
connaissent pas Ils ne savent pas de quelle
classe il s'agit l'un de l'autre. Dupliquons notre
porte verrouillée, notre porte de raccourci. Je vais le dupliquer, et je vais appeler
cette porte de commutation. Alors maintenant, retournons à
nos portes VI et ouvrons-les. Et quand je l'ouvre, vous pouvez voir qu'il
ressemble à un plan, mais il y a de l'autre côté
l' onglet M Blueprint et C'est parce que nous ne pouvons
voir qu'une seule fonction ici, celle qu'elle nous a créée. Si j'ajoute d'autres fonctions, nous pouvons voir une autre fonction. Et le seul graphique
qui existe ici concerne essentiellement ces
fonctions. Comme vous pouvez le voir, ils
n'ont pas été exécutés. L'exécution sera créée dans le plan qui les
hébergera Je vais donc supprimer celui-ci. Je vais appeler cette porte déverrouillée. Maintenant, ce que nous pouvons faire ici, en
plus de nommer une fonction, nous pourrions mettre des entrées
et des sorties et dire que cette fonction
fonctionne toujours comme ça. Il a toujours ces
entrées et ces sorties. Sauvegardons, compilons, et
passons à notre switch,
switch, celui-ci. Alors, comment implémenter l'
interface ici ? Nous allons accéder aux paramètres de
notre classe. Nous allons passer aux interfaces. Nous allons appuyer sur
AD et
rechercher des points BI. Je vais maintenant compiler,
et comme vous pouvez le voir, une nouvelle catégorie est apparue dans les
principales interfaces de mon Blueprint Et si je l'ouvre, nous
trouverons la porte verrouillée. Et si je double-clique dessus, nous créons un événement pour cela. Maintenant, si cela avait une sortie, cela en ferait une fonction et j'
entrerais dans la fonction. Maintenant, que se passe-t-il lorsque
nous déverrouillons la porte ? Eh bien, lorsque vous déverrouillez la porte, nous avons ce code
quelque part ici. Ouais. Nous n'aurons pas besoin de
tous ces mécanismes, je vais
donc simplement supprimer
cette partie, le verrouillage du raccourci. Nous avons besoin du hochet de porte pour prendre la position du mécanicien de la serrure
raccourcie, qui n'existe plus. Et nous avons besoin de ce code. Coupons-le et
collons-le ici. Et le matériau
est le bon. Donc, du point de vue du codage, cette porte est prête
car lorsque nous appuyons sur E, deux choses se
produiront : la porte sera déverrouillée et elle s'
ouvrira ou se fermera, ou la porte sera verrouillée et elle cliquetera Comme vous pouvez le constater,
nous appelons de
nulle part cet événement à porte
déverrouillée En effet, nous l'
appellerons via l'autre plan via le commutateur
en utilisant l'appel d'interface Nous allons maintenant créer
ce commutateur Blueprint. Nous allons passer
au navigateur de contenu. Nous allons accéder à
notre dossier Blueprint. Nous allons cliquer avec le bouton droit de
la souris et créer un nouvel acteur. Je vais l'appeler BP
Switch. Et ouvrons-le. Commençons par les composants. Ajoutons, bien sûr, une boîte ou une lésion. Ajoutons un texte. Rendu en fait, non. Nous n'avons pas besoin d'appel d'offres. Nous avons besoin de deux maillages statiques. Je vais donc
sélectionner un maillage statique et je vais le dupliquer. Maintenant, pour le premier maillage statique, compilons, enregistrons,
revenons à notre carte. Passons à nos accessoires, et sélectionnons
celui-ci ici,
qui est celui du levier du pot à accessoires Lions-le. Bien, revenons à l'
interrupteur et appliquons-le. Maintenant, pour le deuxième maillage statique, nous allons faire de
même, les
enregistrer, sélectionner le second, le lier, revenir au commutateur
et l'ajouter ici. En fait, ajoutons une flèche
parce que oui, c'est ce que je pensais. Ils sont en quelque sorte mal pivotés. Je vais donc les faire pivoter de
90 degrés et leur faire comprendre qu'il s'
agit d'un levier, pas d'un interrupteur. Quoi qu'il en soit Et aussi, je vais le faire pivoter de 90 degrés de cette façon. Il regarde donc vers le haut
parce que nous allons l'animer pour qu'il descende Comparons et économisons. Et maintenant, nous avons besoin de certaines
fonctionnalités depuis les portes. Donc je vais aller à n'importe quelle
porte, peu importe. Je vais aller chez
Double Door tout de suite. Je vais trouver Begin Play, et je vais copier ce mode de jeu de casquette pour
en faire une variable. Et je vais aller dans la
boîte de dialogue et le coller ici. Et comme vous
pouvez le constater, cette variable n'existe pas. Lorsqu'une variable n'
existe pas, elle est grise. Pour qu'elle existe, nous pouvons simplement créer une variable
ici et la nommer ou nous pouvons
simplement cliquer dessus avec le bouton droit de la souris
et créer variablu mode de jeu à la troisième personne et c'est fait La prochaine chose que je
vais faire est dissocier cette flèche
du maillage statique Mais ce n'est pas ce que
je voulais dire. Ce que je voulais dire,
c'est que je vais
sélectionner celui-ci, le maillage statique, qui est le levier que
nous allons actionner. Et au début de la
partie, je vais
l'apporter ici et je vais obtenir une rotation
relative. Je n'aurai donc rien à
calculer. Je vais juste stocker
cette variable depuis movaiable et la connecter
ici Nous allons donc utiliser
cette variable maintenant pour faire pivoter l'interrupteur, le foie. Mais avant de commencer à animer, finissons par copier
le comportement souhaité Nous voulons également connaître le comportement des
collisions. Donc je vais mettre
tout ça ici, je vais contrôler, et je vais
les coller ici. Voir, mettre à jour le texte du widget.
Nous avons besoin de ces deux-là. Je vais donc simplement créer une fonction
correspondante, confirmer. Mais cette fonction
est un peu vide. Mais peu importe, car nous avons besoin de quelqu'un de différent pour faire
des choses différentes cette fois-ci. Ce n'est pas une porte. Donc, nous allons essentiellement
créer une variable, l'
appeler sold et apporter
une branche ici. Si nous sommes résolus,
nous passerons à notre mode de jeu à la troisième
personne et procéderons à suppression du widget Door Widget Widget. Eh bien, c'est un
widget hépatique pour le moment, mais nous l'avons appelé widget de porte. Peu importe. Et si ce n'est pas résolu, nous allons mettre à jour le texte. Et utilisez le type. Le joueur sait donc
qu'il peut utiliser le déclencheur. Et cette fonctionnalité est
maintenant copiée, et nous avons également copié
le texte du widget de mise
à jour en même temps. Petit rappel. fait que lorsque nous
chevauchons le joueur, nous autorisons la saisie
dans ce plan Nous mettons à jour le widget et
nous l'ajoutons à la fenêtre d'affichage, ou nous le supprimons et désactivons la
saisie lorsque le chevauchement est terminé Je pense que c'est
suffisant pour celui-ci. Je
te verrai bientôt. Au revoir.
20. Mettre en œuvre le déverrouillage de porte à distance avec la communication Blueprint: Bienvenue sur
Unreal Engine Five, Blueprint Mastery, Door systems
et portails interactifs Auparavant, nous en avions fini
avec notre interrupteur Door. Nous avons créé une interface de plan dont nous avons expliqué
qu'elle permet aux
plans de communiquer
lorsqu'ils ne
savent pas qui est aux
plans de communiquer
lorsqu'ils ne
savent pas l'autre plan,
quel est le type d'avantage, et nous l' avons implémentée dans
notre porte de commutation BP en accédant
aux paramètres de classe
et en l'implémentant dans les interfaces
implémentées dont nous avons expliqué
qu'elle permet aux
plans de communiquer
lorsqu'ils ne
savent pas qui est l'autre plan,
quel est le type d'avantage,
et nous l'
avons implémentée dans
notre porte de commutation BP en accédant
aux paramètres de classe
et en l'implémentant dans les interfaces
implémentées. Nous avons appuyé sur la publicité et
nous l'avons mise en œuvre. Ensuite, nous avons obtenu l'événement
Unlock Door que nous avons créé dans l'interface
Blueprint, et nous avons connecté la chaîne d' événements que nous voulons voir se produire
lorsque la porte est déverrouillée Eh bien, maintenant ce n'est plus une porte. Eh bien, c'est une porte, en fait. Ensuite, nous avons
continué à modifier l'événement pressant pour qu'il
sonne toujours s'il est verrouillé,
et s'il n'est pas verrouillé, et s'il n'est pas verrouillé, nous débloquerons et jouerons
l'animation de déverrouillage L'animation ouverte. Ensuite, nous avons créé
le commutateur BB dont nous avons copié la fonctionnalité de chevauchement
de la collision entre boîtes. Nous avons ajouté la collision entre boîtes. Nous avons également ajouté deux
mesures statiques et une flèche. Et d'après ce que je peux voir, la flèche est mal tournée Je vais le réinitialiser
par défaut. Maintenant c'est correct. Continuons avec l'
animation de l'interrupteur. Nous allons donc utiliser
le E du clavier. Et la première chose que
nous allons demander est s'il y a un changement de
cap. Est-ce que c'est l'interrupteur ? L'interrupteur a-t-il réellement tourné ? Si ce n'est pas le cas, nous
allons dire que c'
est le cas, car cela ne
passera qu'une seule fois et l'animation
sera jouée. Maintenant, ici, nous
allons mettre à jour le widget. Il arrête donc de montrer
l'utilisation du texte, et nous allons émettre du son. Que nous allons encore
une fois gâcher le terrain. Nous allons effectuer un chargement
aléatoire à portée. Et nous allons
passer de 0,8 à un. Et le son serait,
je crois, qu'il y a un interrupteur. Non, ça s'appelle lever
ever Q. Nous y voilà. Maintenant, nous avons besoin d'un calendrier. Donc, une chronologie. Nous allons entrer dans
cette chronologie. Nous allons créer
un nouveau flow truck. Asseyons-nous, cliquons et
créons deux points. Le premier sera multiplié par 0,15, et ce sera un, et l'autre
sera égal à zéro, zéro Maintenant, je vais appuyer sur ces deux boutons pour l'
ajuster horizontalement, verticalement, et je vais
appuyer sur une image clé. De plus, cette fois, je
vais sélectionner les deux, et je vais
utiliser la courbe automatique. Le mouvement est donc un
peu plus fluide. Maintenant, lorsque la chronologie se joue, nous avons tout d'
abord besoin
d'un peu de place. Il va falloir changer
la rotation du levier. Nous allons donc en acheter
un à maillage statique. Nous allons définir la rotation
relative. Je vais le connecter
ici, je vais émettre alerte et je vais utiliser la rotation
relative que nous avons. Je vais connecter
l'Alpha ici. Et pour le B, ce que
je vais faire, c'est fabriquer le rotateur Je vais passer à -90, et je vais
casser le rotateur Pas d'axe, désolé. Et je vais procéder au lancer
et au lancer de base pour rester les mêmes, parce que nous l'avons fait pivoter
pour regarder vers la flèche Donc, pour le moment, il conservera la
même rotation que nous avions, et cela fera passer le Z à -90 Je vais également sélectionner
l' endroit trié pour qu'il
fasse un petit mouvement. La prochaine chose que nous allons
faire , c'est récupérer le maillage statique et fixer le matériau. Ainsi, lorsque nous avons terminé et
que l'animation est terminée, accessoires sont semés sur le matériau, qui passe du
jaune au vert Maintenant, ce qui est intéressant, comment envoyer le
message à la porte ? Eh bien, comme nous l'avons dit, nous avons cette
interface de plan qui peut envoyer un message à n'importe quel
acteur qui la possède Il peut envoyer un message à
n'importe quel acteur, en gros. Mais si l'acteur possède l'interface du
plan, il en fera quelque chose Si ce n'est pas le cas, cela ne
servira à rien. Je vais donc créer une
nouvelle variable ici, et je vais l'
avoir du type actor. Cela signifie donc que cela
peut être n'importe quel acteur. Tout acteur que je peux
sélectionner et renseigner cette variable peut devenir l'objet auquel j'
envoie le message Je vais appeler
ce portier acteur. Et n'oubliez pas que l'
instance est modifiable. Je vais cliquer dessus et
exposer sur spawn, bien sûr, je vais compiler
et dire, maintenant, que je vais mettre l'interrupteur
et la porte dans le niveau Apportons l'interrupteur ici et apportons également la porte. Ce n'était pas le meilleur endroit. Mettons-le ici. Je trouve que c'est une belle
hauteur, un bel endroit. Tu peux le placer
comme tu veux. Maintenant, je vais sélectionner la collision entre boîtes et je vais l'avancer
un peu. Faites-le un peu plus grand. Ainsi, lorsque le joueur
est à l'intérieur,
il peut interagir
avec le commutateur. Maintenant, comment obtenir
cette référence ? Ici, nous n'en
trouverons pas ici. Désolé, j'ai
sélectionné le plan. J'avais sélectionné la boîte. Revenons donc au plan. Ici, pour les détails, nous pouvons trouver cet acteur de porte. Je peux utiliser ce pick
actor de SN. Et je peux sélectionner
n'importe quel acteur. Comme pour le moment, j'ai
sélectionné le mur. Je peux sélectionner cette histoire, mais elle ne servira à rien. Nous vous enverrons ce code
que nous mettrons en œuvre. En gros, c'est le code qui le fait. Vous allez juste appeler
l'acteur et dire « Déverrouillez la porte ». Et comme vous pouvez le voir, il y a cette petite
enveloppe ici. Cela signifie qu'il envoie
ce message. Maintenant, je pourrais demander si cet acteur
implémente l'interface. Je pourrais sélectionner l'
interface que je voulais,
Vidor, et si ce n'était pas le cas, je
pouvais mettre une branche ici, et si elle n'avait pas
d'interface, elle n'enverrait pas
le message en gros Je pourrais également demander s'il s'agit d'un acteur
valide au cas où j'oublierais , par
exemple, de sélectionner un acteur et que cette
variable serait vide. Je pourrais avoir une chaîne
d'impression ici, chaîne
d'impression, Switch
n'a pas d'acteur. Ce n'est pas un interrupteur. C'est un foie. Je devrais peut-être renommer
ce blubrid. Allons-y Je vais donc appeler
cela une porte du foie. Je vais aller ici et
nommer ces deux foies. D'accord. Cela permettrait donc de s'
assurer que nous avons un acteur et que nous avons également l'interface
implémentée pour cet acteur. Nous pouvons avoir un autre message
d'erreur indiquant
que l'acteur
n'a pas d'interface. N'implémente pas l'interface. Et maintenant, nous pouvons avoir
deux codes d'erreur. Je vais compiler et enregistrer.
Je vais aller ici. Je vais faire pivoter cette porte en fonction de la rotation de la collection et la
placer , d'accord ? Peut-être un peu plus haut,
et c'est bon. Maintenant, apportons également le texte
décrivant les portes. Nous n'en avons pas mis un ici non plus. Alors faisons-le. Apportons un nouveau texte bas. Définissons le message,
suivons cette voie et prenons une
flèche, une flèche de demande. Et faisons pivoter le texte. Oups, ce n'est pas un plan,
le texte lui-même. Et apportez-le ici. Je vais le réduire un
peu. Et apportez également de la lumière. D'accord, et maintenant la collision Appuyons sur Play. C'est bon, ça marche. C'est par là que je vais. Je ferme la porte en
venant par ici. Et l'interrupteur va au
mauvais endroit, nous allons le réparer, et la porte ne s'ouvre pas
parce que tout d'abord, je n'ai pas sélectionné la porte
sur l'interrupteur. Je vais donc sélectionner
cette porte cette fois, et passer au levier, pas à la changer. Ce n'est donc pas Ya que nous voulons, et ce doit être du pitch. Je vais donc connecter
ceci ici et le s -90 ici. Apportons-le également ici. Donc, encore une fois, dans le mauvais sens. Ce n'est pas la bonne méthode.
Ce n'est donc pas 90. C'est 180, et c'est plus 180. La troisième fois, c'est le charme. Youpi. Connectez l'animation. Maintenant, la porte est déverrouillée,
et nous pouvons avancer. Apportons donc le
texte ici maintenant qu' il fonctionne, apportons-en un nouveau. Je vais apporter un texte flottant. Et je vais envoyer un texto. Utilisez le levier pour ouvrir
la porte. C'est bon. Et dans le shift, entrez
pour passer une ligne en dessous. Je vais sélectionner le texte.
Je vais le déplacer ici. Maintenant, cette fois,
je vais mettre la lumière au-dessus du foie. Donc, cet endroit s'illumine. Le joueur voit
où il doit aller. Un peu de game design, même si ce n'est pas nécessaire.
C'est toujours bon de l'avoir. Et je vais
augmenter ce chiffre ici. Je vais l'apporter ici.
Oui, ici c'est bon. Cette chambre est prête. Maintenant, nous allons passer à
la suivante en utilisant deux leviers pour ouvrir une
porte, mais d'une manière différente heure actuelle, le levier envoie un message à la porte
indiquant « déverrouillez ». La prochaine
sera l'inverse. La porte demandera aux
deux leviers : Êtes-vous résolu ? J'irai te voir
alors. Au revoir pour le moment.
21. Créer des mécanismes de puzzle à plusieurs boutons pour les systèmes de portes: Bonjour et bienvenue sur Unreal Engine Five
Blueprint Mastery, Door Systems et portails
interactifs Auparavant, nous en avions fini avec
notre Liver Door, en gros. Je pense que nous l'avons finalement appelé levier.
Oui, Liver Door. Il n'a pas été mis à jour ici car
il ne date pas automatiquement les noms. Nous pouvons donc le mettre à jour. De plus, une chose
que j'ai remarquée, c'est que dans le texte du widget de mise à jour, il ne devrait pas être indiqué qu'il semble déverrouillé Je vais le supprimer
, je vais juste
dire verrouillé. Et
c'est peut-être ça. Nous en avons donc fini
avec la porte du foie. Nous avons également
ajouté quelques textes, et nous avons terminé avec la partie
animation du foie. Et nous avons
également ajouté des messages d'erreur au cas où l'acteur de la
porte ne serait pas défini. Passons maintenant
à la partie suivante. Faisons en sorte que notre niveau
six, sept, notre niveau sept soient visibles, et c'est le
tournant suivant, notre niveau sept soient visibles,
et c'est le
tournant suivant,
nous allons descendre. Commençons par mettre à jour notre
interface de plan pour chiens Nous allons ajouter une nouvelle
fonction appelée SOD. Cette fonction, nous
allons utiliser une sortie, et nous allons l'appeler SOD Nous l'utiliserons pour notre foie. Nous allons donc
aller dans notre foie, accéder aux paramètres des
cours et ajouter une
interface composée de points BI. Nous allons maintenant
passer aux interfaces. Nous allons compiler le plan de collision du nom de la
première interface cause du booléen Disons que ce booléen est vendu. Oui, vous ne pouvez pas avoir deux fois la
même variable de nom, et si elle appartient
à l'interface, elle appartient également au plan ce qui crée un problème Je dois d'abord le compiler, et maintenant celui-ci, et c'est euh, double-cliquons sur Résolu et
amenons le J'ai résolu
et connecté ici. Alors maintenant, chaque fois que resolved est froid, nous allons renvoyer
notre variable I solved. Comment appelle-t-on cela « J'ai résolu » ? Allons à notre nouvelle porte. Nous allons donc
dupliquer la porte du foie. Je vais appeler cette porte
multi-puzzles, et nous allons l'ouvrir. Peu de choses
vont changer ici. La seule chose que nous
allons
changer est de créer une nouvelle fonction. Appelons cela vérifier les réponses aux
énigmes. Et il aura également une
sortie booléenne ou des énigmes résolues. OK. Nous allons construire ensuite. Maintenant, nous allons
utiliser cet événement pour déverrouiller Door,
qui, parce que nous l'avons copié, est devenu un événement normal. Passons à l'interface. Appelons l'interface 1. Cela s'est produit parce que nous avons
dupliqué le plan. Nous allons donc nous rendre à
notre événement, débloquer Door, et nous allons apporter
les réponses au casse-tête. Et si cela se vérifie, nous déverrouillerons la porte. Si ce n'est pas le cas, nous allons tellement
nous amuser ici. Et au lieu de l'appeler
depuis les interrupteurs, nous l'appellerons lorsque nous
appuierons sur E et que la porte sera verrouillée. Donc, une fois terminé, on a appelé We Will Event
Unlock Door Event. Maintenant, quand je l'appelle
dans le plan, Cedar n'a pas
cette enveloppe ici, mais la cible
est d'une couleur différente Cela se produit lorsque vous appelez un plan
en interne. Une fonction d'interface Blueprint. Maintenant, pour continuer avec notre fonction de vérification
des réponses aux énigmes,
nous devons tout d'abord créer une
référence aux énigmes, comme
nous l' avons fait pour le changement ici, nous devons le faire pour la
porte et les énigmes. Alors, comment s'y prendre ? Nous allons créer
une nouvelle variable de type actor object reference, et nous allons la
nommer puzzles. Maintenant, pourquoi des puzzles ? Jusqu'à présent, nous avons
utilisé des variables uniques, ce qui signifie qu'elles ont un
seul type de conteneur. Et pourquoi prononcer ce mot conteneur ? Parce que nous avons trois autres types de conteneurs
différents. Si nous sélectionnons les
puzzles variables et que nous passons ici, nous pouvons voir créer cette matrice de conteneurs
variables, ensemble ou cette carte, qui sont les trois autres
types de conteneurs différents. Un conteneur
est donc un seul. Le second est un tableau, le
troisième est défini et cartographié avec des règles spécifiques pour chacun d'entre eux. Mais les fonctionnalités de base
restent les mêmes, savoir conserver une liste d'éléments, une liste de variables, en gros. Nous allons utiliser un tableau, qui contient un
type de variable. carte peut contenir deux
types de variables, et l'ensemble est que
chaque variable de la liste
doit être unique. Nous allons maintenant sélectionner le premier
type de liste, le tableau,
et une autre chose importante à
propos de ces listes est penser que chaque variable qu'elles contiennent dans la liste a
un ordre spécifique. Par exemple, si je le compile,
nous pouvons voir des puzzles
et des éléments de tableau. Et si je clique sur un élément du
tableau, j'ai un élément du tableau ici. Le deuxième, le troisième, et ceux-ci sont
dans un ordre précis. C'est zéro, c'
est un, c'est deux. Il en va de même pour le reste de la liste
: ils conservent une commande spécifique et
conservent toujours cette commande à
moins que nous ne la modifiions. Maintenant, quand je dis que les acteurs du plateau doivent
avoir un élément unique, cela signifie que le premier élément ne doit pas être le même
que le second. Par exemple, s'il s'
agissait d'entiers, cela aurait été un, deux, trois, cela ne pouvait pas
être un, un, un Démontrons
cela pendant une seconde. Nous allons changer le
type de variable en entier. Et compilons, voyons
si les éléments sont réinitialisés. J'ai donc ajouté zéro. Si
j'essaie d'ajouter à nouveau, je ne peux pas car
zéro existe déjà. Si je le transforme en
un, je peux en ajouter. Si j'essaie de passer de zéro à
un, ça ne me le permettra pas. Si j'essaie de passer de un à
zéro, ça ne me le permettra pas. Je dois donc passer ce chiffre à deux, par
exemple, puis
il a de nouveau ajouté zéro. Ainsi, lorsque cela continue, il est très contre-productif de
remplir les ensembles manuellement Quoi qu'il en soit,
revenons à notre tableau, qui peut contenir
plusieurs fois, il faut, par
exemple,
compiler pour cela. Plusieurs fois
zéro, par exemple, et il doit être de type
acteur sans type. OK, donc une panoplie d'acteurs. Nous avons donc cette jolie
petite liste d'acteurs, qui n'est pas remplie Nous allons le rendre
modifiable avec de l'encens et nous l'
exposerons également lors de l'apparition Nous devons le compiler
puis l'afficher sur notre carte, et faire venir nos nouveaux Apportons deux foies, un ici et
un ici Et apportons la nouvelle porte,
également une porte multi-puzzles. Je
les remplacerai mieux plus tard. Je vais remplir le puzzle. Je vais donc appuyer sur ce
bouton ici, encore une fois, et je vais sélectionner
le premier comme celui-ci et le second
comme celui-ci. Maintenant, si l'ordre
était important, la
façon dont nous les sélectionnons aurait de l'importance Mais dans notre cas, nous allons simplement vérifier si
les deux sont résolus. Maintenant, nous n'avions pas besoin
de créer les acteurs pour le moment, car le code serait « allons-y,
créons le code », en fait. Allons voir le puzzle Acers et maintenant nous allons vous
présenter notre nouvelle gamme de puzzles Nous allons maintenant
découvrir un nouveau nœud, qui serait le nœud
de chaque boucle. Maintenant, outre les quatre boucles de chaque boucle, il y a aussi une boucle à quatre et une boucle à quatre avec pause et une boucle à
quatre avec pause. Et bien sûr, il y a
un revers pour chaque opération. Maintenant, qu'est-ce qu'une boucle ? Parce que le mot le plus courant, comme on peut le voir ici, est une boucle. Une boucle vous permet de répéter des actions plusieurs fois aussi
vite que possible. Comme nous pouvons le voir, il
a une exécution dans une boucle corporelle et un
nœud terminé comme nœuds d'exécution. Et tous ici sont pareils
à l'exception de la pause. La pause, c'est que nous pouvons appeler d'une manière ou d'une autre pour arrêter
tout ce que cela fait. Par exemple, lorsque nous
cherchons quelque chose
et que nous le trouvons, nous pouvons nous arrêter lorsque nous l'
avons trouvé et terminer la boucle. Et l'autre différence est que ces deux éléments, et
pour chaque boucle avec pause, nous avons une entrée matricielle, alors que
nous les configurons manuellement pour faire quelque chose un
certain nombre de fois. Par exemple, si nous
voulions que cela se produise deux fois, cela pourrait être une boucle 0-1
car les boucles et
les tableaux sont également
importants et les autres conteneurs
commencent par zéro comme premier index, le premier nombre
d'éléments Nous aurons l'élément zéro, puis nous aurons l'
élément un et l'élément deux. C'est donc également important. Supprimons maintenant ceci et
faisons fonctionner notre boucle for. Donc, ce que nous allons faire,
c'est que le
message est résolu. Nous allons demander si c'est résolu. Non, nous avons dit que c'était résolu. Oui, message résolu. Maintenant, cela nous permet de savoir si
c'est résolu ou non, le casse-tête que nous nous posons. Et aussi, juste pour rappeler pourquoi nous avons utilisé un appel d'interface car
celui-ci est de type acteur. Cela signifie donc que cela peut
redevenir tout. Il peut devenir un interrupteur,
un levier et un interrupteur. Il peut devenir un bouton
et un interrupteur peut devenir une porte et
un interrupteur ou quoi que ce soit d'autre.
Cela peut devenir n'importe quoi. Alors que si nous avions
le type de classe au lieu de l'acteur ici, nous aurions un levier P, un levier P. Si nous avions celui-ci, nous ne
pourrions que cet ensemble
ne contiendrait que des
portes hépatiques et nous
serions en mesure d'obtenir des informations
directement les concernant. Mais cela lui permet d'
obtenir n'importe quel acteur qui implémente ce type
d'interface de plan Maintenant, complétons
la logique à ce sujet. Nous allons mettre une branche ici parce que si nous nous connectons simplement, au nœud de retour ici, nous reviendrons constamment pour chaque corps, que le problème
soit résolu ou non. Mais cette fonction est sur le point de vérifier tous les puzzles, pas un seul. Le nœud de retour devrait donc
se produire à la fin. Maintenant, nous allons faire en sorte que la première fois que nous trouverons une
énigme qui n'est pas résolue, nous allons promouvoir
cette variable, mais une variable locale cette fois. Il n'existe donc que
dans cette fonction, et nous allons le
déconnecter en fait. Si l'une d'elles est fausse, nous allons rompre
les quatre boucles. Oui, utilisez
chaque boucle pour une boucle avec rupture ou avec rupture. OK. Avec le contrôle, je
reconnecte simplement toutes les broches. OK, donc quand nous trouverons une
énigme qui n'est pas résolue, nous la désactiverons et nous
briserons les quatre boucles. Nous devons donc également lui donner une valeur
par défaut de True. Donc, si cela ne se casse jamais, cela renverra
cette nouvelle variable. En fait,
donnons-lui également un nom. Disons que tout est résolu. Et cela le complétera. Maintenant,
expliquons un peu rapidement ce que nous faisons depuis le
début. Nous sommes en train de passer en
revue nos énigmes. Nous avons défini une
variable par défaut, une variable locale. Cela signifie que
chaque fois qu'il s'exécute, il commence comme résolu. Même si nous la désactivons la
prochaine fois,
elle commencera comme terminée
car il s'agit d'une variable locale. Maintenant, nous allons parcourir nos
puzzles avec une boucle for. Nous vérifions s'ils sont résolus. S'ils ne sont pas résolus, nous désactivons cette variable,
nous interrompons la boucle et nous produisons
le résultat Allons donc tester cette boutique. Réglons les interrupteurs. Placez-les dans le mur.
Enfin, pas dans le mur, mais... Est-ce juste à l'intérieur ? Non, c'est aussi le contraire. Nous le faisons donc pivoter. Et la porte est également en face. Oui, je pense que c'est bon.
Peut-être un petit peu. De cette façon. OK, je
vais aider les joueurs à démarrer. Je vais le déplacer ici. Pas de jeu. Tu vas utiliser
un seul discours ? Oh, claquons d'abord la porte. Ça fait du bruit. Deuxième
interrupteur, et il est déverrouillé Génial. Nous en avons donc fini
avec cette porte également. Apparemment, on ne peut pas fermer. Oh, peut-être que cette porte
ne devrait pas s'ouvrir de cette façon. Peut-être et passez simplement à Pen Graph. Oh, il s'ouvre en face
du joueur. OK. Tu sais quoi ? On va laisser ça
comme E. Si tu veux, tu peux jouer avec l'angle. En fait, nous pouvons
simplement le déconnecter et passer à 90, je pense. Oui, je ne vais pas m'
en tenir à E. Je ne
peux pas, je suis désolée. Je ne
peux pas vivre avec moi. ce que je fais. Oui, cela
fonctionne correctement. Parce que le fait de toujours placer l'
angle à 90 désactive essentiellement la direction de
calcul. Quoi qu'il en soit, nous avons terminé et nous sommes arrivés au moment où nous
allons fabriquer les objets de physique. Je vais
t'envoyer le prochain.
22. Programmation d'un pressostator pour l'activation de porte: Bonjour et bienvenue
sur Unreal Engine Five,
Blueprint Mastery, Door Systems
et Interactive portal Auparavant, nous avons terminé
notre puzzle multiple, puzzle
multiple w. Nous avons
ajouté deux commutateurs, puis nous
leur avons ajouté une interface, une nouvelle fonction d'interface que nous avons appelée SLP Nous avons implémenté que lorsque SLT est appelé parce que c'est une fonction
avec un nœud de retour, il renvoie le
statut ESL du Nommée également en E salt, la variable
résolue que nous avions parce que j'ai également nommé SL la
variable de l'interface, ce qui a entraîné une erreur car
nous ne pouvons pas avoir
deux noms, deux variables portant
le même nom, une variable renvoyant et une
variable du plan Ensuite, nous avons modifié un
peu la porte du foie. Nous avons finalement supprimé
l' angle d'ouverture et fixé à
90 % la chronologie. De cette façon, nous avons contourné
la section calculée et elle s'ouvre vers nous et
non vers les escaliers Nous avons également modifié la porte de déverrouillage des
événements pour vérifier les réponses aux énigmes. Maintenant, nous avons également appelé
la porte déverrouillée lors de notre interaction car ce
ne sont pas les interrupteurs qui appellent la porte C'est pourquoi nous avons également créé cette fonction de vérification des
réponses aux énigmes qui nécessitait le
tableau d'acteurs des puzzles, qui était la nouvelle variable, la nouvelle variable de conteneur
que nous avons rencontrée. Il s'agit essentiellement d'une
liste dans un certain ordre. Pour le renseigner, nous avons ajouté
l'acteur sur la carte,
puis à partir des détails par défaut de l'
acteur nous exposons
cette variable, nous en avons ajouté deux avec un symbole
plus ici, éléments du
tableau, et nous
les avons choisis comme étant ces deux commutateurs Ainsi, lorsque nous vérifions
si le puzzle est résolu, nous utilisons une
boucle à quatre âges, un nouveau nœud que nous avons utilisé pour parcourir la liste des énigmes et demander
si elles sont résolues. S'ils ne sont pas résolus, nous avons une variable locale, ce qui signifie que lorsque
la fonction s'exécute, toujours réinitialisée sur la variable
par défaut, et la valeur par défaut est vraie Ainsi, lorsqu'il n'est pas résolu
et qu'il ne l'est pas, il recommence à tomber et
rompt la boucle du fourrage. Maintenant, il est temps de
faire les changements. Ouvrons donc notre nouvelle carte. Niveau huit. Oh, nous n'avons pas mis
le texte ici, et les collisions sont un peu plus nombreuses. Réparons d'abord à la
collision. Sélectionnons les interrupteurs et
déplaçons le boîtier un peu à
l'extérieur
pour faciliter la collision avec le joueur Nous voulons faire de même
pour l'autre boîte. Oui, c'est bon, je pense. Et aussi, augmentons un peu le cadre
de la porte,
car lorsque la porte est ouverte, je devrais pouvoir la
fermer un peu plus loin et peut-être l'agrandir
à cause des escaliers Oui, je pense que c'est bon. Très
bien, apportons un texto. Dupliquons cela en fait. C'est bon si nous le faisons.
Mettons le texte. Si je double-clique sur le texte, ou si je parviens à sélectionner un texte alors que j'ai sélectionné
le plan, je peux simplement cliquer sur le texte Je me concentre instantanément sur le texte, et je vais l'apporter ici. Et changeons le texte
pour utiliser les deux. Les deux. Leviers pour déverrouiller la porte. D'accord, apportons également la
lumière. Où est la lumière ? Et la collision,
tournons-la un peu comme ça. Peut-être quelque part ici. Oui, je pense que c'est bon. Donc, quand on entre, euh, oui. Je pense que si je venais
de K, ce serait bien. Je crois que je vais juste y entrer. Ouais. Utilisez les deux rivières
pour déverrouiller la porte. Oh, il y a deux
rivières ici. Génial. Maintenant, nouvelle pièce, commençons
par les éléments physiques. Faisons bouger les choses
parce que c'est plus drôle. Sélectionnons-les donc tous. Et c'est assez simple. Nous pouvons simplement passer aux détails. Je vais chercher de la physique. Simulez la physique, et nous
allons laisser les paramètres tels quels, car ils correspondent
parfaitement à ce que nous voulons faire. Alors maintenant, si je vais les voir, nous devrions
peut-être prendre
une longueur d'avance. Maintenant, je peux déplacer
ces boîtes. Super, mais nous devrions faire le
petit puzzle avec les boîtes. Cela ne suffit pas. Donc, ce que nous allons faire c'est
créer un commutateur, tout d'
abord, en utilisant
ce maillage ici. Alors laisse-moi retourner dans la chambre. Passons au contenu, puis
aux plans, cliquez avec le bouton
droit de la souris sur Nouvel acteur de type de
classe Blueprint Et appelons-le commutateur BP. Oui, parce que c'
est l'interrupteur. L'autre était le levier. L'un d'eux est de confondre les deux. Maintenant, ouvrons le commutateur BP et ajoutons-le au maillage Srtic Cela va dupliquer
cela. Sélectionnez le premier. Je vais l'ancrer ici. Passons aux interrupteurs. Détails. Physique. Nous allons rechercher ce maillage statique. Et nous allons mettre en œuvre jusqu'au
premier plan, en fait. C'est donc celui-ci et celui sans numéro
serait la base. Recherchez-le à nouveau
ici et mettez-le en œuvre. C'est bon. Maintenant, la prochaine
chose dont nous aurons besoin est, bien
sûr, un hub de collision. Donc, boîte de collision. Et nous allons le
redimensionner à la taille de la brique interne et
le pousser
vers le haut jusqu'à ce qu' il ne touche pas la boîte,
car nous ne voulons pas qu'il soit déclenché par
le maillage statique lui-même. Nous allons donc aussi le
rendre fin comme ça. Peut-être un peu plus mince. Je vais désactiver. Je peux
vraiment le faire d'ici. Je vais le faire 2.2. Non, 0,16. Oui, je
pense que c'est bon. donc que quelque chose entre en
contact aussi étroit pour que l'on puisse considérer
qu'il s'agit d'un interrupteur. C'est pour cela que nous
allons l'utiliser. Voici ce que nous allons
dire à
ce plan : le commutateur doit
être arrêté. Il y a
quelque chose sur toi. Je pense donc que cette taille, près de la boîte, convient. Bien, passons au graphique des événements, et nous allons avoir besoin que
les deux événements qui se chevauchent commencent et se terminent se chevauchent
dans cette case. Donc, nous allons obtenir le chevauchement de début, et nous allons
obtenir le chevauchement de fin. Maintenant, cette fois, nous
n'allons pas faire le casting ou l'autre composant a une étiquette car nous
aurons deux commutateurs. Nous devrons
retourner dans notre chambre. Amenons-les
au niveau du jeu. Ainsi, un commutateur sera, par
exemple, ici, et disons que l'autre
commutateur sera peut-être ici. Oui, mettons-le ici. Donc, dans l'un, nous devrons
mettre une boîte dessus, et dans l'autre, nous
devrons nous tenir debout, puis la porte sera ouverte. Et lorsque nous
sortirons de la gâchette, la porte s'abaissera. Nous aurons donc un
certain temps pour franchir cette porte. Donc, si nous commençons ici, il y a
peut-être plus de
chances d'échouer. Mais en gros, nous sommes en train de créer un petit
mécanisme de jeu ici en même temps. Donc, comme il est possible l'acteur soit
sur le dessus de l'interrupteur, et
qu'une boîte se trouve en même temps sur le dessus de l'interrupteur, nous pouvons utiliser quelque chose de
différent cette fois-ci. Revenons à l'interrupteur, et trouvons notre boîte et les acteurs qui
se chevauchent, ce qui nous donne une liste
de tout ce qui chevauche,
de tout ce qui se chevauche lors de
cette collision ici Il existe un
filtre de classe si nous devions simplement rechercher un type spécifique, et cela ne renverrait qu'une
liste de cette classe spécifique. Mais pour nous, nous nous
soucions de tout. Donc, ce que nous allons faire, c'est utiliser, comme vous pouvez le voir, cette icône ici est
également une icône matricielle. Cela nous indique que si nous
revenons à la porte
multi-puzzles, vous voyez, nous avons cette icône ici, alors qu'ici, nous l'avons
avec une boîte vide au milieu. En gros, cette boîte vide
n'est qu'un symbole de connexion. Donc, si je lis, par
exemple, ici, nous pouvons voir que la case est remplie, mais qu'elle est vide. C'est juste pour dire que cela n'est pas
lié à quelque chose. Ce que nous allons faire,
c'est obtenir la longueur de ce tableau. Et si c'est égal à zéro, alors nous faisons quelque chose
ou nous ne faisons
rien faux ou de faux En gros, en cas de superposition,
si ce n'est pas zéro, nous créerons une chronologie laquelle nous jouerons l'animation. À la fin du chevauchement, s'il est égal à zéro, nous inverserons l'animation. Mais je pense que c'est un bon point d'
arrêt pour celui-ci. Je te
verrai le prochain. Au revoir
23. Concevoir une porte d'entrée avec des systèmes Blueprint: Bonjour et bienvenue sur Unalizing five Bluepin
Mastery Door Systems and Auparavant, nous en avions terminé
avec les collisions de la porte à énigmes multiples. Le magasin qui prend
ces deux puzzles, ces deux interrupteurs
pour les ouvrir. Maintenant, nous avons également ajouté ce texte, ce plan de texte fluide que
nous allons éclairer, nous avons
activé la physique
de ces cases et créé
le plan du commutateur, auquel nous avons ajouté deux mesures
statiques pour représenter la partie inférieure et la partie supérieure
du commutateur et une collision de boîtes qui a
fait en sorte que le parallélogramme en trois D au-dessus
du bas Ensuite, nous avons
utilisé les événements de début de superposition et de fin de chevauchement
de cette collision de boîtes. Nous avons créé une branche
dont la question, la condition cette fois est que tous les acteurs
se chevauchent Et si c'est une longueur
supérieure à un, alors nous demandons si c'est
fondamentalement vrai ou faux, supérieur à zéro ou inférieur à
zéro, parce que c'est égal. Donc, si c'était moins, il est
impossible de l'être, mais si c'était moins, cela deviendrait toujours vrai plutôt que faux. Si nous voulions être
égal à zéro ou supérieur, il pourrait être inférieur ou
égal à zéro. Cela couvrirait
les moins de zéro. Ajoutons donc la chronologie. Allez dessiner le câble et
appuyez sur Ajouter une chronologie. Passons maintenant à la chronologie et créons un flow truck. Créons deux points. Le premier,
bien sûr, zéro, et le second,
disons, 0,5, deux, un. Je vais l'adapter à
ces deux boutons utiliser Le keyframe,
compiler et enregistrer. Maintenant, que ferons-nous lors de la mise à jour ? Eh bien, comme pour
la rotation des modifications que nous avons utilisée cette fois,
définissez une rotation relative. Cette fois, nous utiliserons un emplacement relatif
défini. Nous allons obtenir le
premier maillage statique. Nous allons définir l'emplacement
relatif. Nous allons le
connecter pour le mettre à jour. Et nous allons diviser ce vecteur parce que nous voulons
simplement changer le zen. Donc pour cela, nous allons larp et nous allons
connecter l'Alpha ici Maintenant, pour la valeur, nous avons besoin de 02 peut-être moins dix. Oui, moins dix, c'est bien. Alors, allez sur Annuler. Donc moins dix. Et
cela provoquerait sa chute. Si nous voulons le tester,
appuyons sur Play. J'ai marché
dessus, il est tombé. Maintenant, ça ne monte pas,
peut-être devrions-nous le mettre un peu plus
dans le sol parce que le personnage ne
semble pas être capable de monter trop facilement. Je suppose donc que cette
boîte sera également difficile. Ouais. Nous
allons donc le récupérer. Nous allons le pousser
ici et nous allons
faire les mêmes choses. Pareil pour celui-ci. Nous
allons juste le pousser comme ça. Ouaip. C'est bon. Revenons maintenant
au plan et créons la direction
opposée Nous allons donc utiliser
la même question. Nous allons le copier, le
coller et le mettre ici, puis nous allons
utiliser l'inverse. Nous allons donc
compiler et enregistrer, et nous allons le tester. Compilons et
appuyons sur Play. Et ça descend, ça remonte. Ça descend, ça
remonte. Génial. Maintenant que nous avons un lingot dans le foie qui
semble résolu, il va
de même
pour ce changement Créons donc que cette
variable soit résolue, et apportons-la ici. Maintenant, lorsque la chronologie se
termine et qu'elle avance, alors activez la direction de la chronologie,
nous allons la définir. Cela a été résolu à deux reprises. Et en fait, nous pouvons également
changer le matériau. Nous allons prendre le modèle à mailles
statiques, qui est notre pack d'accessoires, la boîte de déclenchement,
celui-ci, le boîtier orange Et nous allons installer du matériel. Nous n'avons pas
besoin de deux références, du matériel de réglage, et je crois que
c'est plaque de
pression sur plaque de
pression. Et nous allons également le
copier et désactiver lorsque nous quitterons le
déclencheur. Eh bien, lorsque la boîte de déclenchement n'
a rien dessus, nous devons également vendre, c'est
résolu. Quand nous partons. Nous n'attendrons pas que
toute la chronologie soit terminée. Eh bien, il s'agit en fait
plus d'un design de gameplay. Par exemple, si vous
attendez la fin
de la chronologie puis que vous la désactivez, ou si vous la désactivez
directement lorsque vous quittez le site, c'est au développeur de choisir. Ce n'est pas obligatoire. Nous le faisons donc lorsque nous nous retirons instantanément au lieu d'attendre que le
bouton se lève. Et cela devrait être prévu sur
une plaque de pression, pas sur mesure. C'est bon. Allons donc tester ça.
Vire au vert, devient normal. Vire au vert, devient normal. Vous voyez, si je marche trop vite, il tourne plus vite parce qu'il continue à
jouer là où il était. Maintenant, apportons une case sur un bouton et voyons
si cela ne fonctionne pas. La raison pour laquelle cela ne
fonctionne pas est que, par défaut, dans
ces cases dans leurs paramètres de
collision événements de génération de chevauchement
sont désactivés dans
ces cases dans leurs paramètres de
collision. Si je l'active, cela signifie que cette boîte n'
ignorera pas cette collision. Mais nous ne voulons pas que cela
se produise dans toutes les boîtes. Nous voulons juste cette boîte, celle avec
les couleurs
et sur laquelle il est écrit « push ». Les autres ne font donc rien, et celui-ci, nous faisons quelque chose. Activons donc cette option
pour générer des événements de chevauchement. Compilons, appuyons sur Play, appuyons sur cette
case, et cela a fonctionné. Et si je m'assois ici,
ça marche aussi. Et la prochaine étape serait de
faire en sorte que tout fonctionne ensemble
et de créer la porte. Maintenant, poursuivons celui-ci juste pour démontrer qu'
il ne fonctionne pas. Oui, ça ne marche pas, mais si je marche, ça marche. Continuons donc à dupliquer
notre porte multi-puzzles. Passons donc à notre porte
multi-puzzles, trouver d'une manière ou d'une autre. Je peux me déplacer
ici. Non, en fait, j'en ai besoin dans le navigateur de
contenu. Et la façon dont je m'y prends manuellement. Oh, oui, ce bouton ici. Si j'appuie sur ce bouton,
il m'y amène. Donc, en dupliquant cela,
nous appellerons
cette porte à interrupteurs
multiples BP. Ouvrons-le. Et ce dont nous n'aurons pas besoin, nous n'aurons pas besoin d'une contribution. Cette porte s'ouvre d'elle-même, et nous n'aurons pas besoin d'un hochet Cela ne sera pas nécessaire. Il faut que la porte soit déverrouillée. Et nous n'avons pas besoin
du début, nous le faisons, nous pouvons créer
un widget pour ce magasin, exemple faire quelque chose
pour ouvrir cette porte. Donc, en gros,
passons à la mise à jour du widget. Ce magasin aura deux états. Il aura fermé ses portes. Réglons la fermeture par défaut, puis l'ouverture, la
fermeture de base et l'ouverture. Mais fermons et
ouvrons. Ça n'a pas vraiment d'importance. Donc, quand il sera fermé,
nous dirons, mais il
faut appuyer sur les deux interrupteurs. Capitalisons les premiers en majuscules. En fait, nous n'avons pas besoin
d'insister sur tous les autres cas, nous n'avons pas besoin de dire quoi que ce soit. Donc, en compilant la sauvegarde, nous avons une erreur car nous appelons Rattle alors qu'il n'y en a pas Et bien sûr, nous n'avons pas
besoin de la face avant. Nous n'avons pas besoin de
calculer les directions. Peu importe qu'il soit utilisé. Nous allons le supprimer là où
il est utilisé. Nous avons donc besoin du moment où il est
ouvert pour s'ouvrir, du moment où
il est proche pour s'ouvrir, moment où il est ouvert pour se fermer. Et nous n'avons pas besoin de l'
être du début à la fin. Nous avons besoin que cela continue
là où il était. Donc, cela va jouer, et cela va aller en sens inverse
parce que cette porte s'
abaissera lorsque les
deux interrupteurs seront éteints, et quand ils seront tous les deux
allumés, elle se lèvera. Nous voulons donc qu'
il émette un son
lorsqu'il fait cela. Nous allons donc jouer du son. Et joue du son. Le premier
serait un lève-porte, et l'autre sera
également un lève-porte. Mais nous voulons que le
son qui
descend soit un
peu plus profond, afin qu'il passe à 0,8 pouce. Cela semble donc plus profond. Et cela en croira les usages, et ce serait
tout à cause des sons. Maintenant, la prochaine chose que nous devons
faire est de
changer ce modèle. Nous allons donc aller
chercher notre modèle ici, mais on ne
sait pas
exactement de quel modèle il s'agit. C'est
censé être un pack d'accessoires. Je le trouverai d'ici. Oui, nous l'avons trouvée. Et
allons-y et mettons-le dedans. Il a mal pivoté,
mais peu importe. C'est juste que je n'
aime pas le côté. Oh, il n'a pas le bon matériau. Oui, parce que j'ai
changé la porte, mais le matériau
est resté le même. Maintenant, je peux appuyer dessus
pour le rétablir par défaut. Et c'est ce
qui s'est passé. Si vous modifiez le maillage,
le matériau reste le même que celui du maillage précédent sauf si vous avez
un matériau par défaut, qui le remplace par le
matériau par défaut du nouveau maillage. Mais si vous avez remplacé le matériau du maillage précédent, il conservera le matériau
remplacé Quoi qu'il en soit,
continuons, ramenons la porte un peu
plus au milieu. Je pense que c'est à peu près très bien. Je vais appuyer un peu vers le haut. OK, compilez et sauvegardez. Et ajoutons-le
également sur la carte. Accédez aux plans, aux portes
et aux portes à interrupteurs multiples On aurait pu
le nommer autrement. Est-ce que la face avant est
la face avant, non ? Cook pourrait être un
peu plus gros. On pourrait y aller un petit peu. Ça l'étire un
peu, mais oui, je vais l'
agrandir un peu, je préfère. C'est trop gros maintenant. Comme vous pouvez le constater, ne faites jamais cela sur le plan car lorsque vous le faites sur
l'acteur dans son ensemble, vous obtenez également des résultats
inférieurs aux collisions Donc, même si cela semble beau, il se peut que cela ne fonctionne pas correctement. Donc, si je voulais le faire, je devais me rendre sur l'accessoire
lui-même, puis le faire Oui, je pense que c'est bon. Le rendre un peu plus grand
et un peu plus petit. Je peux aussi
le faire en boucle. Je peux annuler toutes ces modifications
et le faire ici. D'accord. Agrandissons également
un peu la boîte de collision. C'est bon. Ce sera donc
un peu plus élevé également. Il. Maintenant, cette porte ne se déverrouillera
que de cette façon Donc, si nous avions commencé de cette façon, nous aurions été bloqués. Ça n'a pas d'importance. Maintenant, je
pense que c'est tout pour celui-ci. Au prochain,
nous allons coder pour que les deux
interrupteurs ouvrent la porte. Au revoir.
24. Mettre en œuvre des astuces pour la mécanique des portes à commutateur de porte: Bonjour et bienvenue sur les Blueprint Mastery,
Door Systems et
Interactive d'
Unreal Engine Door Systems et
Interactive Auparavant, nous avions
presque terminé
les visuels de notre porte coulissante,
coulissante vers le haut avec le mécanisme à interrupteurs
multiples Maintenant, ce que nous avons fait, c'est terminer avec la chronologie, en
jouant depuis le début, jouant ou en inversant
les événements de début
et de fin qui se chevauchent Et quand c'est fini, nous avons dit que c'était résolu. Mais lorsque nous avons mis fin au chevauchement, nous avons dit que le problème n'était pas
résolu instantanément. Nous changeons
également le matériau et nous utilisons l'emplacement relatif
défini. Nous avons également dupliqué
notre porte à puzzles multiples et supprimé certaines choses, et nous avons conservé l'
animation de la porte, l'interrupteur Nous avons ajouté un son de lecture, et nous l'
avons connecté à la lecture et à l' inversion au lieu de jouer depuis le
début et d'inverser depuis la fin. Nous avons également supprimé l'entrée E. Ce que nous devons supprimer,
c'est le widget Ajouter une porte. En fait, nous n'avons pas
besoin de supprimer complètement
le widget Addo Laisse-moi annuler. D'accord, nous devons l' ajouter à closed car ce n'est que
lorsque la porte est fermée que
nous voulons qu'il affiche le widget. Maintenant, en y réfléchissant, il doit y avoir un bogue partout. Allons donc jouer et
tester un peu. Je pense qu'il y a un
bug qui fait que lorsque
nous fermons la
porte et que nous nous
éloignons, je montre le widget.
Je vais donc le fermer. Ouais. Parce que nous
ajoutons le widget, peu importe si nous sommes
impliqués dans la collision ou non. Donc, pour résoudre ce problème, nous devons changer certaines choses. Mais nous allons le
faire plus tard. Continuons maintenant
avec la porte. Ce que nous allons corriger c'est ajouter quelques règles ici, et dans chaque plan, nous enverrons simplement une
référence à l'acteur Continuons maintenant à réparer la
porte à interrupteurs multiples en la complétant. Ce que nous devons faire, c'est aller
à notre porte déverrouillée. Tout d'abord, faisons-en une
interface car nous la dupliquons. Je vais donc
double-cliquer sur Unlock Door, créer l'événement d'interface. Je vais l'apporter ici
et supprimer celui-ci. Maintenant, ce que nous devons vérifier c'est mettre à jour le texte du widget et le modifier pour supprimer le widget. Je vais donc copier
le code d'ici. Je vais le coller ici. Ainsi, lorsque nous
déverrouillons la porte, le widget est toujours retiré,
même s'il se trouve sur la vue Et, bien sûr, l'animation de
porte d'appel , car
lorsque nous déverrouillons, nous devons appeler cette animation La prochaine chose dont nous aurons
besoin est une porte verrouillée, la même chose mais pour le verrouillage. Nous allons donc
retourner à nos portes de BI, créer un nouvel événement, une
nouvelle fonction, et nous allons
appeler cela une porte verrouillée. Et nous allons
aller à notre porte, et nous allons appeler
l'événement d'interface. Et ce dont nous avons besoin à partir d'ici, c'est que cela doit
vraiment être fermé, oui. Ainsi, lorsqu'il est fermé et qu'il exécute l'animation de la porte,
il s'ouvre. Il nous faut donc le contraire. Nous n'avons pas besoin du
son ici parce que nous en jouons déjà
un ici. Nous n'avons pas non plus besoin du changement
matériel. Il y avait donc certaines choses
que nous devions supprimer, mais nous avons besoin de tout le reste. Eh bien, en fait, nous n'avons pas non plus
besoin du widget de suppression. Il faut donc l'
activer pour l'ouvrir, puis nous lançons l'animation du chien qui, une
fois terminée, sera ouverte, de sorte qu'elle diffusera le son fermé et s'
inversera où qu'elle se trouve. Maintenant, nous devons
appeler ces événements. En fait, nous n'en avions pas besoin, alors je m'occupe de savoir comment
appelle-t-on ces événements Eh bien, c'est assez simple sur le
switch que nous avons créé. Lorsque nous avons fini d'
appuyer sur le bouton, nous appelons, eh bien, nous avons besoin
d'une référence à la porte, nous allons
donc
créer une variable. Nous allons le
faire de type acteur et nous pouvons le faire de type acteur parce que nous avons l'interface
Blueprint Appelons cette porte
et rendons-la modifiable en instance et exposons-la au moment du spawn afin que nous puissions la modifier depuis
l'éditeur et aussi
lors de la création à partir
d'un autre Je vais sélectionner ceci
et sélectionner la porte sélectionner ceci et cela et
sélectionner également la porte. Nous avons donc maintenant une
référence à notre porte. Où est le commutateur ici ? Et nous allons obtenir
cette référence de porte
et ce message de porte déverrouillée Envoyez le
message de la porte déverrouillée ici. Ensuite, nous devons envoyer
le message du journal ici. Nous mettons donc fin au chevauchement. Nous envoyons que
ce n'est pas résolu,
nous disons que ce n'est pas résolu et nous envoyons Lock Door Et lorsque nous
commençons à nous chevaucher, lorsque la chronologie est terminée, nous envoyons Unlock Door. Maintenant, en théorie, cela devrait
fonctionner. Vérifions-le. Vous devez d'abord appuyer sur cette case. C'est bon. J'ai joué le son, il n'aurait
pas dû le faire. C'est donc une bonne situation
pour utiliser le débogueur. Voyons ce qui se passe. Je vais donc trouver la
porte, l'interrupteur multi-portes. Je vais m'éjecter. Je vais
apporter ça ici. Je vais le déconnecter,
corriger le zoom. Réduis-le un peu plus petit. Faites-le un peu
plus grand, un peu plus. C'est ici. Sélectionnez la porte à interrupteurs
multiples de celui-ci. Encore une fois comme ça.
Retour au tutoriel. Voyons voir ce qu'il fonctionne. Un huit à reprendre possession. Donc c'était bon, tout d'
abord, il
fait une rotation, ce qui ne devrait pas être le cas. Mais pourquoi est-ce qu'il fonctionne
pour injecter à nouveau ? Donc, le problème est là, c'est que le
puzzle est rangé. Eh bien, pour l'instant, cela devrait
être résolu parce que nous
avons ceci, mais ici, il est admis que c'est résolu, ce qui n'est pas vrai. Nous n'avons pas de puzzle matriciel, c'est pourquoi cela se produit. Il dit que c'est vrai
parce qu'il
n'y a aucune pièce de puzzle sélectionnée. C'est un sac intéressant. Alors peut-être qu'un code
qui, s'il vaut zéro, ne devrait pas s'ouvrir
serait nécessaire. Passons à l'interrupteur. D'accord, je n'ai pas ouvert. Je déménage ici, mais ce n'est toujours pas le cas. Cela a déclenché le
pouls, donc c'est bon. OK, tout d'abord,
changeons le truc de rotation. Il ne devrait pas pivoter. De plus, j'ai oublié ça. Nous ne devrions pas définir une rotation
relative et le faire dans le
mauvais plan Je vais aussi revenir
à l'interrupteur. Supprimez donc l'
emplacement relatif, conservez l'alouette, supprimez l'angle ouvert,
définissez l'emplacement relatif Connecté ici, connecté ici, divisez le nouvel emplacement,
connecté ici. L'
emplacement d'origine des portes est donc proche. C'est un peu complexe, nous devrions
donc l'
enregistrer au début du jeu, passer de la promotion de localisation relative à une variable,
le connecter ici. Begin enregistre la variable. Et nous allons
apporter cette variable. Nous allons faire une pause partagée. Nous allons connecter X ici. Nous allons connecter Y ici parce que nous voulons qu'ils
restent les mêmes. Et à partir de Z, nous voulons que
cela passe à deux -13. Disons que 260
Rackley semble aller bien. Nous verrons dans
WordSpace plus tard dans la soixantaine. Alors maintenant, la porte ne devrait
pas au moins pivoter. Il n'augmente pas parce qu'il
faut le résoudre. Mais je pense qu'il y avait un bug qui ne
se produisait pas de toute façon. OK, une nouvelle parenthèse. Créons du code pour placer ce tube dans cette
position quand nous le voulons. Nous allons copier cet
emplacement du tube. Nous allons passer au plan de
niveau dans lequel nous avons créé ce code
ici et nous allons choisir celui du clavier Et nous allons
cliquer et créer une référence à cette case
parce que je l'ai sélectionnée. Et je vais définir le lieu. Je dois le coller ici. En fait, je vais en
faire une variable, le compiler
et le coller ici. Maintenant, vous voyez, je pourrais coller tout
ce vecteur parce que
c'est un vecteur, en fait. Je peux le copier d'ici et coller dans une nouvelle variable. Je n'ai pas pu le coller ici, il n'y a aucun moyen de le
coller ici. Je peux le coller en X, mais il colle
tout dans une seule case. Donc, il suffit de connecter
cela pour appeler cette boîte l'emplacement. Et connectons cela ici. Donc en gros, pour l'instant, si je déplace cette case, appuie sur une, elle revient ici. Génial. Maintenant, nous pouvons créer des codes pour le coller
exactement où nous le voulons. Faisons-le donc pour le numéro deux. Comment faire cela ? Je
vais le placer là. Je vais m'éjecter.
Je vais le sélectionner. Je vais copier à
nouveau cet emplacement car si je déplace cette case maintenant, il changera toujours d'emplacement. Il est mis à jour en direct. Je vais donc arrêter de
jouer, aller Tutorial Map et
appuyer sur le clavier 2. Et je vais créer un
nouveau vecteur de type variable. vais compiler,
coller la nouvelle valeur, l'
appeler box, trigger, location, et je vais juste
dupliquer ce code. Et c'est une bonne occasion
de vous montrer autre chose. Lorsque j'ai un vecteur comme celui-ci, je peux cliquer avec le bouton droit sur
le vecteur et dire « remplacer la variable par l'emplacement du déclencheur de la
boîte ». Donc, si j'avais d'autres vecteurs ici
aussi, ajoutons-en d'autres, deux de plus. Je pourrais les remplacer par eux. Donc, s'il s'agit du
même type de variable et que vous êtes dans le
même plan, vous pouvez avoir cette
option ici Donc, l'emplacement du déclencheur, la colonne vertébrale doivent connecter la cible, car qui
suis-je en train de définir la position ? Jouons, et je suis doué
pour pousser des boîtes. C'est bon. Je pense que c'
est suffisant pour celui-ci. Nous allons le débuguer lors de
la prochaine leçon. Je
vais te voir alors. Au revoir.
25. Débogage et optimisation du système de porte à commutateur de porte: Bonjour et bienvenue
sur Unreal Engine Five, Blueprint Mastery Door Systems
et les portails interactifs Auparavant, nous avions
presque terminé avec notre
porte à interrupteurs multiples qui coulissait vers le haut. Maintenant, je souligne en quelque sorte
ce qui s'est mal passé. Dans les commutateurs, nous ne l'avons pas fait,
je n'ai pas mis l'interface, nous devons
donc mettre l'interface
I VidOr Et pour ce qui est
de la fonction résolue, nous devons la connecter. Il semble que par erreur, lorsque j'ai cliqué sur la porte
et que j'annule certaines actions, je retire les pièces du puzzle, donc je vais les ajouter à nouveau. Le premier est ce
changement ici, et le second est
le changement ici. Assurez-vous d'avoir
sélectionné les interrupteurs et non le sol ou un mur. Donc, en théorie, cela devrait
maintenant fonctionner. Donc, si j'appuie sur deux,
le téléps est là, et si je reste là, ça
monte très, très vite Donc ça descend très, très vite. Cela ne
me laisse donc pas assez de temps pour courir. Et comme vous pouvez le constater,
le widget est un petit
peu visible au verso, même si je ne le superpose pas,
que nous allons corriger plus tard Maintenant, il ne dit rien non
plus lorsque la porte est fermée. Réparons donc cette boîte. Commençons par le widget qui affiche E lorsque je le
superpose Et en fait, allons-le également
un peu plus. Donc, comme cette histoire n'
est que de cette façon, je vais juste l'
apporter ici et la réduire un
peu. Et c'est très bien. Maintenant, pourquoi le
widget ne dit rien ? En gros, comme la valeur par défaut
est fermée et ouverte, nous ne disons rien, et je suis contrariée à
l'ouverture pour dire quelque chose C'est donc une erreur. Maintenant, il est écrit E, mais nous n'allons pas nous embêter
à réparer le E. Les deux interrupteurs doivent être allumés. Donc, appuyez sur deux, maintenant
ça devrait juste indiquer E. Non, ça ne devrait pas
parce que c'est fermé. Donc, ce que nous allons
faire, c'est un peu
la
chronologie . Est-ce la bonne ? Maintenant, ce n'est pas
la bonne. Porte à interrupteurs multiples. C'est ici. Passons à la chronologie. Réglez ces deux.
Donnons-lui un peu de temps. Disons 5 secondes. Mais cela signifierait 5 secondes pour monter et 5
secondes pour descendre. Ce serait donc une porte lente. Je vais donc appuyer sur deux. C'est une porte lente, lente à monter et à descendre
lentement. Bien, maintenant, réparons le
sac qui émet le son lorsque je prends la parole Ce que nous allons faire est de résoudre ce problème, et nous allons utiliser
un nouveau nœud pour cela. Nous allons aller à notre porte, porte interrupteurs
multiples ici. De près. Non, pas d'ouverture. Donc, en gros, lorsque nous fermerons la porte, nous allons obtenir
la chronologie elle-même, ce que nous n'avons jamais fait auparavant. La chronologie est également une variable. Nous pouvons le trouver dans
le talon du composant. Nous pouvons la trouver elle-même sous
forme de variable. Il s'agit donc d'une référence
à la chronologie. Et si nous donnons un nom à notre chronologie parce qu'elle
est également disponible, nous pouvons appuyer sur F deux
sur la chronologie
et dire chronologie de l'animation. Comme vous pouvez le constater, cela
change également ici. Donc, si nous avions un
tas de délais, nous pourrions les trouver ici. Je vais donc l'obtenir en
tant que variable getter, et je vais obtenir la
position layback Alors, à quoi sert Get
Clayback Position ? En gros, il obtient
l'heure actuelle de la chronologie
lorsqu'il joue, il a l'heure actuelle, et cela la renvoie. Donc, ce que nous allons faire, c'est
utiliser une branche. Nous allons faire
une note égale ici. Si ce chiffre est égal à zéro, ne jouez pas. En fait, ne jouez pas le
son. Connectons-le ici et
false apparaîtra ici parce que le jeu
est déjà en cours de lecture. Quand il ne joue pas,
nous allons faire marche arrière. Il n'y a aucune raison de faire marche arrière, car nous réglons l'état
sur la fermeture parce que nous
mettons l'état ouvert ici. Alors testons-le. Pas de son. Donc ça marche. Il y a du son. Il y a du son. Si je le remets en marche,
il n'y aura aucun son. Donc ça marche. Sympa. Apportons la zone de texte. Apportons-en un nouveau car ils
sont trop modifiés. Commençons par
le texte flottant où nous
devrions le mettre ici. Que dira-t-il ? Tout d'abord, disons qu'il s'
agit d'une porte coulissante. Je ne l'ai pas sélectionné. Il s'agit d'une porte coulissante. C'est bon.
Mettons-le là-bas. Faisons également entrer
un quart de travail. Peut-être que je vais aussi le réduire un
peu . Oui, c'est bon. Apportons également la lumière. Je pense que c'est bon. Et la collision. Quand le joueur doit-il entrer en collision avec cela ? Hmm. Tout ce que tu voudras. Je vais juste faire
quelque chose comme ça. Et je pense que c'est bon.
Peut-être plus comme ça. Oui, c'est bon.
Alors allons-y. C'est un jeu glissant. Nous voyons cela lorsque nous
entrons d'ici, nous voyons cela, c'est
une porte coulissante, et nous résolvons le puzzle. Génial. Maintenant, pour
résumer ce que nous avons fait, nous avons créé un plan de commutation,
auquel nous avons ajouté l'
interface de BI Doors Dans le graphique des événements, nous avons créé une animation
avec une chronologie, et nous déclenchons les événements au début du chevauchement et à la fin du chevauchement
. Selon les règles, ils envoient un message
à la porte indiquant que je suis résolu et
essaient de déverrouiller la porte ou que je ne suis pas résolu
et verrouille la porte. Ensuite, nous avons créé le
plan de la porte, qui est la porte à interrupteurs multiples Et selon le message
qu'il envoie, soit
il déverrouille la porte, qui essaie de l'ouvrir diffusant l'animation de la
porte, soit s'il se verrouille, il inverse l'animation
et verrouille la Passons maintenant
à la pièce suivante. Nous allons ouvrir
le petit œil. Il y a donc probablement
quelque chose qui ne va pas ici. Nous allons donc
ouvrir les deux yeux. Niveau neuf et niveau dix.
En gros, c'est bon. Niveau 9, niveau 10, peu
importe. Alors, ici, qu'
allons-nous créer ? Nous allons créer à peu
près le même mécanisme, mais avec deux portes sur
lesquelles ils peuvent monter et descendre, et nous aurions trois boutons lesquels il faudrait
appuyer dans l'ordre. En plus de cela, nous aurons également un plan distinct qui décidera si cette énigme
est résolue ou non Et la porte
communiquera avec ce responsable, et le directeur
communiquera avec la porte. Les boutons eux-mêmes n'
auront donc aucune interaction
avec la porte elle-même. C'est un autre exemple de la façon de créer un mécanisme
qui ouvre une porte. Mais je pense qu'avant de continuer, nous devrions corriger ce bogue qui s'
active après la
fermeture de la porte et corriger tout le
reste, car le faire vers la fin représentera plus de travail à faire dans
chaque plan Donc, ici, le
plan apparaît. Le widget apparaît. Et c'est ce que nous
allons faire dans
la prochaine leçon. Au revoir pour le moment. On se voit alors.
26. Préparation d'une porte coulissante à boutons puzzle: Bienvenue sur
Unreal Engine Five, Blueprint Mastery, Door Systems
et portails interactifs Auparavant, nous avions fini
avec notre porte coulissante, notre porte à interrupteurs multiples. Avant de passer à la porte à boutons, nous avions
demandé au responsable de fixer le
widget
sur toutes les portes. Je vais donc tout
fermer ici, juste en haut à
droite, et je vais ouvrir chaque porte dans l'
ordre qui lui est propre. Peu importe. Nous voulons juste qu'
ils soient tous debout. Et je vais économiser. De plus, nous aurons besoin du mode de jeu à la
troisième personne,
que nous trouvons dans le mode de jeu Blueprints à la troisième
personne Nous avons donc ce
widget de porte, chez Door Widget. Et à partir de ce widget Door
at Door, nous pouvons réellement trouver des références où qu'elles se trouvent
en utilisant le clic droit, recherchant les références par nom, puis en utilisant ces deux
langues vernaculaires, Ainsi, en utilisant cela, une nouvelle recherche
s'ouvrira qui
nous montrera partout où cette fonction existe, cet événement existe. Donc, ce que nous pouvons faire,
c'est créer
une entrée ici que nous appellerons. Ce sera le composant de collision de la
boîte de saisie. Je pense que cette collision de boîtes
serait , laissez-moi voir, un composant de
collision. Maintenant, je suppose que la
collision de boîtes fera l'affaire. Je vais donc donner un nom à cette boîte. , Collider a peut-être besoin
de L honnête, Collider a peut-être besoin
de L. Je ne suis pas sûr. Je vais le laisser
car cela n'a pas d'importance. Et je vais trouver des acteurs
qui se chevauchent dans ce collisionneur Et je vais
vérifier auprès du personnage de la classe à la troisième personne, si c'est get length, bien
sûr, juste length,
pas get length. Et si c'est au-dessus de zéro,
je vais apporter une branche. Je vais ajouter une fenêtre d'affichage. J'espère donc que cela
résoudra le problème. Maintenant, il ne
nous reste plus qu'à accéder à
chaque plan et à trouver
les portes publicitaires que nous
pouvons réellement trouver dans le champ
de recherche,
où est passé le champ de recherche ? chaque plan et à trouver les portes publicitaires que nous
pouvons réellement trouver le champ
de recherche, où est passé le champ de recherche Ils le ferment. Je l'ai peut-être
fermé. C'est ici. Nous pouvons donc simplement
double-cliquer sur chacune d'entre elles, simplement apporter le box collider et cliquer sur le
suivant pour accéder au mode de jeu Je vais donc prendre celui-ci et choisir le box collider Ainsi, nous ne
manquerons aucun d'entre eux. Nous n'avons pas à effectuer de
recherche manuellement. Nous pouvons simplement nous rendre à chaque événement. Maintenant, cela n'est pas recommandé. Il pourrait y avoir de meilleurs
moyens de le faire. Mais c'était une bonne façon d'ajouter
la recherche ou les plans. Comme si cela avait créé une
raison de le faire. Eh bien, ce n'est pas une
très bonne option, mais j'espère que cela fonctionne. Ce n'est pas beaucoup, mais c'
est une somme formidable. Avons-nous connecté
le bon ? Ouais. Enfin, ces deux-là, et il n'y a rien
d'autre sur la liste. Ouais, c'est le dernier. Donc je suppose que cette fois, testons le quartier
2 ici,
une autre porte avec tos, une autre porte avec tos, et il n'y a pas eu d'ajout de widgets
parce que je n'étais pas Donc je suppose que
si je suis là,
oui, il l'a mis à jour Génial. Maintenant, d'après ce que je vois, lorsqu'
il s'ouvre ou se ferme, il affiche toujours le E, ce que nous
ne voulons pas qu'il fasse. Donc, encore quelques problèmes à résoudre, nous passerons à la
porte à interrupteurs multiples. C'est celui-là. Alors, quand je vais bien. Donc, si je termine, nous devrions peut-être l'
ajouter partout. Mais c'est bon. Ce que nous devons faire, c'est
ajouter cet état de commutateur ici et dire que si la
porte se ferme ou s'ouvre, en fait, juste à celui-ci,
je pense, pas à tout. Nous n'avons pas besoin d'afficher
ou de fermer le widget. Peu importe. Passons
à la porte d'à côté. Commençons maintenant à créer
les actifs de la nouvelle porte. Nous allons donc avoir besoin d'
un plan d'acteur que nous appellerons
PP Button Je vais appeler.
Je vais
également avoir besoin d' un plan d'acteur
que nous appellerons PP Puzzle Manager Ensuite, nous aurons besoin
d'une nouvelle porte. Nous allons donc
aller chez nous et dupliquer la porte à interrupteurs multiples. Je vais l'appeler
Buttons Puzzle Door. Maintenant, enregistrons automatiquement
puisqu'il est apparu. La façon dont cela va
fonctionner est que nous allons avoir tout d'abord
la porte, ce qui ne sera pas le cas,
mais cela n'a pas vraiment d'importance. Cela va changer plus tard. Nous allons avoir
la porte, nous
allons avoir la sauvegarde. Je vais donc tout sauver,
ce que j'ai oublié de dire. Ce bouton indique tout, mais nous pouvons également contrôler les tamisages Et nous pouvons également trouver des
sauvegardes partout ici. Nous allons donc avoir besoin de trois
boutons. Retournons en arrière. Apportons trois boutons. Un, deux, trois, en fait, deux, trois, et nous allons
également avoir besoin du gestionnaire de boutons,
du gestionnaire de puzzles. Je vais l'apporter
ici. Cela peut être n'importe où sur cette carte,
cela n'a pas vraiment d'importance. Mais je vais l'
avoir ici, pour nous
sachions que c'est le manager. Maintenant, selon la façon dont
cela
va fonctionner, les boutons
connaîtront le responsable et le responsable
connaîtra la porte. C'est en fait comme
ça que ça va fonctionner. Créons ces références. Je vais donc tout fermer ici et ouvrir les boutons, le manager et la porte. Le puzzle des boutons est terminé. OK, je
dois les enfermer ici. Il ne s'agit pas d'une fenêtre séparée. C'est bon. Et non pas
la porte aux boutons. Nous devons créer une référence
de responsable. Donc, une nouvelle variable, tu
vas appeler BP Manager. Je vais chercher BP Manager. Une référence à un objet,
que nous appellerons gestionnaire de puzzles. Maintenant, la prochaine chose dont nous avons besoin, c'est que le directeur soit au
courant de l'existence de la porte. Dans le gestionnaire,
nous allons donc créer
une nouvelle variable. Nous allons l'appeler. Nous allons trouver un et nous allons appeler
une référence d'objet. allons en faire une référence à un
objet, et
nous allons l'appeler PP. Notez qu'ici,
j'ai utilisé un acteur, alors ici, j'ai utilisé
le manager lui-même. La raison en est que nous
n'avons pas besoin de créer de nouvelles interfaces ou quoi que ce soit pour le manager. C'est
juste un manager. Si j'avais voulu avoir
beaucoup de managers et leur
envoyer leurs propres messages, j'aurais pu le créer en tant qu' acteur et une interface pour envoyer
des messages aux managers. Nous devons également rendre
ces variables modifiables. Puisque nous avons besoin d'une
référence dans l'éditeur. Et passons au rédacteur en chef. Maintenant que nous les
rendons visibles, pourquoi est-ce que je ne les vois pas ? Parce que je n'ai pas compilé. OK, maintenant que j'ai
compilé, le voici. Je vais donc
sélectionner le manager, et ici je vais
sélectionner le manager, et ici je vais
sélectionner le manager. Et le directeur
doit connaître la porte, alors je vais sélectionner la
porte et je vais économiser. Maintenant, allons en bas de page. Ouvrons le plan. Nous avons besoin de deux maillages statiques. vais le dupliquer,
et pour le premier, trouvons notre
bouton. C'est ici. Je vais sélectionner
l'interrupteur inférieur. Je dois le trouver dans le navigateur puis le transmettre ici. Et pour l'autre, j'ai fait le contraire.
Ça n'a pas vraiment d'importance. Je vais le trouver dans le navigateur
et le placer ici. Passons maintenant à la porte. Nous allons avoir besoin d'un
deuxième maillage statique. Je vais dupliquer celui-ci. Et sélectionnons le
premier et passons à notre carte. Trouvez que la porte s'ouvre. Comme ça,
trouvez-le dans le navigateur, allez à la porte
et passez-le ici. Obtenez le suivant,
trouvez-le dans le navigateur, accédez au plan et
passez-le ici. Oups Oui, ce sont les
bons matériaux, non ? Et je vais
les déplacer un peu plus haut vers la gauche. Et celui-ci est un peu plus petit. Et peut-être ici et un peu plus longtemps. C'est bon.
Allons vérifier la porte. Ça va, un peu vers la gauche.
Je pense que c'est bon. Peut-être
un peu plus en avant. Quoi qu'il en soit, je pense que c'est bon
là-bas et que les boutons
doivent pivoter. Celui-ci et celui-ci vont tous les sélectionner et
les placer un peu plus haut. Peut-être que c'est un peu bizarre. Cela aussi et je pense que nous sommes
prêts à commencer à programmer. Mais nous allons le
faire lors de la prochaine leçon. Alors au revoir pour le
moment. À bientôt.
27. Créer des mécanismes de puzzle de boutons pour des portes interactives: Bienvenue sur
Unreal Engine Five, Blueprint Mastery, Door Systems
et les portails interactifs Auparavant, nous avions terminé
la partie visuelle, la mise en place de notre scène, et le réglage des visuels
et du message de nos plans pour la nouvelle porte Passons maintenant à la
programmation du gestionnaire. Ouvrons le gestionnaire. Passons au graphique des événements. Et ce dont nous avons besoin ici,
ce sont deux événements personnalisés. Et dites « bouton » sur un autre bouton de pliage
personnalisé. Maintenant, nous allons
faire quelque chose de délicat, mais qui n'est pas très nécessaire, mais c'est un bon moyen de
démontrer un autre conteneur
variable. Nous allons utiliser le conteneur de variables
cartographiques. Nous allons donc
dupliquer ce Gr BIP, et nous allons le
nommer pièces de puzzle Nous allons donc passer aux conteneurs et choisir un conteneur de
cartes. Maintenant, comme vous pouvez le constater, un deuxième type de variable est
apparu ici
, que nous allons
définir sur le harcèlement. Qu'avons-nous réellement
créé ici ? Qu'est-ce que ce conteneur de cartes ? Eh bien, le conteneur de cartes suit la règle suivie par le
conteneur défini. Cela signifie qu'il ne peut pas avoir de premier type de variable
dupliqué. En disant cela, je veux dire que le deuxième type de variable peut être plusieurs fois le
même, peu importe. Mais le premier type de variable doit toujours
être différent, il
ne peut pas être le même. Et, bien entendu, cette liste correspond à la façon dont
les choses sont saisies Par exemple, pour le moment, nous l'avons rendu instantané
et exposé au moment du spawn et nous allons ajouter trois variables Je dois le faire à partir d'ici
car chaque fois que j'en ajoute une, je ne peux pas en ajouter une autre car non variable est
la première variable et elle la considère comme
quelque chose d'unique. Je ne peux donc pas en ajouter une seconde. Donc, en ajoutant le premier non, comme vous pouvez le voir, je ne peux pas en
ajouter un second, mais si je choisis l'un
des boutons, l'ordre ici est important. Le premier bouton est donc celui de
gauche, tel que
nous le voyons actuellement. Je vais donc ajouter
une deuxième variable. La deuxième serait
celle du milieu et la troisième variable, la troisième
serait la bonne. Maintenant que nous avons un
ordre de un, deux, trois, et que nous avons un bouton
correspondant, nous pouvons définir un code qui correspond à la bonne façon dont ces
boutons devraient fonctionner. Revenons donc à
notre gestionnaire de puzzles. Créons une autre
variable que nous appellerons mot de passe correct Et il ne
sera pas du type map, il sera
du type array, et il sera
du type booléen,
container array
et boolean container array
et Nous allons compiler et enregistrer. Nous allons ajouter
trois éléments. Supposons que le
premier et le
dernier soient activés
et que ce soit le bon mot de passe. Nous pourrions l'exposer sur
un spawn et le modifier, le
rendre modifiable, afin de pouvoir définir le mot de passe
que nous voulons à partir d'ici Maintenant, n'oubliez pas, autant de pièces de
puzzle que nous avons, que nous devrions avoir de nombreux éléments de
tableau corrects pour le mot de passe. Pour ce type de puzzle
que nous fabriquons, tel que nous le fabriquons. Revenons maintenant au gestionnaire
de puzzles. Et ce que nous devons faire, c'est ajouter un acteur en tant que contribution
à ces deux événements. Nous allons donc placer
cet avantage ici. Nous allons ajouter un acteur et ici nous allons également
ajouter un acteur. Et nommons-le puzzle et copions-le également dans l'autre événement. Donc, ce que nous allons faire c'est que lorsque
nous activerons un bouton, nous allons
ajouter des éléments à cette carte. Maintenant, pourquoi
allons-nous en ajouter ? Parce que les cartes ont
la propriété unique que lorsque nous ajoutons quelque chose
qui existe déjà, cela met simplement à jour la valeur. Ainsi, lorsque nous
activerons un bouton, nous ajouterons quelque chose. Nous allons ajouter cet
acteur qui existe déjà, et nous allons activer
ses lingots Lorsque nous le supprimons lorsque nous
désactivons le bouton, nous l'ajouterons mais
nous l'activerons. Cela mettra donc à
jour notre valeur. Maintenant, la prochaine étape
serait d'avoir
une branche à laquelle nous nous
connecterons aux deux. Et ici, nous aurons une condition selon laquelle nous
créerons une fonction, mais ne la créons pas encore. La prochaine chose que nous devons faire
est d'obtenir notre plan Dor, par
exemple, un message de déverrouillage
ou un message de journal Et connectez-vous au vrai ou au faux. Parce que si le puzzle est
résolu, nous le débloquons. Si le puzzle est faux,
nous verrouillons la porte. Maintenant, créons la condition. Pour la condition, nous
allons créer une fonction. Nous allons l'appeler puzzle
solve. En fait, le puzzle vient d'être résolu. Pas besoin de point d'interrogation. Je n'aime pas avoir de points d'
interrogation dans les variables ou les fonctions. Et celui-ci
aura une sortie, et elle sera pure parce que nous n'allons pas
définir quelque chose ici. Le résultat serait que les
bullians disent que le puzzle est
également résolu , compilé et sauvegardé et ce que nous allons faire
ici, c'est assez simple Nous allons récupérer les pièces de
notre puzzle. Il existe maintenant deux manières d'
obtenir des valeurs et des clés. Nous appelons le premier kiss, le second value. Nous avons donc reçu le baiser, le baiser, et nous avons obtenu les valeurs,
en fait, juste des valeurs. Comme vous pouvez le voir,
celui-ci reçoit notre baiser, la première partie, et celui-ci reçoit les valeurs, qui
est la deuxième partie. Maintenant, nous allons simplement
obtenir nos valeurs. Et nous allons obtenir
notre mot de passe correct et nous allons
comparer les tableaux Comme vous pouvez le constater, j'ai
choisi l'identique. J'ai appuyé sur égal,
mais
cela donne également l'identique. C'
est ce que nous voulons. Ces deux tableaux, étant donné qu'il
s'agit d'une sortie de tableau, nous voulons qu'ils soient identiques S'ils sont identiques, cela signifie que le
mot de passe est correct. S'ils ne sont pas identiques, cela signifie que le mot de passe est erroné. Compilons et enregistrons,
et en gros,
introduisons la fonction et
connectons-la ici, peu près, c'est
tout le code du gestionnaire. Ce serait ça. Maintenant, continuons
avec le bouton. Je vais compiler
et enregistrer celui-ci. Et avant d'aller en bas, en fait, oui, continuons d'abord
avec le bouton. Appuyons sur le composant
et ajoutons un cube de deux points dont nous aurons besoin pour vérifier
si l'acteur est devant. Amenons-le ici pour ne pas avoir à le redimensionner
en externe Faisons en sorte qu'il soit un peu
plus grand que le bouton. Oui, je pense que c'est
une mince distance, compilez
et sauvegardez. Passons au graphique des événements. Et en fait,
passons au puzzle DR, et nous allons copier
ces événements ici pour qu'ils nous montrent le widget
et activent la saisie. Nous allons revenir
au bouton et
les coller ici. Le widget de mise à jour, nous
allons créer une fonction
correspondante, confirmer, et nous
allons entrer dans cette fonction, compiler et enregistrer. Il a ce problème avec l'
erreur avec le mode de jeu. Nous avons besoin du jeu
dès le début. Allons-y rapidement. Nous allons donc commencer à jouer. En fait, je vais tout
copier, revenir au bouton, y faire face ici et
créer cette variable, et maintenant elle sera compilée. Maintenant, revenons au widget de mise à jour, nous avons en quelque sorte ce
code dans notre foie. Donc, si j'ouvre le foie
et que je vais sur le widget, vous pouvez simplement le copier et
revenir au bouton. Et collez-le ici, connectez-le ici,
et une fois que j'ai résolu, nous allons l'utiliser ou
si vous appuyez dessus ou non. Je vais donc le créer
en tant que variable, et le renommer en EEO Et changez-nous en «
let's » Ou vous savez quoi ? Rendons-le un
peu plus joli. Dupliquons le texte de cette
mise à jour Wigen, et définissons-le
s'il est activé, activez-le Et cela sera activé. Nous savons donc maintenant exactement ce qu'il fait lorsque
nous le pressons. Et n'oublions pas de connecter le
mode de jeu à la troisième personne, de compiler et de sauvegarder. Revenons au graphique pair. Et créons notre entrée
E. Je vais la mettre ici. Il nous faut de la place. Donc je
vais le mettre ici. Il a cliqué E, le voici. Et la première chose dont nous
aurons besoin, c'est le calendrier. Je vais donc ajouter une chronologie. Je vais t'expliquer dans une seconde. Donc, si nous avons
d'
abord besoin de la chronologie , c'est parce que nous devons nous
demander si elle est déjà en cours de diffusion. Je vais donc apporter le composant
chronologique ici. Je vais demander à jouer. Parce que s'il joue déjà, nous ne voulons pas pouvoir appuyer
à nouveau sur le bouton. Je vais donc mettre une branche, la connecter ici,
la mettre ici. Et si c'est faux, cela signifie que l'animation
du bouton est terminée. C'est donc le moment
d'émettre un son. Jouez du son. Et le son que nous
allons jouer est un bouton. Maintenant, la question suivante, la question suivante serait si un bouton est activé ou désactivé. Je vais donc me
connecter ici. Et s'il est activé, je vais le régler pour
qu'il ne soit pas activé. Et si c'est le cas, je vais
le configurer pour qu'il soit activé. Ensuite, je vais le connecter
à la chronologie pour
jouer et inverser. Mais cela nécessite quelques
explications, car
cette chronologie suivra
une trajectoire différente. Laissons ça
pour la prochaine fois, et j'irai vous voir à ce moment-là. Au revoir.
28. Finaliser la porte coulissante du puzzle de boutons avec des plans: Bonjour et bienvenue
sur Unreal Engine Five,
Blueprint Mastery, Door Systems
et les portails interactifs Auparavant, nous avions
créé notre gestionnaire, et nous avions lancé notre bouton. Notre gestionnaire se compose donc d'
une carte de puzzle dans
laquelle, dans une variable, nous avons les boutons
qui doivent être placés dans un ordre spécifique et la seconde variable est un booléen,
que nous activons et
désactivons en l'ajoutant Et nous l'ajoutons
parce qu'en tant que propriété de carte, si nous ajoutons
le même élément, cela change simplement la valeur. Maintenant, nous faisons la même chose
pour supprimer, et non pour supprimer, en désactivant la
deuxième valeur, le booléen, en l'
ajoutant à nouveau, mais en l'ajoutant Dans une fonction
appelée puzzle solve, nous avons obtenu les valeurs de la carte
, nous vérifions s'il s'agit de tableaux, et nous avons vérifié si les tableaux sont identiques au tableau de mots de passe
correct Assurez-vous d'avoir
sélectionné chaque bouton dans le bon ordre lorsque vous les avez ajoutés sur les pièces du puzzle de
la carte. Ensuite, nous avons copié
du code dans notre bouton, essentiellement le comportement de la lorsque nous
surverrouillons
la boîte, nous activons les
entrées, mettons à jour le widget, l'ajoutons à la fenêtre d'affichage et le
supprimons de la fenêtre d' Et nous avons également modifié le widget de
mise à jour pour dire « désactiver » et « activer ». Passons maintenant à notre événement urgent vérifier si la
chronologie fonctionne. S'il ne joue pas, nous
émettons un son et nous activons et désactivons le
bouton. Maintenant, j'ai dit que
cette chronologie avait besoin quelques explications sur les raisons pour lesquelles nous
jouons à partir du jeu et à l'envers. Et pour être honnête, même
si je les avais de cette façon, cela n'aurait pas vraiment d'importance car ce que nous
allons
faire dans le délai imparti, c'est créer un camion de flux qui
part de zéro, monte haut en un, puis revient à zéro. Donc, la première variable
serait zéro, la deuxième variable ,
disons, pour un bouton, disons que le total devrait être d'un quart de
seconde, c'est un bouton. Donc 0,12 quelque part là-bas, 0,12. Disons 0,12, la valeur est un. Et puis à 0,24, la valeur est à nouveau nulle. Transmettons-le à l'écran. Vous voyez, je ne l'ai pas complètement
adapté parce que j'avais sélectionné celui-ci. Donc, pour les adapter à
tous, je
les sélectionne tous, puis je les adapte, et je sélectionne Use last kin frame. Maintenant que nous l'avons
fait monter et descendre, peu importe que
je le joue à l'envers ou depuis le début. C'est important si c' était vraiment le premier, c'est
ce qui compte. La première fois, il
ne faut pas que ce soit l'inverse. Il devrait être en jeu car si c'était la première
fois, il aurait vraiment envie de jouer. Donc oui, la première fois compte, la première fois c'est important
, c'est en jouant. Donc, en cas de chute, nous
l'allumons et nous jouons. maintenant au mouvement, nous
allons nous procurer notre Top mesh, et nous allons l'apporter
ici. Je vais le glisser-déposer. Je vais définir l'emplacement
relatif. Nous allons le séparer. Vérifions l'emplacement. C'est zéro, zéro, zéro, donc si je le déplace de cette façon, -1,6 Je pense que c'est un peu bas. Ça ne montrera pas grand-chose. Alors peut-être au moins
trois moins trois. Oui, je pense que moins
trois, c'est bien. Donc, revenons à zéro, et nous allons nous cacher dans
la direction large De 02 à 0,3. Et pour l'Alpha, nous
allons le connecter. Et maintenant, comme nous avons
cette diapositive ici, cela signifie que nous passons de zéro
à -0,3 et que nous revenons à zéro Maintenant, il faut indiquer au joueur que le
bouton est activé ou éteint. Nous allons donc obtenir le maillage statique, et à la fin, nous
changerons le matériau. Nous allons donc régler matériau et le
connecter pour terminer. Et à partir du matériau, nous
allons sélectionner et la sélection sera basée
sur ISO et si c'est faux, sera le
matériau qu'il possède actuellement, c'
est-à-dire celui-ci. Et si c'est le cas, nous
devons porter un accessoire. Donc, les accessoires sont là. Nous avons donc mis des accessoires sur le vrai
et des accessoires sur le faux. Maintenant, nous allons mettre à
jour notre widget. Donc, il s'allume. Il indique « Allumer ou éteindre ». Et encore une fois, en nous basant sur les choses
seules, revenons-en à nouveau. Nous allons dans une succursale et nous
allons chercher notre directeur, et nous allons activer le bouton
si c'est vrai et le bouton désactiver
si ce n'est pas vrai. Et pour la pièce du puzzle, nous avons besoin d'une référence
à cet acteur. Pour ce faire,
nous allons simplement faire glisser un câble et nous appeler self. Et c'est ainsi que
nous faisons référence à l'acteur qui
fait quelque chose. Il doit se référencer à lui-même. Donc, rétrospectivement, ces
deux événements pourraient être le même. Par exemple, si nous avions un
événement consistant à
ajouter ou à supprimer et qu' ajouter ou à supprimer et au lieu de vérifier
la présence de la pièce du puzzle, nous envoyions un booléen, et ce booléen activé
fonctionnerait tout aussi bien, mais nous n'aurions pas
utilisé la variable map, qui était une belle démonstration Donc, toutes les variables sont également de type v. Je pense que nous pouvons
aller les tester. Alors jouons. Déplaçons
les joueurs en commençant par ici. Et au moins je pense qu'
on peut appuyer sur des boutons. Il s'agit d'éteindre le widget
lorsque nous appuyons dessus Après un peu
d'introspection, je comprends ce qui se passe,
et ce qui se passe, c'est
que nous avons copié la porte. Donc, lorsque j'appelle Lock
and unlock the door, si nous accédons au code des portes, nous supprimons le widget. Cela sera donc réglé
lorsque nous réparerons la porte. Notre bouton est donc à
peu près prêt. Nous appuyons, il passe au vert, nous appuyons
à nouveau, il tourne. Et ne perdons pas de temps. Commençons par la porte. Ouvrons donc le plan de la
porte. En fait, nous n'avons pas besoin
d'un widget dans cette boutique, donc nous n'avons même pas besoin
d'un tube de collision, donc tout ce code peut disparaître. De plus, le
mode de jeu n'est pas nécessaire, mais l'
emplacement relatif n'est pas nécessaire. Nous allons donc également
le supprimer. Créons les variables. En fait, nous n'avons besoin d'
aucune de ces variables. Nous pouvons tous les nettoyer en toute sécurité. Gardons ouvert
l'angle que nous allons renommer. Nous n'en avons pas besoin. Nous n'avons pas besoin de la troisième personne. En gros, nous avons juste besoin de la
porte et de l'angle de la porte, et nous n'avons pas besoin
des fonctions également. Tellement bon en termes de fonctions. Supprimons donc l'animation de la porte et faisons en sorte que l'événement de déverrouillage de la
porte déverrouille la porte, car nous avons copié et supprimé les événements
et la porte verrouillée. Et en gros, nous n'avons pas
besoin de tout ce code également. Nous avons besoin d'une succursale et nous finirons par changer de
position. Nous n'avons pas besoin du widget et nous n'avons pas besoin de l'animation de la
porte. Nous allons donc organiser
ces deux événements, en
conservant la chronologie et le code qui les accompagnent. Maintenant, nous ne nous soucions pas vraiment l'État, car il s'agit d'un
message direct, d'un verrouillage ou d'un déverrouillage. Nous n'aurons pas besoin de cette succursale. Nous garderons celui-ci qui contient le code « Est-ce que la
chronologie joue déjà ? » Apportons-le ici. Et si nous
voulons cette branche c'est parce que si la chronologie
revient à zéro, lorsque nous verrouillons la porte, nous ne devrions pas rejouer l'animation
du verrou. Nous ne devrions même
pas jouer le son. Nous allons donc relier
les forts au son, et je vais le relier
au son, et nous devons choisir un son. Et le son est un tube de porte
coulissante. Nous allons donc le sélectionner. Et bien sûr, pour
le côté verrouillable, nous allons changer
le multiplicateur à 0,8. Lorsque nous débloquons, nous voulons jouer. Et lorsque nous verrouillons, nous voulons faire marche arrière. Il y a du code
ici dont nous n'avons pas besoin. Et déplaçons cela sur
le côté, car nous avons besoin d'espace pour faire
de même, presque même, ou pour la deuxième
partie de la porte. Je vais donc apporter ça ici. Je vais copier-coller
le relatif défini. Je vais connecter ceci
ici, connecter ceci ici. Et je vais dupliquer
le larp, le connecter à Z et également connecter Alpha Et cet angle ouvert, appelons-le déplacement ouvert. Et
apportons-le ici et
connectons-le ici et ici à B. C'est
donc notre objectif. Eh bien, en fait,
l'un d'entre eux
doit être multiplié par moins un. Voyons donc
lequel est lequel. La porte numéro un
est donc la partie inférieure. Cela va donc baisser. Et le déplacement
se fait sentir, non, non. C'est aussi beaucoup. Nous allons donc passer à moins dix parce que cela n'a pas
commencé depuis le début. Donc oui, moins dix au lieu de 124. Donc 130, si j'ajoute 130 plus 130, cela fait 230 plus 130. Non, désolée, je l'ai mal fait. Je dois aller à
la fin et ajouter 130 Oui. Donc, 254. 130 semble être l'
astuce. Alors allons-y. Disons que le déplacement que nous
devons compiler est de 130. Et le second
est le premier. Oui, le premier est celui
qui doit être opposé. Nous le multiplions donc par moins
un pour le rendre négatif, et nous le connectons ici. Je pense que c'est ça et
que nous pouvons aller le tester. Jouons. Mettons d'abord
notre propre manteau. Non Non J'ai fait quelque chose de vraiment bizarre. Donc, pour être honnête, cela a du sens car
les valeurs ne sont pas nulles. Nous n'avons pas réduit ces valeurs à zéro
. Et c'est ma faute. C'était censé
être la porte coulissante, et j'ai ajouté la porte ouverte vers le
haut et vers le bas. Je ne sais pas comment l'expliquer. Je vais donc
supprimer la deuxième partie, et je vais simplement
insérer la bonne porte. Je vais sélectionner la première partie. Et oui, parce que c'
est la porte coulissante. Je vais le sélectionner,
le trouver dans le navigateur et le mettre ici. Fixez également la balance. Maintenant, cela se déplaçait très
lentement parce que nous avions copié à partir de la chronologie de la porte
coulissante, le renversement. C'est donc 5 secondes. Nous pouvons changer ce paramètre à 0,5. Et ce serait tout. Et nous n'avons pas besoin du
deuxième ensemble de portes relatif. Nous le reconnectons donc ici
et supprimons le deuxième larp, ainsi que le déplacement
que nous allons voir maintenant Cela devrait être sur Y, pas sur Z. Nous ne montons pas et ne descendons pas, nous allons à gauche et à
droite, donc ce serait Si c'est à zéro, 00, disons qu'il se déplace ici. Donc moins 140. Mettons donc moins 140 ici, moins 140 et compilons une sauvegarde Allons jouer. Il n'est pas
correctement positionné. Oui, je pense que c'est
bon. Jouons. C'est bon. C'est bon,
ça marche Maintenant, comme vous pouvez le constater,
étant donné que ces deux boutons sont très proches l'un de l'autre, et si je les éjecte et
qu'il y a donc des collisions, lorsque
je quitte celui-ci, j'ai déjà saisi celui-ci, donc il supprime le widget Permettez-moi de vous le démontrer encore une fois. Si je suis ici et que je vais ici, cela supprime un widget et nous ne pouvons pas le voir. Donc, ce que nous pouvons faire, c'est aller
un peu plus loin, peut-être ici, aller
un peu plus loin. Et ça réglerait le problème. Une autre façon de
résoudre ce problème serait de créer un système qui
vérifie cela. Je n'entends pas vraiment de
différence sonore lors du déverrouillage. Peut-être que ce devrait être un tuyau
à point inférieur. C'est beaucoup. Laissons donc 0,7, et je pense que tout ira bien. Et peut-être que la porte devrait
être un peu plus lente. Alors faisons-en une seconde. Je pense que la quantité de son
diffusée doit être égale à la quantité de mouvement de la porte. Oui, peut-être 1.2, mais
laissons les choses telles quelles et nous sommes
prêts pour la pièce suivante. Ce serait la porte
qui se déverrouille avec un objet. Nous ne créerons pas un système d'inventaire
complet. Apportons-le ici aussi. Et nous avons en fait
besoin d'un texte ici. Je vais le copier
ici. Et c'est à peu près bon. Nous allons simplement
changer la taille de la boîte, et définissons-la comme suit. C'est très bien. Et
changeons également le texte pour indiquer que le puzzle ouvre la porte. Et c'est très bien tel quel. Peut-être le frapper deux
fois, le déplacer un peu plus loin. OK, c'est bon. Maintenant, la maison d'à côté
utilisera l'inventaire, et qu'est-ce qu'un
inventaire, en gros ? En gros, c'est une
liste, rien d'autre. Ensuite, vous avez dans cette
liste quelques éléments. Et à partir de ces éléments,
soit vous les affichez dans l'interface utilisateur soit vous les manipulez dans votre jeu
avec d'autres éléments Nous ne créerons pas d'interface utilisateur représentant
cette liste, mais nous saurons si nous
avons l'élément ou non. Nous allons donc quitter ce ballon la prochaine fois.
Je te verrai alors. Au revoir.
29. Créer un système d'inventaire avec des articles à choisir: Bonjour et bienvenue sur les cinq systèmes de portes Blueprint
Mastery
et portails interactifs d'
Area Engine et portails interactifs La dernière fois, nous avons fini avec notre porte à boutons qui
s'ouvre en coulissant. Maintenant, nous avons
créé trois boutons,
et nous avons créé un gestionnaire dans lequel nous stockons les informations
relatives aux boutons. Le responsable détient également
un mot de passe correct. Ainsi, lorsque les boutons sont dans le bon ordre
ou dans le bon état, la porte peut se déverrouiller. En gros, la porte se déverrouille. Quand ils sont faux, ils
recommencent à verrouiller la porte. Continuons maintenant
avec notre inventaire. Comme nous l'avons déjà dit, un
inventaire n'est qu'une liste. Donc, ce que nous allons faire, c'est accéder à notre personnage à la
troisième personne plans de
dossiers
à la
troisième personne, à la troisième personne, et nous allons créer
une nouvelle variable Et nous allons l'
appeler inventor R. Cette variable
sera du type chaîne, et ce sera un tableau. Il existe de nombreuses
règles concernant le type de conteneur que serait
l'inventaire. Mais pour nous, une chaîne suffira car
nous ne donnerons qu'
un identifiant à nos articles. Continuons donc en
créant notre article. Nous allons aller à Blueprints. Nous allons cliquer avec le bouton droit de la souris. Nous allons créer un nouveau
modèle de classe type acteur, acteur classe, et nous
allons l'appeler article BP Je vais l'ouvrir.
Je vais fermer toutes ces choses, nous n'avons pas
besoin du personnage non plus, nous avons juste créé l'inventaire. Nous n'aurons rien d'autre à
faire. Ce serait notre
inventaire, cette liste. Disposer d'une
interface utilisateur pour représenter cette liste constituerait la
partie visuelle de l'inventaire. Mais en plus de cela, il s'
agit essentiellement d'une liste, et cette liste
pourrait fournir des statistiques
sur les objets. Mais nous n'allons pas entrer dans les tableaux de
données et
tout le reste pour le moment. Revenons donc à notre article et
ajoutons ses composants. Donc, tout d'abord, nous allons avoir besoin d'un
maillage statique pour représenter l'article. Nous n'allons pas
le régler pour le moment. La prochaine chose dont nous aurons
besoin, c'est d'une collision de sphères. Maintenant, pourquoi une sphère n'est pas un cube, une boîte ? Parce qu'il est un peu plus facile pour les objets
d'entrer en collision sphérique. Par exemple,
avec des murs contenant Al, le joueur ne
détecte pas le motif. Il existe de nombreuses hypothèses quant à la raison pour laquelle il devrait s'agir d'une
sphère ou non ou d'une boîte. Personnellement, je préfère
une sphère pour les objets. La troisième chose dont nous
aurons besoin
serait un composant de
mouvement rotatif. Lorsque je clique dessus,
nous verrons que cela devient un peu
laissé à la hiérarchie. Si je le ferme, il n'
appartient pas à la racine par défaut. Eh bien, c'est parce qu'
il s'agit d'un composant indépendant, d'un comportement qui
peut être attaché à un plan et que nous pouvons créer nos propres composants de
plan Laisse-moi te montrer très vite. Accédez à la classe Blueprint
et nous pouvons faire d'un plan un composant acteur. Appelons cela mon composant d'
acteur. J'ai appuyé sur espace
au lieu de cela, et modifions mon
c Comme vous pouvez le voir, ces composants sont
des entités distinctes et
n' appartiennent pas à la racine défaillante Ne le supprimez pas car
nous n'en avons pas besoin. Et ici, nous pourrions
avoir un comportement scénarisé pour tous les acteurs Par exemple, le comportement du
widget
aurait pu être tel que nous n'aurions pas à répéter la collision et
tout le reste avec l'acteur En parlant de ça, en
répétant ce code. Ouvrons la
porte à interrupteurs multiples, cela n'a pas vraiment d'importance. Une porte présentant le même
comportement que le widget. Nous allons donc le copier. Nous allons passer à l'article, et nous allons le
coller ici. Je vais créer
une fonction correspondante pour la mise à jour du widget
, que nous allons
simplement remplir dès maintenant. Je vais aller à l'
autre réception ici. Je vais le copier
et le coller ici. La promotion est toujours disponible car il s'agit du mode de jeu à la
troisième personne. Je vais dire ici, choisissez Compile et la boîte doit se
transformer en sphère, hein ? Maintenant, nous avons un problème. C'est une sphère, et
c'est un collisionneur de boîtes. Nous pourrions simplement changer cela. Mais ce que nous allons faire,
c'est simplement entrer cette fonction, la remplacer Box Collider par Actor Component Une référence à un objet. Je vais le déconnecter. Je vais me fier à
une boîte à composants. Je pense que c'est un composant de la boîte. Convertissez-le en
plâtre pur. Mettons une branche. En fait, non.
Gardons-le tel quel. Connectons-le ici, puis je vais le
lancer dans la sphère. La sphère n'est pas répartie comme ça. Composant moulé en sphère. Je vais le mettre en dessous. Donc, si c'est le cas, nous allons le faire. Et je peux le faire aussi ? OK. Nous devons donc le convertir
en un moulage pur. Je vais déconnecter
ces éléments. Je vais le convertir
en plâtre pur. Je vais
également relier cela à un casting pur. Et je vais faire une sélection. Je vais le connecter ici. Donc, si c'est vrai, si c'est faux, nous créons cette branche, et je vais la
connecter ici. Pour en revenir à notre article, nous pouvons connecter la lance Alors, qu'est-ce que je viens de faire en ce moment ? Ce que j'ai fait, c'est aller à notre événement
en plein air. J'ai changé. Restons que la boîte utilise
également un collider. Type du composant de boîte de la collision de boîte au composant d'acteur
général. Puis je suis allée de l'avant et j'ai demandé : Ce composant
est-il une boîte ? » Si c'est une boîte, alors tout va bien, trouvez des acteurs qui
se chevauchent. Si c'est une sphère, alors tout va
bien, il faut que les acteurs se chevauchent. Je pense que c'est un
peu exagéré, mais voyons si cela fonctionne Je vais donc retourner par une porte, où est le tout début. Appuyons sur Play. Cela ne semble pas fonctionner. C'est bon. J'ai donc bien testé. Cela fonctionnait, si je prie maintenant, j'ai juste besoin de recompiler
ces plans Par exemple, j'ai ouvert la porte du foie
et ça n'a pas été compilé. Il y avait un avertissement
parce que les choses avaient changé, mais elles n'ont pas beaucoup changé, mais elles ont également changé. Donc, si nous examinons chaque
plan et que nous le compilons, en fait, nous pouvons simplement
enregistrer tout ce que je pense Nous disons tout, est-ce qu'il compile tout ? Fais un crash. Oui, vous voyez, parce que
cela n'a pas été compilé. Area n'aime vraiment pas
faire ça dans les plans. Ni dans SE Plus Plus
ni dans aucun langage de programmation, vous devez vraiment
compiler des choses. Mais la compilation du Blueprint
est beaucoup plus rapide. Il vous suffit d'appuyer sur le bouton de
compilation et cela se produit instantanément. Mais c'est pourquoi ils
disent également qu' il ne devrait pas y avoir
beaucoup de changements dans le code. Par exemple, lorsque vous avez un code de base, vous ne devriez pas trop le modifier. Je pense que c'est ça. Je crois que
j'ai tout compilé. Génial. Maintenant, je vais fermer
toutes les fenêtres sur la droite. Je vais juste garder l'article. Et corrigeons les autres erreurs. Maintenant, l'autre erreur est
que nous recherchons un chevauchement de cases là où la sphère se chevauche. Je vais donc
cliquer sur la sphère,
accéder aux événements qui se chevauchent, commencer à se chevaucher et à se superposer. Il s'agit essentiellement
des mêmes événements, juste pour la sphère
plutôt que pour la boîte. Je vais donc contrôler et
connecter ces câbles ici. Assurez-vous de
le connecter aux bons composants, un
autre composant et à
rien d'autre. Je vais l'apporter
ici, l'apporter ici, et j'
aurais peut-être dû écrire le code
depuis le début, mais il
faudrait quand même le changer. fait de le remplacer par un composant
général d'acteur
et de passer au
composant lance et au composant boîte
semble donc et de passer au
composant lance et au composant boîte avoir fonctionné Et maintenant, nous pouvons avoir n'importe quel collisionneur
entre les deux, ou nous pouvons l'augmenter ou créer un
système différent ici, ou une étape précédente Maintenant que nous avons
le widget de mise à jour, nous avons besoin d'une dernière partie. Nous avons besoin du mode de jeu. Non, désolé, ce n'est pas ce
mode de jeu et passez à GM. Non, en mode de jeu à la troisième personne,
passez au mode Pure Cast. Et je vais apporter un
setter et régler ça maintenant, allons définir nos mesures
statiques Pour ce faire, nous allons passer à
Construction Script, et nous allons créer un système d'identification de
mini-objets. Appelons cela le système d'identification des articles. Nous aurons donc une nouvelle variable. Nous allons faire en sorte que ce soit une chaîne, et appelons-le item ID. Maintenant, nous allons le rendre modifiable en instance
et l'exposer au moment du spawn Maintenant, nous allons obtenir
notre maillage statique. Nous allons définir maillage
statique car il
ne s'agit pas de ce maillage statique
défini, définir le maillage statique, c'est définir le composant. Nous voulons définir la fonction. Alors pourquoi cette fonction ? Parce qu'il s'agit d'un maillage statique
d'un
composant, nous voulons définir le
maillage de ce composant. Nous allons faire une
sélection de Let's Bring. Nous ne pouvons pas faire de
sélection et de chaîne. Nous allons
donc activer la chaîne. Je vais supprimer cette sélection. Je vais le dupliquer et le
connecter ici. Prenons deux cas, et passons au cas zéro
ici et au cas un ici. Passons maintenant aux mesures statiques sur notre carte. Sélectionnons notre triangle vide
sans col. Je vais également fermer le jeu. Nous n'en avons pas besoin. Il faut que je le
trouve et que je l'ajoute ici. Même chose pour
le triangle suivant. Nous allons le trouver
et l'ajouter ici. Maintenant, préparons les étuis. Je vais donc dire : «
Identifiez-en un ». Je suis arrivé ici en sélectionnant
l'interrupteur sur la chaîne, et le second
indiquera ID deux. Et je vais supprimer
le code PIN par défaut. Cela a été déconnecté
parce que j'ai changé de nom. Notre article correct est donc l'ID 2. Définissons un identifiant par défaut, l'ID un. Et si je compile maintenant
et que je passe à Viewport, nous pouvons voir que nous avons
ce triangle ici et que notre
collision est très faible Augmentons donc la sphère de
collision. Fixons un rayon de
150. C'est peut-être beaucoup. Réglons-le 120100. Oui, 100, ça semble aller. Compilons et sauvegardons, et apportons notre
article à notre monde. Nous avons un article ici
et un article ici. Maintenant, je veux changer cet
article pour qu'il soit le bon. Je vais aller sur ID
ici et sélectionner ID 2. Et voilà, c'est devenu
l'autre objet. Je pense que c'est
suffisant pour celui-ci. Je te
verrai le prochain. Au revoir.
30. Travaux de base pour une porte Sci-Fi nécessitant des éléments clés: Bonjour et bienvenue sur Unreal Engine Five
Blueprint Mastery, Door Systems et portails
interactifs Auparavant, nous avions commencé
à créer nos objets,
puis nous démarrions le mode de jeu
en tant que variable, puis nous avons copié ce code pour le début, le chevauchement et la fin de la boîte et nous
l'avons transformé en sphère. Maintenant, nous avons également modifié la
fonction d'ajout du widget Door en événement. Au lieu d'être un collisionneur de boîtes,
d'être un acteur. Ensuite, nous utilisons ce
composant d'acteur pour le casting afin de vérifier s'il s'agit d'une case ou d' une sphère et d'obtenir les acteurs
qui se chevauchent Ce n'est pas le bon script
de construction. Nous voulons le script de
construction de l'objet. Nous avons créé un identifiant d'article et l'avons changé en fonction
de l'identifiant, en fonction de la chaîne. Et dans le cas de l'ID 1, nous avons défini le maillage statique de
l'article sur le triangle. Et dans le deuxième cas, nous
définissons le maillage
statique sur le triangle qui
a une certaine couleur. Passons maintenant
au code permettant de
l'ajouter à un inventaire. Ce que nous allons faire, c'est
exactement la même chose. Lorsque nous appuierons sur E, nous
interagirons avec cet élément. Nous allons donc
apporter un clavier E. C'est bon. Et ce que nous voulons faire, c'est
que cela n'arrive qu'une seule fois. Donc, le truc que
nous faisons avec la presse, c'est de le faire une seule fois. Et
peu importe la réinitialisation, car nous n'avons pas d'
inventaire complet ou quoi que ce soit d'autre. Nous avons maintenant besoin d'une référence
au joueur. Et pas seulement le joueur, laissez-moi terminer le jeu. Nous n'en avons pas besoin,
non seulement du joueur, mais de l'instance du personnage
qui se trouve dans le monde du modèle à
la troisième personne, du personnage à la
troisième personne. Nous allons donc
passer au volet joueur. Cela nous donne l'instance
actuelle de ce que
le joueur possède. Ensuite, nous allons passer au personnage
à la troisième personne. Donc, en gros, nous sommes en train
de prendre la patte actuelle
et nous nous demandons vous
êtes le personnage à la troisième
personne Comme nous le savons dans notre jeu, ce sera
toujours le cas. Je l'ai converti en purecast et je vais en faire l'inventaire Et voici l'inventaire
actuel du personnage qui
parcourt la carte. Pour ajouter quelque chose ici, nous allons simplement
appuyer sur Ajouter car il s'
agit d'une fonction matricielle, mais elle ne fonctionne pas
comme une annonce cartographique. Dans ce cas, si
un élément partageait l'ID,
il l' ajouterait également en tant qu'
autre entité à cette liste. Donc, si j'avais, genre, deux de l'ID un, alors cette liste serait remplie avec deux
versions de l'ID un. Donc, en gros, ce serait ça. Cela reviendrait à mettre à jour
notre inventaire, et quand nous le ferons, nous détruirons
simplement Actor. Et cela détruirait
l'acteur sur la carte, donc l'objet disparaîtrait. Et c'est tout. C'est-à-dire avoir un article dans son ensemble, récupérer un article que nous allons faire. Allons donc le tester. Allons sur notre carte et
lançons les joueurs. De retour ici, nous pouvons récupérer ceci et
nous pouvons le récupérer. Maintenant, juste pour le démontrer, passons à notre article. Et à partir de là,
avant de détruire, faisons une boucle for. Pour chaque boucle, et
pour le corps de la boucle, nous allons imprimer une chaîne, qui sera l'élément du tableau, c'est-à-dire l'identifiant
que nous venons d'ajouter ici. Je pense que je l'ai fait en silence, mais je pense que tu l'as compris Donc, quand je choisirai le premier article, ce sera le numéro d'identification,
quand je choisirai le second, ce devrait être les deux. Ouais. Notre
inventaire fonctionne donc. Reconnectons-le ici. Supprimons ce débogage, compilons
et enregistrons. Maintenant, pour la porte, nous
allons copier la porte à interrupteurs
multiples. Nous allons passer à la porte à interrupteurs multiples Blueprint
Doors, et nous allons dupliquer Et appelons-le point D. accord. Eh bien, peut-être que Item
Door n'est pas un bon nom. Appelons-la porte clé
car elle nécessite un objet. Considérons cet article comme une clé. Donc, porte clé. Amenons également
la porte à clés
sur le niveau. Et ouvrons-le. Maintenant, cette fois, je vais
utiliser la bonne porte, celle que nous voulions. Je voulais l'utiliser auparavant, c'
est-à-dire cette partie ici. Je pense que la
partie inférieure devrait en être une. En fait, la
partie supérieure devrait en être une. Alors trouvez-le et placez-le ici et je vais également
réinitialiser son emplacement. Et je vais
sélectionner le suivant, trouver et le dupliquer, Control C, Control V, et le configurer ici. Alors maintenant, je vais également corriger les
rotations. C'est bon. En fait, non, les
rotations étaient correctes. Voici la flèche ici. Voici donc la face avant. Je vais donc
en parler ici. Déplacez-le un peu de cette
façon et corrigez également ce problème. Je pense que celui-ci, oh, non, nous avons le comportement
du widget. C'est bon. Compilez et enregistrez. Mettons à jour notre chronologie
d'animation pour inclure la deuxième porte. Je vais donc le déplacer
ici. C'est assez facile. Lorsque vous en avez
la main, qu'est-ce qui fait quoi, qu' est-ce qui est où, il est plus facile de manipuler le code et d'
ajouter des éléments à supprimer. Nous allons donc dupliquer défini pour
la rotation emplacement défini pour
la rotation, car ce
sont des poupées en mouvement. Ce ne sont pas des poupées rotatives. Et je vais amener la
deuxième porte ici. Et nous avons à nouveau besoin de ce
nœud larp pour l'axe défini. Nous devons le
connecter à Alpha. Et pour les valeurs, nous avons ici un
emplacement relatif. Supprimons-le simplement. Ce n'est pas nécessaire.
Commençons donc à jouer, supprimons également cette
variable et les puzzles,
nous n'en avons pas besoin. Et l'angle ouvert,
nous n'en avons pas besoin. Cette variable, je pense qu'
elle n'est pas nécessaire. Oui, ça ne l'était pas. Si c'était le cas, il le dirait, et
ce serait tout. Mettons le terrain en mode verrouillé et revenons
aux valeurs. Donc des valeurs. Celui-ci commence par
arrondissons-les à 51 25. Et celui-ci est, encore une fois,
au 51 25. OK, ils sont un peu
étirés. Alors réglons ce problème. C'est bon. C'est donc 115. Est-ce la bonne
? Il en fera 115. Cela fera l'affaire. OK,
donc on commence 51 15. Voici donc la porte numéro deux. Cela va de 50, et celui-ci est de 115. Et le suivant est 51 25. Encore une fois, Y 50, et a serait 125. Maintenant, pour ce qui est de leur
destination, celui-ci passe à 20. Donc 20, et celui du bas passe à moins quatre moins cinq. Moins cinq. Génial. Notre animation est terminée. La prochaine chose que nous allons faire
est d'effacer le code, car cette porte ne se déverrouille pas ou ne se
verrouille pas depuis un autre endroit. Nous allons à nouveau utiliser la touche E pour vérifier
si le joueur a la clé. Nous n'avons donc pas besoin des
puzzles pour obtenir des réponses, et nous n'avions pas besoin de
ces deux fonctions, ni ces deux événements également. Les événements que je viens de supprimer étaient la porte verrouillée par
l'événement et la porte déverrouillée par l'événement, qui proviennent de
l'interface que nous avons copiée et de la fonction Check
Puzzles D'accord. Nous sommes donc prêts
à commencer à coder. Mais je pense que c'est quelque chose
pour la prochaine leçon. Je vais le
laisser ici pour le moment. Au revoir.
31. Verrouillage et déverrouillage des portes avec un système basé sur des articles: Bonjour et bienvenue
sur Unreal Engine Five,
Blueprint Mastery, Door Systems
et Interactive portal Auparavant, nous avions terminé
l'animation de notre porte. Nous avons ajouté le nouveau maillage statique. Nous avons défini
les numéros à définir, et nous avons également effacé le code de la porte à clé parce que nous
l'avons copié à partir de la porte à interrupteurs multiples. Maintenant, continuons
avec la presse E. Nous allons
donc passer au clavier E et commencer à programmer. La première chose à faire est vérifier si notre porte est verrouillée. Je vais donc apporter une succursale. Je vais
le connecter ici. Je vais vérifier l'état de la porte et vérifier si l'IAM est
égal à verrouillé Si ce n'est pas le cas, nous allons
animer la porte. Nous appelons donc Door Animation. Maintenant, si ce n'est pas le
cas, s'il est verrouillé, nous devons vérifier
le mécanisme de verrouillage. Créons donc un événement
client. Et nommez-le mécanisme de verrouillage
que nous allons appeler ici. Et notre E est complet. Maintenant, programmons
le mécanisme de verrouillage. Ce dont nous avons besoin en premier, c'est d'une nouvelle fonction qui
aura une sortie booléenne Et appelons cela une clé liée. Dans cette fonction,
nous allons passer à la patte de
couche et passer à
nouveau à la troisième personne, afin d'obtenir notre inventaire actuel Nous allons faire l'
inventaire auprès de nos acteurs. Maintenant, avec les tableaux, à l'exception de AD, nous avons un autre
nœud spécial appelé point, qui peut trouver un élément, un élément du tableau dans le tableau et renvoyer
l'index de cet élément Quel sera l'
objet. Nous allons promouvoir ces deux variables. Nous allons appeler
cet article obligatoire. Nous allons le
rendre modifiable par instance. Nous allons également l'exposer sur Span,
le
compiler et le sauvegarder, et
si j'apporte une branche,
nous avons besoin d'un lingot d'une manière ou Nous avons besoin d'un vrai ou d'un faux. La question serait
donc de savoir si l'indice
est supérieur
ou égal à zéro ? Parce que si c'est
dans les négatifs, cela signifie qu'il ne l'a pas trouvé S'il passe à moins un, cela signifie que l'article est introuvable. Et je vais relier
cette condition ici. Si l'article est trouvé, je vais le supprimer
de l'index de suppression. Maintenant, assurez-vous de choisir
l'index de suppression et non l'élément de suppression car les deux fonctionnent
complètement différemment. Comme vous pouvez le constater, cela supprime toutes les instances d'
un élément du tableau, ce qui supprime simplement
l'index que nous appelons. Je vais relier
cela à la vérité. Et maintenant, nous avons un nœud de retour. Comment s'y prend-on ? Eh bien, nous
pouvons avoir deux nœuds de retour. C'est la magie, et nous le
connectons ici et
nous disons que la clé est trouvée, et nous pouvons la connecter ici
et dire que la clé est introuvable. Et bien sûr, connectez
l'index ici. Comment dupliquer cela, je contrôle le copier-coller contrôlé en
C. Donc, en gros,
copions-collons ces deux
éléments ici dans Pure Cast. Nous n'avons donc pas
beaucoup de câbles croisés, et cela peut être un
peu plus logique. Maintenant, que devons-nous faire ? Nous récupérons l'inventaire, nous vérifions
si nous pouvons trouver l'article. Si nous n'y arrivons pas, nous revenons,
nous n'avons trouvé aucune clé. Si c'est le cas, nous l'
enlevons et nous indiquons
que nous avons trouvé une clé. Et nommons cette
fonction, chèque ou clé. Et passons à notre
mécanisme de verrouillage. Ensuite, nous avons besoin d'une succursale. Si nous trouvions une
clé et que nous la retirions, nous devrions régler l'
état de la porte pour qu'elle soit fermée ou verrouillée. Nous devrions mettre à jour le widget, mais nous n'avons pas défini les textes, et nous avons besoin d'une variable indiquant
verrouillée et la définissant sur false. En fait, nous n'avons pas besoin de cette variable. Je ne sais pas pourquoi nous en avons
besoin. Il n'y en a pas besoin. Nous avons l'État. Et en parlant
d'état et de widget, allons corriger la mise à jour de notre widget. Et nous avons besoin de l'état de la porte. Nous avons besoin d'un interrupteur. Et nous n'avons pas besoin de cette sélection. Nous allons simplement le copier trois
fois lorsqu'il est verrouillé, il sera indiqué verrouillé. Lorsqu'il est fermé,
il indiquera ouvert. Et quand il est ouvert,
il indique « fermer ». En fait,
allons-y pour la quatrième fois. Cela ne dirait rien. Donc, dans le pire des cas, nous voyons ce E. Nous savons donc qu'il est bloqué lors de l'
ouverture et de la fermeture Vous voyez, des choses comme
ça ne sont que quelques nœuds, gros, un nœud supplémentaire. Mais lorsque vous
jouez et que vous voyez un bogue que vous avez
conçu pour être bogué, exemple, un
widget s'affiche alors qu'il s'ouvre Pourquoi ? Et cela
indique clairement quel est le défaut. Il est donc toujours bon d'avoir quelques conseils
de debug pour vous. Maintenant, continuons, nous devons montrer
au joueur que la
porte a été déverrouillée Faisons-le simplement en
ajoutant un endroit ici. Ne parlons pas du son débloqué. Je n'aime pas vraiment
le son débloqué. Je veux dire, c'est
une sorte de son clé. Alors peut-être que les boutons sonnent. Utilisons le son du bouton. Nous avons donc un moyen de dire au joueur que la
porte a été déverrouillée Il devrait réessayer et
cette fois, il s'ouvrira. Maintenant, lorsque nous sommes en chute, nous devrions claquer la porte,
mais cette porte ne peut pas
vraiment Il est très mal placé. C'était quoi ça ? D'après ce que j'ai vu, il
faut passer au 115. C'est bon. Mettons tout
cela correctement en place. Hein ? La porte ne
semble pas étroite. Je veux dire, il y a peut-être ces
endroits d'où tirer. Je ne sais pas.
Nous le plaçons donc ici. Nous sommes en train de le
déverrouiller avec notre clé. Nous devrions émettre un son
ici, ce ne devrait pas être un ascenseur. Ça devrait être la porte de science-fiction. C'est ici. Donc une porte de
science-fiction par ici, porte
Sif par ici. Et pour les vêtements,
multiplicateur 0,8 pitch. C'est bon. C'est bon. Maintenant, revenons au hochet. Cette porte ne
claque pas en fait. Cette porte devrait faire autre
chose et nous allons
changer cette couleur et
émettre probablement un son. Mais laissons ça
pour la prochaine fois. Nous allons
vous voir alors. Au revoir.
32. Ajouter des effets visuels pour améliorer les interactions entre portes de science-fiction: Bonjour et bienvenue sur Unreal Engine Five
Blueprint Mastery, Door Systems et portails
interactifs Auparavant, nous avions fini avec le code pour vérifier si notre porte est verrouillée ou non en utilisant
la touche E et une branche. Et si elle est verrouillée, nous
déclenchons le mécanisme de verrouillage, et si ce n'est pas le cas, nous
déclenchons l'animation de la porte. Maintenant, pour notre mécanisme de verrouillage, nous avons utilisé une vérification du fonctionnement des touches qui
nous permet d'obtenir l'
inventaire du joueur. Nous sommes en train de déterminer
s'il existe l'article requis, et si c'est le cas, nous le retirons
de l'inventaire. Si ce n'est pas le cas, nous déclarons
que nous n'avons pas trouvé de clé, et nous avons trouvé la clé si nous l'avons trouvée. Ensuite, nous avons créé une succursale, et sur cette base, nous avons utilisé
la porte restée proche. Nous avons mis à jour le widget, et nous avons émis un son
pour indiquer au joueur que
la porte avait été déverrouillée Et nous avons parlé de la création de
notre nouveau mécanisme de hochet. Appelons cela un
événement personnalisé et appelons-le un hochet, qui ne sera pas un hochet, mais ce sera intéressant Maintenant, quelle sera la partie
intéressante ? Ce qui est intéressant, c'est que nous utiliserons un nouveau nœud appelé D N et il est un
peu difficile à trouver. Je crois que je l'ai passé, ici, cette opération N. Comme nous l'
avons fait une fois, s'agit d'un nœud qui permet à
l'exécution de passer un certain nombre
de fois, puis elle s'arrête. Cela est utile pour
limiter le nombre de fois qu'une action peut se produire pendant
le jeu, par exemple. heure actuelle,
pour notre hochet ,
nous allons changer
le matériau de la porte quatre fois nous allons changer
le matériau de la porte Je vais obtenir les deux pour obtenir
du En fait, du matériel fixe,
du matériel, matériaux,
les connecter tous les deux ici et faire une sélection à partir d'ici
parmi le matériau. Qu'est-ce que je vais utiliser comme index ? Eh bien, je vais
utiliser un nœud flip lock, et sélectionner le nœud est A. Ensuite, je vais
connecter les deux ici parce que je veux l'exécution de la
bascule soit la même Je veux juste faire la différence
entre A et B. Quand ça part de A et
quand ça part de B. Et pour le matériau
des plis, nous voulons le matériau d'origine, donc ce sera la porte
verticale, verticale. Et puis je suppose que ce
sera la porte verticale. rouge. Ouaip. Maintenant, si je connecte cette
tongs directement au D N, cela se produira si vite
que je ne pourrai pas la voir Je vais donc
mettre un délai ici. Peut-être un peu plus de place et associez le delay
à la tongs. Maintenant, pour ce qui
est du délai, 0,2 est un peu
élevé, je vais donc le passer à 0,1. Pour appeler à nouveau le D N, je vais appeler Rattle On appelle donc le hochet ici. Il fonctionne et s'appelle lui-même, et il fonctionnera quatre fois
au total. Maintenant, comme un joueur
peut l'essayer plusieurs fois, nous devons le réinitialiser. Je vais donc créer un
événement personnalisé et l'appeler reset. Fais du hochet. Et nous procéderons à
une réinitialisation à chaque fois que le joueur essaiera
d'ouvrir la porte Alors réinitialisez, faites du cliquetis. Jouons un son
également une fois que nous avons commencé à vibrer,
jouons-le ici Play Sound to D. Et le son serait refusé. Oui, autorisation refusée. Jouons. C'est bon. Nous avons un problème
avec les widgets, mais je pense que c'est parce que
tous se chevauchent Je vais donc m'étendre un
peu plus loin, peut-être ici. Oui, ça marche bien, je
reçois le mauvais
article, ça ne marche pas, reçois le bon article Cela ne fonctionne toujours pas. Et c'est parce que nous n'avons pas donné à la porte l'objet requis. L'ID deux est donc l'élément requis. Choisissons-nous le mauvais
. Cela ne fonctionne pas. Trouvons le bon
. Elle s'ouvre. Génial. C'est un peu lent. C'est la
porte la plus lente jamais créée. J'ai fermé lentement.
Alors réglons ce problème. Passons à notre chronologie. Et réglons ça sur,
je ne sais pas, 1 seconde. En utilisant la dernière image-clé, tout va bien. Et changeons également le matériau de la porte
lorsque nous la déverrouillons Rendons-le vert.
Je vais donc aller à notre open
ici, nous jouons du son. La porte est déverrouillée
et récupérez la partie supérieure. Celui-ci a mis du matériel. Cela pourrait être ouvert verticalement. Compilez et enregistrez.
Que s'est-il passé là-bas ? Je pense que ça doit être Loaden
Shader ou quelque chose comme ça. C'est donc ouvert. Il ferme. Quand il finit de s'ouvrir, il ne m'affiche pas le widget. Quand elle s'ouvre et que tout va
bien, passons à la porte à clé. Mettez à jour le texte du widget,
la porte lorsqu'elle est fermée. Je le suis, je ne me chevauche pas. OK, c'est donc le problème. Le code est correct.
Il est là. C'est juste que la boîte
est un peu petite. En fait, je vais le
changer à partir d'ici. Oui, je pense que c'est bon. Donc, je récupère la clé. C'est bon. Non, le widget ne s'affiche
toujours pas lorsque la porte est fermée ou ouverte. OK. Je vais donc simplement
le connecter ici. Et ils ajoutent tous les
deux le widget de porte. Je veux voir le
négatif encore une fois. Ah, j'aime vraiment le négatif. C'est vrai. Cela fonctionne
correctement. Génial. Et maintenant, nous nous heurtons à un mur de briques. Je suppose donc que c'est le moment de passer
à la porte de téléportation, nous utiliserons dans ce
super téléporteur, qui a aussi de la colle pour les fêtes Pour ce faire, nous allons
créer un nouveau plan. Passons aux portes des dossiers. Créons une nouvelle
classe d'acteurs et appelons-la téléporteur BP Compilons et sauvegardons, et commençons par ajouter les composants
du téléporteur Bien entendu, nous aurons
besoin d'une boîte de collision. La collision de boîtes en
serait donc un élément. Nous aurons besoin d'un maillage statique
pour notre maillage de téléporteur, et nous aurons besoin d'une particule Je pense que c'est une particule de Niagara. Ici, c'est un composant du Niagara. Ajoutez un système Niagara. Et nous avons également besoin d'une flèche. Maintenant, sélectionnons notre maillage qui sera le maillage du
téléporteur Lions-le et
installons-le ici. Et nous devons le faire
pivoter, non ? Et pour le partigi Niagara, nous allons
sélectionner le partige Nous allons aussi le trouver
et l'ajouter ici. Maintenant, faisons pivoter ça
Oui. Je pense que c'est ça. Et notre boîte devrait être un
peu plus grande et plus large, un peu plus à l'avant. Ouaip. C'est très bien. Et amenons
notre téléporteur sur la carte Hein ? Et rendons également visible la pièce
suivante. Peut-être le déplacer un peu ici. Et dupliquons-le également ici et faisons-le pivoter dans le bon sens. Il y a une raison à cela pour laquelle il doit faire face
de la bonne façon. Mais nous allons continuer
avec cela lors de la prochaine leçon, et c'est là que nous
allons en rester cette fois. Au revoir,
à la prochaine.
33. Créer un téléporteur pour les transitions de niveau dans les limites: Bonjour et bienvenue
sur Unreal Lensing, cinq systèmes
de portes
Blueprint Mastery Auparavant, nous avions terminé avec
notre porte nécessitant une clé, et nous avons démarré notre téléporteur Nous avons ajouté quelques
composants et maillages, ainsi que la
particule de Niagara et la boîte de collision. Continuons la
programmation du téléporteur. Nous allons utiliser l' événement
de
début de superposition de la collision, et nous allons choisir
deux personnages à la troisième personne parce que seul notre
personnage doit se déplacer, et nous voulons également une référence
au personnage. Maintenant, comment déplacer notre
personnage d'ici à ici, où nous pourrions définir la
position de l'acteur Mais il existe une
note spéciale appelée téléportation. Dans Unreal Engine,
il nous donne deux entrées, destination et emplacement de
destination et la rotation de la
destination, ce qui est une bonne chose car
lorsque nous nous téléportons, nous voulons faire pivoter le
personnage d'une certaine manière Il ne se téléporte donc pas
et ne regarde pas en arrière, par
exemple en direction de la porte
du téléporteur Mais avant de
déterminer où cela devrait être,
émettons également un son, qui serait le son de
téléportation Nous avons ce son, mais
j'aime beaucoup celui-ci, le son de téléportation VR Maintenant, cela est inclus dans le
moteur au cas où vous ne le verriez
pas dans votre
tiroir de contenu dans les paramètres, vous pouvez activer le contenu du moteur. Afficher le contenu du moteur quelque part. Je n'ai pas cliqué dessus, mais cela devrait le
rendre visible. Passons maintenant à notre position de destination
et à
notre rotation des destinations. Ce que nous allons utiliser pour cela ,
c'est
créer un système
ici en utilisant une scène ,
donc nous allons ajouter une
scène. Qu'est-ce qu'une scène ? En gros, c'est juste un point. Nous parlons donc ce point où nous pouvons nous
déplacer vers la gauche tout en haut, et nous pouvons créer une référence
à ce point parce que nous l'
appelons la racine de la
capsule de téléportation Ce sera la racine de la capsule de
téléportation, et nous pouvons faire en sorte que nous puissions la
référencer là où elle se trouve, là où elle est tournée vers
deux et Mais nous n'allons pas
nous contenter de cela. Nous allons ajouter une collision de
capsules. Cela sera transmis
sur place. Ainsi, chaque fois que nous déplaçons la scène, nous déplaçons également la collision. Comme il n'est pas ajouté
au bon endroit, nous allons simplement
réinitialiser son emplacement, transformer, et il s'
accrochera à la racine. Maintenant, nous allons également l'
augmenter pour qu'il corresponde à la taille du joueur. Je pense que c'est le joueur que je ne
me souviens de rien à voir. Je vais ouvrir le
lecteur, sélectionner la capsule. Oui, demi-taille des années 90. 90 correspond à la moitié de la taille et le rayon est 35. Ça va être mince. Donc 35 rayons. Et pour le moment, nous
savons exactement où apparaîtra la capsule du joueur. Et ajoutons également une flèche. Je vais sélectionner à
nouveau le
composant racine car je ne veux pas
qu'il soit ajouté à la capsule. Je veux qu'il soit ajouté
au composant racine, flèche
et qu'il
réinitialise également sa position. Maintenant, nous pouvons voir clairement où se trouve le joueur et vers quoi
il regarde. Je vais donc le mettre
ici. Peut-être que c'est ici plus à l'avant. Je pense que ça
sort et qu'il tombe ici. Ouaip. Peut-être plus dans les airs. C'est bon. Continuons. Maintenant, nous ne voulons pas que nous soyons des
capsules et des racines. Nous voulons les cibles, capsule et le composant racinaire. Donc, ce que nous allons faire, c'est créer
une autre variable, nous allons l'appeler
target, le port, le et nous allons l'exposer et la rendre extensible lors du
spawn, également modifiable, et elle sera du
type de téléporteur P. Nous allons compiler, enregistrer
et accéder à Teporter à partir des détails, nous allons sélectionner
l'autre téléporteur, et pour l'autre téléporteur, nous allons faire de
même avec celui-ci C'est peut-être un
peu loin. Je vais donc sélectionner la racine. Oui, je pense que c'est
une bonne distance. Et maintenant, dans notre
journaliste sur le BPA, compilons. Et pour la destination, nous
allons utiliser ce reporter
cible. Je vais obtenir Arrow parce
que c'est ce dont nous avons besoin. Pour être honnête, nous n'avons pas besoin de la capsule
ou des spots. Arrow fera le job. Assurez-vous qu'il s'agit de la flèche
1, car la flèche est utilisée pour le plan
d'origine Nous allons donc passer à Transform. Mais nous allons transformer le monde parce que nous voulons qu'il soit situé dans le monde et en rotation. Cette fois, nous n'utilisons pas la localisation relative
locale ou la rotation parce que nous ne voulons pas qu'elle soit
relative au plan Nous voulons que cela soit
relatif au monde. Ainsi, par exemple,
si je vais ici et sélectionne ce téléporteur, que je
sélectionne la racine et que je la fais pivoter, je veux qu'il soit
pivoté vers ici, fonction du monde, et non vers ici, en
fonction du plan Maintenant, qu'est-ce que la transformation ? Eh bien, une transformation est essentiellement une
structure d'éléments de
trois vecteurs. Et si je le casse, nous pouvons voir qu'il
a un emplacement, une rotation et une échelle. Je vais donc relier
l'emplacement à
l'emplacement de destination et la rotation à la rotation de
destination. Et c'est ainsi que se terminera
notre portail télévisé. Apportons notre
capsule ici. Appuyons sur Play. Et
nous sommes en train de nous téléporter. C'est bon. Je pense que c'
est tout pour celui-ci. Je te verrai bientôt. Au revoir.
34. Concevoir une porte basée sur la physique avec la programmation Blueprint: Bonjour et bienvenue
sur Unreal Engine, cinq systèmes de portes
Blueprint Mastery
et portails interactifs Auparavant, nous en avions fini
avec la porte de notre téléporteur. Nous avons créé un système à l'aide d'une capsule, d'un composant root
sin et d'une flèche. En fait, nous n'
avions besoin que de la flèche, mais nous avons la capsule
qui permet de voir la collision entre notre joueur et le
composant racine pour le déplacer. Maintenant, nous utilisons cette flèche pour obtenir la transformation
que nous avons appliquée aux trois vecteurs et utilisons
l'emplacement et la rotation pour utiliser le nœud de téléportation comme destination et destination de
rotation Ensuite, nous jouons le son. Et tout cela a été déclenché
par le chevauchement du boîtier du téléporteur.
C'est à peu près ça. Il est maintenant temps de créer
le magasin de physique. Nous allons ouvrir la porte de
nos dossiers. Nous allons cliquer avec le bouton droit de la souris.
Nous allons créer une nouvelle
classe de modèle de type acteur. Je vais l'appeler
PP Physics Door. Et nous allons l'ouvrir. Maintenant, pour ce plan, nous allons avoir besoin de
deux maillages statiques Et sélectionnons le message. En fait, il n'en est qu'un. Il va remplir les deux, et nous allons simplement
alterner l'un d'entre eux. Et déplace-le un peu. Ces portes
ne doivent pas se toucher. Déplaçons-les un peu au centre du plan Ils devraient avoir un
écart entre eux parce que comme ils
vont être un magasin de physique, ils se toucheront
s'ils se touchent Maintenant, compilons et sauvegardons, et faisons découvrir notre
acteur au monde. Je pense qu'il faut le
déplacer un peu quelque part
ici. C'est bon. La prochaine chose que nous allons faire est d'activer la physique
pour ces objets. Je vais donc les
sélectionner tous les deux. Je vais aller dans
l'onglet physique. Où est la physique ici et sélectionnez
simuler la physique. Mais cela ne nous aidera pas beaucoup, car
si je joue maintenant, nous pouvons les voir se
balader. Cela ne l'est pas du tout.
Ce ne sont que des gravats. C'est donc ce que nous voulons. Heureusement, il existe ce que
l'on appelle la physique. Contrainte, c'est ce que
nous allons utiliser maintenant. L'embout de l'outil indique qu'
il s'agit en fait d'un joint qui
permet de relier deux corps
rigides ensemble. Vous pouvez créer
différents types de joints à l'aide des différents
paramètres de ce composant. OK, le mot clé ici, c'est qu'il crée quelque chose comme
un joint, comme une charnière Cela nous permet de contrôler la rotation et les limites de
mouvement, comme les
bras mécaniques, par exemple, ou le comportement des poupées de chiffon
à un niveau plus avancé Mais pour nous, nous allons
simplement l'utiliser pour fixer les limites afin de
créer une porte dynamique. Continuons donc avec la question de savoir
comment utiliser les contraintes physiques ? Tout d'abord, nous
devons nommer les portes. Ensuite, nous aurons besoin de
deux contraintes physiques. Nous allons donc en avoir un. Ajoutons une flèche. Nous savons donc où se trouve le front. OK, le début du
plan est comme ça, mais ça ne nous
intéresse vraiment pas Nous allons simplement faire
pivoter la flèche et dissocier
du maillage statique Il suffit de le
faire pivoter. D'accord. Et appelez cette porte
et celle-ci DR. Donc, ce serait la contrainte L, et celle-ci serait contrainte Et compilez, ils sont
dans l'ordre opposé , mais peu importe. Ce que nous allons faire, c'est sélectionner la première contrainte de
visite. Et je vais aller dans
les paramètres et dire le nom du composant 1. Ici, nous allons
utiliser la porte L. Assurez-vous que cette porte L est exactement la
même que celle-ci. Pas d'espaces supplémentaires, les majuscules
peuvent être importantes. Je ne suis pas vraiment sûr parce que si ce n'est pas le cas, cela ne marchera pas. Maintenant, comme vous pouvez le constater, elle a déjà pris
la forme de notre porte. En gros, il nous montre
les limites du maillage, mais il nous montre aussi, avec cette ligne,
où se trouve notre pivot Nous allons donc passer à
ce coin de la rue, et c'est notre pivot. La prochaine chose que nous voyons, ce sont les cercles ronds
autour du point de pivot. Que nous devrions aller un
peu plus loin ici. D'accord. Maintenant, quels
sont ces cercles ? Eh bien, allons-y ci-dessous et nous
verrons quelques limites angulaires. Maintenant, pour nous, nous n'avons
besoin que d'un seul mouvement, nous bloquerons
donc le second, et nous bloquerons la torsion. De plus, nous voulons que ce
soit uniquement sur cette rotation, et nous allons définir la
première rotation avec une limite, et la limite serait de 90
45, c'est un peu petit. Et vous pouvez voir que cela nous montre
les limites de la rotation. Maintenant, nous allons
faire de même pour Dor R. Passons à un de ces sujets par ici. Passons au nom R. Réglons ce paramètre sur verrouillé, et celui-ci est limité à 90. Mais c'est le contraire. Nous devons le faire pivoter. Ops. D'accord. Et faisons-le
pivoter de 180°. Allons donc le tester. Ça ne marchera pas parfaitement, mais c'est un bon début. Ramenons ici nos proches, nous sommes en train de passer, et la porte se
retourne comme des fous Maintenant, il existe de nombreuses
options pour résoudre ce problème. Nous jouerons avec
quelques réglages simples. Par exemple, nous
devons d'abord corriger un paramètre. Ici, je vais
sélectionner les deux. Nous avons le moteur angulaire, que nous avons le moteur d'entraînement
angulaire. Il utilise actuellement le slurp,
qui est, comme il le décrit, une
alerte entre le courant, la vitesse
et l'orientation de la
cible Mais ce que nous voulons, c'est
un rebondissement qui décomposera un peu
le chemin La prochaine chose que nous
allons faire est de sélectionner chacune des portes et d'accéder
aux paramètres physiques, et nous activerons la masse. Nous allons leur faire une masse de 80. Vous pouvez jouer
avec les valeurs, et nous augmenterons également l'amortissement
angulaire J'espère que cela corrigera A avec le balancement. C'est bon. Maintenant, le seul problème, c'est qu'
ils sont laissés comme ça. Ils ne retournent pas à
leur position initiale. Cela aurait donc dû être
corrigé par le swing and twist. Mais oui, j'ai probablement oublié que je n'ai pas cliqué sur
l'option swing, donc elle n'a pas d'orientation
cible, car le swing
et la torsion
lui confèrent une orientation cible. Cela signifie où est-ce que j'
essaie de retourner ? Nous pourrions jouer avec
la vitesse de la cible et tout le reste, mais c'est ce dont nous avons besoin
pour qu'elle revienne dans
la même position. Je vais donc compiler, enregistrer
et appuyer sur Play. Quand il s'ouvre et revient
à la même position. Maintenant, vous pouvez jouer un
peu, mais les valeurs le rendent plus réaliste. Je ne sais pas Lorsqu'
il y a deux portes ,
cela dépend également un peu de la vitesse du
joueur. Ports, mais je pense que c'est bon. Une porte, c'est trop facile. Non, une porte c'est bien, deux portes c'est un
peu trop dur. Ce sera donc pour
le magasin de physique. Nous vous verrons lors de
la prochaine leçon où nous ferons la téléportation
vers un autre niveau Au revoir pour le moment.
35. Programmation d'une porte de changement de niveau avec des effets de transition: Bonjour et bienvenue sur les cinq systèmes
de portes
Blueprint Mastery
et portails interactifs d'Unreal Lenzing systèmes
de portes
Blueprint Mastery
et Auparavant, nous en avions presque terminé
avec notre magasin de physique. Il semblerait que j'ai oublié
d'ajouter les sons. Ouvrons le magasin de physique, et c'était une bonne occasion montrer un autre événement de collision. Cette fois, parce que cette porte ne se chevauche pas vraiment
avec le joueur. Je bloque le joueur. Nous
utiliserons la chaleur des composants. Je reçois donc
la chaleur des composants par cette porte, et je reçois la
chaleur des composants par l'autre porte, et nous allons juste
émettre du son. Et connectez les deux pour afficher le
son et pour le son, nous allons utiliser
le point physique Q. Et nous allons rejouer
avec la tonalité. Nous allons faire une plage flottante
aléatoire,
comprise entre 0,8
et un. Et maintenant, nous avons un son horrible parce
qu'il sonne trop souvent. Je pense donc que ce son nécessite des paramètres de
simultanéité. Que sont les
paramètres de simultanéité ? Ils sont ici. Il s'agit d'un paramètre qui contrôle le
nombre d'instances
du son pouvant être jouées
simultanément et qui nous permet de limiter ou de
gérer les sons qui se chevauchent De plus, lorsqu'un son
peut démarrer et s'arrêter, et qu'il y a beaucoup
de paramètres avec lesquels jouer, mais c'est ce que nous utiliserons principalement. Je vais donc aller dans
le dossier sons, et je vais le créer Il semblerait que nous les ayons
déjà créés. Voici donc Physis do C qui a
déjà quelques réglages prédéfinis pour nous Comptez au maximum combien de
fois il doit être joué. Re : heure de déclenchement à laquelle
il doit rejouer, limite au propriétaire, comme
limite au propriétaire. Cela signifie le plan qui le
joue, en gros. Donc, si vous aviez deux plans,
il ne
semble pas que le nombre maximum d'un ne serait pas le même Ils émettaient deux
fois plus de sons. Oui, il y a beaucoup
de réglages ici. C'est ce que nous allons utiliser. Donc, si je l'ajoute
ici, tout de suite, oui. Le son est bien meilleur. Maintenant, une autre chose
que j'ai remarquée, c'est que je n'ai jamais vraiment
expliqué et que je
n'ai jamais utilisé le
composant de rotation des objets. Cela fonctionne, mais si nous
jouons et montrons des collisions, vous remarquerez que
la collision
se déplace également, ce qui n'
est pas un gros problème pour le moment , mais
si nous en avions plusieurs,
cela créerait un
énorme manque de cadre. Ce que nous allons faire, c'est saisir le plan de l'objet, passer au script de construction et obtenir
le mouvement de rotation qu'il est. Expliquons-le
puisque nous ne l'avons pas fait C'est un composant qui
fait pivoter l'acteur. Il effectue la rotation en fonction des règles et des paramètres
que nous saisissons ici. Par défaut, il pivote dans l'espace
local et à 180 degrés. Maintenant, il existe un moyen de
faire en sorte que cela soit responsable d'un
certain composant et non d'un acteur dans son ensemble. Et ce nœud serait
défini comme composant mis à jour. Nous allons donc
connecter les deux ici et nous allons
connecter le
maillage statique ici. En fait, on le
copie-colle en quelque sorte. Ce
mouvement de rotation ne fera donc désormais
pivoter que le composant de maillage statique et non le reste de l'acteur. Donc, si nous jouons et nous
éjectons, nous pouvons voir que cela n'a pas fonctionné J'ai fait un test en direct. C'est incroyable. Quel est cet article ? Voici le
composant mis à jour de l'ensemble d'éléments, le maillage statique. Oh, je pense que c'est parce que je l'ai connecté
au script de construction. Cela devrait être au début du jeu. Rafraîchissons-le. Ouaip. Vous pouvez donc voir que le triangle ne fait que bouger. Ouais Le composant mis à jour ne fonctionne donc pas vraiment sur le script de
construction car il a besoin que le jeu s'
exécute pour faire quelque chose. Donc, comme dans le script de
construction, le jeu ne fonctionne pas, le composant de mise à jour
ne fait vraiment rien. C'est pourquoi nous avons dû l'
utiliser pour commencer à jouer au lieu d'un script de construction
car il est inactif C'est sur l'éditeur. Nous pouvons voir qu'il ne tourne pas. Quoi qu'il en soit, continuons. Nous allons dupliquer le plan
du téléporteur Et appelons cela un changeur
de niveau. Et apportons-le ici. Et d'après ce que vous avez deviné, il a à peu près
la même configuration Nous avons besoin de la même configuration car nous allons effectuer des
portages entrants et sortants Nous avons
donc besoin de toutes
ces fonctionnalités. Maintenant, avant de commencer à
programmer cela, créons également un
widget simple avec une animation. Nous allons
cliquer avec le bouton droit de la souris dans le
dossier des widgets et créer un plan de widget
et un widget utilisateur Je vais l'appeler W you fade. Parce que lorsque nous entrons dans le monde
et
que nous le quittons, nous devrions entrer et
sortir pour ne pas avoir une mauvaise apparence Nous allons ajouter un canevas
et
une image. Nous allons ancrer l'image
pour qu' elle soit plein écran et annuler
les décalages Et la couleur doit être noire. Maintenant, comment créer des animations ? Il y a un onglet ici lorsque je suis dans le plan du
widget Si ce n'est pas le cas, l'onglet n'
est plus là, comme vous pouvez le voir, mais dans
le plan du widget, un nouvel onglet apparaît ici
, appelé animations Ajoutons une nouvelle animation. Appelons cela un fondu. Animation. Appelons
ça mon animation en fondu. Il ne devrait pas comporter d'espaces. Ma grosse animation et
double-cliquons pour y accéder. Ici, nous avons l'onglet
avec toutes les animations. Et ici, lorsque nous
sélectionnons une animation, nous avons les paramètres pour l'utiliser. les paramètres, nous allons sélectionner le bouton Ajouter et ajouter une image car j'ai sélectionné
l'image. Si vous n'avez pas sélectionné
l'image, vous devez la
sélectionner en gros puis appuyer sur Ajouter
. Pour cette image, nous avons
ici notre
piste d'animation que nous utilisons un 0,5, donc 02,5, peut-être que cela
suffit d'animation Nous allons ajouter un nouveau
camion à cette image, qui sera de couleur et
d'opacité En fait,
faisons simplement le rendu de l'opacité. Pourquoi compliquer les choses ? Maintenant, il commence par défaut avec un où nous
voulons qu'il soit zéro, et dans 0,5 seconde, nous voulons qu'il soit un. Donc 0-1. Et c'est ainsi que
s'achève notre animation. Compilons et sauvegardons, et fermons le fondu. Widget, nous n'en aurons pas encore besoin. Fermons les
objets et le magasin de physique. Et le personnage, le
porte-clé et le téléporteur. Ouvrons le changeur de niveau. Puisque nous allons changer de
niveau, nous n'avons plus besoin de la
téléportation. Nous n'avons pas besoin
de l'emplacement de l'autre acteur, mais nous devons
créer ce widget, comme nous l'avons fait au début
du jeu en mode jeu. Ouvrons-le pour l'afficher
Nous avons créé le widget, puis plus tard, nous avons
décidé quand
l'ajouter au viewpod ou quand le
supprimer du viewpod Maintenant, nous voulons simplement le créer niveau
propriétaire devrait être
le contrôleur Taer, et la classe devrait être payée et nous l'ajouterons instantanément
à Viewport Le seul problème, c'est que nous
devons le rouvrir. Je vais donc ouvrir le widget, rechercher opacité puis l'opacité
et mettre la valeur par défaut à zéro Parce que si je la laisse
telle quelle,
dès que je l'ajoute,
même si l'animation ne l'est
pas même si elle même si l'animation ne l'est se
joue juste après, je verrais un écran noir, puis je verrais le fondu. Ce ne serait donc pas
l'effet escompté. Maintenant, jouons à l'animation en
fondu. Comment allons-nous nous y prendre ? À partir de
ce widget, nous allons appeler le fondu, obtenir mon animation de fondu, et à partir de là, nous
allons jouer à l'animation. Maintenant, en utilisant cette animation, nous allons faire get
and time, et nous allons y ajouter
quelques secondes. Par exemple, ajoutons-y 1 seconde. Peut-être qu'un c'est beaucoup, peut-être 0,5. Et nous allons faire une publicité
différée et connecter tout cela. Donc, quoi qu'il
arrive, cela
se produit une fois que l'animation du faux est terminée. Maintenant, connectez le son, et nous allons
ouvrir le niveau par son nom. Et le nom, ça
devrait être le nom
du deuxième niveau de Tutor Map Il doit être exactement
copié ici ou tapé, mais il doit correspondre exactement Maintenant, nous devons connecter le widget à la cible
car il joue une animation. OK,
cette animation est en train de jouer, mais à qui joue-t-elle ?
L'animation. Compiler une sauvegarde. Allons
tester ce que nous avons créé. Cela ne fonctionnera pas vraiment
complètement. Jouons. Et comme vous l'avez remarqué, d'
accord, bien sûr,
tout d'abord, nous n'avons pas d'éponge, nous n'avons pas de lecteur, mais
le son n'a pas vraiment joué La raison en est que nous
jouons simplement un son en deux D
comme nous le faisons normalement, ce qui n'est pas suffisant
dans cette situation. Parce que nous changeons de
niveau, cette entité, ce son de jeu n'
existent que dans ce niveau. Dès que nous essayons d'en
ouvrir un autre, une procédure commence qui détruit les
éléments de ce niveau. Comment pouvons-nous émettre un
son qui
persistera tout au long du niveau ? Ce que nous devons faire,
c'est générer le son en D, qui, comme vous pouvez le voir, a une pointe d'outil
plus importante ici Cette fonction permet aux utilisateurs de créer des composants audio avec un réglage spécial pour les composants non
spatialisés et non distants Quoi qu'il en soit, il y a un
tas d'autres règles. Mais ce qui nous importe,
c'est que si nous l'ouvrons, il y aura une transition persistante à travers les
niveaux. Je vais donc cliquer dessus
, et je vais utiliser le son de téléportation Je vais utiliser celui de
téléportation VR. J'aime vraiment
celui-ci. Mais ce son ne
sera pas joué instantanément. Il vient d'être engendré. Cela ne veut pas dire
qu'il va jouer. Nous l'avons mis au monde, mais rien d'autre ne s'est passé. Pour ce faire, nous allons simplement partir
de la valeur de retour. Il est important
qu'elle ait une valeur de retour, est important
qu'elle ait une valeur de retour car jouer du son vers D n'a pas
de valeur de retour. Cela nous donne une
entité à manipuler, à promouvoir une variable et à faire des choses avec elle. Mais ce que nous voulons faire pour
le moment, c'est simplement jouer. Ensuite, nous connectons
le niveau ouvert. Et maintenant, si nous essayons de jouer,
nous avons un son qui joue. Mais pour être honnête, le son devrait être diffusé
avant le délai. Ensuite, nous ouvrons le
niveau. C'est bon. Maintenant, nous n'utiliserons pas
ce nœud, en fait. Nous n'utiliserons pas simplement
un nœud de niveau ouvert. Nous allons créer un système qui, lorsque vous entrez
par un point A, sache
qu'il mène au point B et qu'
il va du point B au point C,
et peut-être aurons-nous
un système qui indiquera au jeu que si je
le
téléporte d'ici, je me téléporte là-bas Peut-être que nous l'
expliquerons mieux dans le prochain car je pense que c'est un bon
point d'arrêt pour celui-ci. Au revoir pour le moment.
36. Système de points de passage dynamique pour les niveaux interactifs: Bonjour et
bienvenue sur Unreal Engine, cinq systèmes de portes Blueprint
Mastery
et portails interactifs Auparavant, nous avions commencé par notre porte de téléportation,
notre changeur de niveau Maintenant, nous avons ajouté un widget payant qui, lorsque nous le déclenchons avec
la case qui se chevauche, nous le faisons exister Nous le créons, nous l'
ajoutons à la fenêtre d'affichage, puis nous diffusons l'animation et le son que nous produisons, et il sera persistant pendant
toute la transition de niveau Et après un petit délai, nous avons ouvert le nouveau niveau. Cela nous amène à
discuter de trois nouvelles choses
que nous allons rencontrer. La première chose est
l'instance de jeu, qui est une classe globale, une classe créée
lorsque nous lançons le jeu pour la première fois
et qui est détruite
lorsque nous terminons le jeu. Je veux dire, terminez le jeu en
quittant l'application. Cela est donc utilisé pour contenir des variables
essentiellement globales. C'est un bon moyen de le
démontrer et savoir comment y accéder
pendant le jeu, à tout moment, en gros. Il existe de nombreuses façons de stocker ces données un peu plus
complexes, comme les états des joueurs, et ce
sera pour nous un bon exemple. L'autre point dont je voulais
parler est une structure. Nous parlons un peu
des structures selon lesquelles la transformation est une structure, comme si je créais une variable de
transformation, c'est une structure composée
essentiellement de trois vecteurs. Et si nous le cassons, nous pouvons voir ces trois vecteurs. Eh bien, une structure,
par définition, est un type de données personnalisé qui nous
permet de regrouper
différentes variables, n'est-ce pas ? Or, cette structure comportait trois variables différentes
du même type. nôtre comportera également deux
variables du même type, mais il s'agit d'une structure
qui nous est propre, une variable qui contient les informations que nous
voulons contenir de manière personnalisée Donc, tout d'abord, nous allons passer à Blueprints Nous allons cliquer.
Nous allons accéder à l' onglet
Plan et
sélectionner la structure Je vais nommer ce changement de niveau
ST. Et cela nous donne une
variable en elle-même, et créons-en une autre, et elle
sera du type chaîne. En fait, cela pourrait
être du type name, mais laissons-leur une chaîne, et nous allons nommer
ce niveau actuel, et l'autre niveau suivant. Et il s'agit essentiellement
d'une structure. Nous pourrions en avoir, par exemple, un
autre qui indique « charger la santé
du joueur » et un autre qui indique que le joueur est
capable de sauter ou ce que nous voulons. C'est notre structure,
notre type de variables. Nous allons donc enregistrer ceci,
puis nous allons créer en allant dans Divers
et dans la table de données. Et ici, cela nécessite une structure de flèche de
sélection. Nous allons choisir notre changement de
niveau ST et appuyer sur OK. Je vais nommer
ce changement de niveau DT. Et ouvrons-le.
Qu'est-ce qu'un tableau de données ? Il s'agit d'un ensemble de données
structurées utilisant la structure que nous avons créée que nous avons sélectionnée pour son utilisation. Il est organisé en lignes et colonnes, ce qui
nous permet de stocker, de
gérer et d'accéder facilement à
ce type de données. Chaque ligne correspondra à une instance
de la structure et comportera
ses propres variables. Créons quelques lignes. En fait, il nous en faut plus
et pour ces noms, nous allons utiliser exit. A, en fait, sortie A, tutoriel. Disons quitter un didacticiel. Ce serait exit, B, tutorial, et l'
autre serait exit. A, transfert, et l'
autre serait sortie, B, transfert. C'est bon. Et j'ai commis une erreur. Nous ne voulons pas le niveau actuel. Nous voulons revenir à la structure avant de
procéder à de nombreux autres changements. Nous voulons que cela signifie que deux
joueurs commencent, en gros. Le joueur commence parce que ce que
nous allons changer c'est le départ du joueur qui
sera choisi. Par exemple, si je
pars du joueur Start A,
je passerai au niveau suivant joueur Start B ou
joueur Start A. Quand je partirai du
joueur B, je passerai aux niveaux suivants, début du
jeu B et dans les deux sens. Nous allons donc créer une boucle dans laquelle
je vais d'une porte, revenant à la
même porte d'où je
viens et en choisissant une porte d'à côté, revenant à « c'est mieux de
montrer », en gros. Nous allons
entrer par cette porte. Nous allons
quitter ce magasin. Lorsque nous entrerons dans ce magasin, nous allons sortir par
la dernière porte Oups, pas celle-ci,
celle-ci, par ici. Complétons ces informations
dans notre tableau de données. Ce sera le point de départ du joueur. Lorsque nous sélectionnons chaque ligne, nous pouvons voir ici
l'éditeur de lignes, lequel nous pouvons ajouter
les informations. Le niveau suivant
sera courant. Mais pour plus de cartes,
cela sera utile. Notre niveau suivant est donc
Tutorial Map Two. Donc, tout
aurait la carte 2 du didacticiel. En fait, pas tout. Ceux-ci auraient juste dû leur
donner un didacticiel, qui
est le premier. Tutoriel. Arrêté.
À partir de ce niveau, nous allons passer au deuxième tutoriel À partir de la carte 2 de Tutorialm, nous revenons
à la carte du didacticiel Maintenant, quel est le point de
départ du joueur auquel je fais référence ? Remplissons-le d'abord,
puis nous
allons l'expliquer. Donc, pour la première rangée, ce sera «
exit a transfer ». Je vais copier ça. Le prochain sera
le transfert à la sortie B. Et je vais copier
en fait les noms
que je donne à ce didacticiel de sortie B, à
ce didacticiel de sortie A et à
ce didacticiel de sortie B. C'est bon. Maintenant, de la même manière que nous utilisons des tags pour le pion du joueur, la même manière que nous pouvons utiliser des
tags pour le démarrage du joueur Et si nous examinons les
détails du départ des joueurs, vous pouvez constater qu'il possède un tag de départ du joueur très spécial, différent
de ceux que nous
avons déjà définis. Ce serait donc le
point de départ du joueur. Maintenant, dupliquons cela. Ajoutons-en un ici. Faisons en sorte qu'elle se chevauche avec celle-ci, qui est la sortie. D'accord. Je pense que c'est bon. Alors nous en aurons
un autre ici. Et nous avons besoin d'un
téléporteur ici. Je vais donc
simplement le dupliquer faire pivoter comme ça
et le ramener ici. C'est bon. Superposons les
joueurs en commençant par la sortie. ,
peu importe la sortie Pour être honnête,
peu importe la sortie. C'est bon. Et faisons de même pour
la carte du didacticiel. Je vais enregistrer la sélection. Maintenant, pour cette carte, nous devons également définir le remplacement du mode de jeu. Donc, le mode de jeu à la troisième personne, et nous allons
permettre au joueur démarrer, ça a l'air plutôt énorme. Oui, je suis loin de l'
endroit où je suis censé être. D'accord, nous avons donc également besoin de
téléporteurs ici. Nous allons donc passer aux plans, aux
portes, aux changeurs de niveau, pas aux téléporteurs. C'est ici. C'est bon. Dupliquons tout cela et faisons-les pivoter. OK. Compilons et
sauvegardons, puis revenons à notre carte. Non, nous n'avons pas ajouté de
balises sur celles-ci, donc sélectionné la première. La première serait la suivante. Allons chercher le tag. Le
tag est Exit A transfer, et l'autre Exit B transfer et
copier-coller les noms, donc aucune erreur ne se produit Et je pense que ce
serait pour celui-ci. Et nous allons passer à
la prochaine étape en liant tous ces éléments. Cela commence donc à avoir du sens. Je te verrai alors. Au revoir.
37. Passer du mode de jeu pour personnaliser la fonctionnalité de création de joueur: Bonjour et bienvenue
sur les vrais portails Engine Five, Blueprint Mastery, Door Systems
et Interactive. Auparavant, nous en avions terminé avec nos tables de données et
nos structures. Nous avons également fini d'ajouter des
tags aux démarrages de nos joueurs. Nous avons placé les départs de joueurs
là où nous
voulions entrer et sortir des portes, et nous avons ajouté les tags aux
départs des joueurs qui
correspondent à ce départ, je ne devrais pas dire « start nice ». première erreur s'est produite, cela devrait indiquer de quitter un didacticiel. C'est bon. Maintenant, nous allons laisser le
joueur commencer ici. Pour l'instant, nous avons également fait
le deuxième niveau, le didacticiel à deux niveaux. Nous avons ajouté le joueur commence ici et les tags correspondants. Je vérifie également les erreurs. Transfert de sortie B. C'est bon. Et maintenant, passons à la
création de notre instance. Je vais donc cliquer avec le bouton droit de la souris. Je vais suivre le cours
Blueprint. Je vais faire une recherche par
exemple. Et je veux l'
instance du jeu. C'est ici. Je vais le
sélectionner. Je vais l'appeler GI doors Tutorial. Ensuite, nous devons accéder
aux paramètres du projet. Et recherchez par exemple. Et au lieu d'une instance de jeu, nous voulons qu'il s'agisse d'un
didacticiel GI door dans une classe d'instance de jeu. Maintenant, je vais
fermer les paramètres. Ils n'ont pas besoin d'être
sauvés. La sauvegarde automatique à chaque modification que nous effectuons Et je vais ouvrir
l'instance de jeu. Et ici, nous allons créer
un événement très simple. Nous allons créer un événement
personnalisé, l'appeler transfert de
niveau et y
créer une entrée. Il sera
du type chaîne. Cela va venir de. Nous allons le promouvoir
en tant que variable. Et nous allons
commencer par Get Data TB. Ne pas obtenir les noms des lignes des tables de données, obtenir le plan des lignes de données. Et c'est le
nœud qui extrait les informations
de notre table de données Nous pourrions avoir une variable ici avec les tables de données que nous voulons, mais nous allons simplement l'utiliser manuellement pour sélectionner manuellement à partir d'
ici, changement de niveau DT. Maintenant, le propre nom, où il vient,
sera le nom de notre ligne. Comme vous pouvez le voir, à partir d'une chaîne, il l'a automatiquement traduite en nom. La prochaine chose que nous allons
faire est d'annuler le changement de niveau. Nous allons en
faire une variable, nous appellerons couche active. Commencez, puis nous allons
ouvrir le niveau mon nom, et nous allons connecter le niveau
suivant à ici. Alors, qu'avons-nous fait ? Nous avons créé
un événement de transfert de niveau. Nous avons commencé par le « came from », qui sera le nom de
notre joueur de départ actuel, puis nous avons trouvé ligne correspondante
dans le tableau de données. Par exemple,
il s'agit du didacticiel Exit A et le prochain joueur
que nous
enregistrons est le transfert Exit A. Donc, à l'intérieur, nous
stockons le transfert d'un joueur
vers le début du joueur actif, puis nous
ouvrons le niveau que nous sommes censés ouvrir. Maintenant, lorsque nous ouvrons
le niveau suivant, ces informations
sont restées telles quelles car, comme nous l'avons dit, l'instance de jeu est
un plan global qui stocke les informations
par le biais de transferts de niveaux Revenons à
notre changeur de niveau et modifions ce niveau ouvert. Pour appeler depuis l'instance la nouvelle fonction, le nouvel événement. Nous allons donc
obtenir une instance de jeu. Et c'est ainsi que nous trouvons l'instance de jeu comme nous l'avons
fait avec le mode jeu. Nous allons passer au tutoriel
de GI Drs. Nous allons en
faire un pur casting. Maintenant que nous savons qu'il
s'agit de l'instance, nous pouvons obtenir des informations, l'événement de transfert du
niveau de transfert. Mais comme vous pouvez le constater, cet
événement doit venir de là. Nous allons donc le promouvoir
en variable, exposer lors du
spawn
et le créer
dans iStAnseable. Nous devons installer le connecteur de
démarrage de ce joueur et le copier pour qu'il
provienne du téléporteur Et en fait, nous n'avons pas
besoin du téléporteur cible, nous pouvons
donc le supprimer en toute sécurité Et pour être honnête, nous n'avons
pas besoin de la capsule ni de la flèche, ni de la racine. Ouais, ça a déjà l'air mieux. Enfin, souvenez-vous
qu'au début, j'ai dit que nous annulerons
la fonctionnalité dans laquelle notre mode de jeu comporte une fonction prédéfinie indiquant comment
trouver le joueur commence Nous allons remplacer ce comportement et
créer le
nôtre pour remplacer un comportement déjà prescrit,
précodé dans
n'importe quel plan précodé Nous pouvons accéder aux
fonctions, en fait,
sans appuyer sur le bouton plus, mais ici, cela apparaît
sous forme de symbole de dérogation Donc, en appuyant dessus, vous pouvez voir les fonctions que nous pouvons
remplacer dans ce plan Nous pouvons sélectionner le
joueur de départ ici. Maintenant, la logique de la façon dont cela fonctionnera sera faire démarrer tous les joueurs
que nous pourrons trouver. Recherchez le point de départ du joueur
actif. Si vous ne le trouvez pas,
choisissez le point de départ. Nous allons également créer un code pour rechercher le lieu de
départ. En gros, ce serait ça. Maintenant, comment faisons-nous cela ? Revenons à la
troisième personne, Gao. abord, je vais créer une variable locale
qui ne sera pas liée au démarrage
du joueur Tapullan et Colli Et lorsque nous commencerons le plan commencerons l'ordre des opérations, je le mettrai sur « vrai Ensuite, je vais
recruter tous les acteurs de plus et le cours
pourrait être le début du joueur. Maintenant, il s'agit d'un nœud un peu lourd
car il passe par tous les acteurs du
niveau qui sont chargés. Mais comme cela se produit
avant le
début du niveau en ce moment, c'est bon. Maintenant, à partir de cette liste, je vais sélectionner chacune d'elles. Et je vais vérifier si je
ne vais pas vérifier si
je vais obtenir le tag player start tag player. Je pense que cela s'appelle G player
Start tag et je vais comparer
s'
il s'agit d'un tag à départ égal. Je vais sélectionner
une succursale ici. Et cela nous sauvera le
départ du premier joueur. Je vais donc en faire une variable locale et nommer
cet emplacement de départ. Maintenant, je vais faire
une nouvelle promotion parce que si ce
n'est pas le joueur qui commence, alors je vais
avoir des instants de jeu. Je vais passer au casting chez GI. Je vais passer
à Pure Cast, et je vais inciter les joueurs
actifs à commencer. Et maintenant, à partir de ce tag
play start, je vais comparer si les deux
sont égaux. Si c'est le cas, alors
c'est notre nouveau départ. Appelons ce joueur start. Donc, s'il a le tag start, c'est l'emplacement de départ. S'il porte le tag du joueur
actif, c'est le début du joueur. Nous devons également configurer les joueurs pour qu'ils
commencent à ne pas tomber. Et maintenant, au final, nous devons
vérifier si nous avons trouvé
un joueur Si c'est le cas, alors oui, je l'ai promu variable puis variable locale. Je vais donc
le supprimer maintenant et le promouvoir à nouveau au début de la couche
variable locale. Je vais donc le
connecter ici. E. Faisons en sorte que le
joueur commence ici. Et si nous ne l'avons pas trouvé, si ce n'est pas vrai, donc c'est faux, alors le début du joueur est le
départ du joueur
que nous avons trouvé. Si le point de départ du joueur n'
est pas trouvé, cela signifie que nous n'avons pas
trouvé le point de départ du joueur actif, alors nous allons
définir le point de départ du joueur, non le point de départ. La convention de dénomination
ici n'est pas la meilleure. Allons tester notre
système. Compilons. Peut-être que je dois le
compiler aussi, bien
sûr, et le compiler
à nouveau. Et jouons. Alors maintenant, je suis pressé, je dois ajouter les tags de départ des
joueurs Tout cela dit aussi de commencer. Il s'agit donc du
didacticiel Exit B. C'est bon. Nous avons vérifié les autres au début de cette leçon. Donc, en théorie,
cela devrait fonctionner maintenant. Nous sommes là, nous pouvons y retourner. Nous pouvons y retourner, donc nous ne pouvons pas
y retourner. Je ne vois rien. Je suppose donc que je n'ai pas ajouté au
niveau suivant les tags des joueurs,
les tags de porte
des téléporteurs Ouaip. C'est
tout parce qu'à l'heure actuelle, elle
essayait de savoir quoi
faire, mais elle n'y est pas parvenue. Bien, revenons au niveau
d'origine. Donc, suivre cette voie et
suivre cette voie, ça marche. Donc, si je prends cette direction, nous arriverons à la dernière pièce. Mais il y a
encore des choses à faire. OK, ce n'était pas correct. Voyons d'où tout cela vient. Mais je viens de le coller. C'est bon, ça marche. Et
je ne pars nulle part. Pourquoi est-ce que je ne pars nulle part ? Tout d'abord, ça dit trans.
Ça dit quelque chose de bizarre. Transfert de sortie B. Mais je fais la même
erreur partout. Cela devrait fonctionner. Ts. Testons-le à nouveau. OK. Donc je suppose qu'il y a
eu une faute d'orthographe Ouaip. Nous avons un
système de transfert qui fonctionne. Génial. Je pense que c'
est tout pour celui-ci. Je te verrai bientôt. Au revoir
38. 7 travaux de base pour les systèmes de sauvegarde afin de préserver les états de porte: Bonjour et bienvenue
sur Unreal Engine Five,
Blueprint Mastery, Door Systems
et les portails interactifs Auparavant, nous en avions terminé avec notre système de points de cheminement
dynamiques à plusieurs portails Je ne sais pas comment tu
veux l'appeler. Nous sommes passés de la
téléportation de ce niveau à un nouveau niveau qui en est la
représentation Nous sortons d'ici et nous
pouvons faire des allers-retours. De cette porte à cette porte
et de cette porte à cette porte, puis de cette porte à cette porte et de cette
porte à cette porte. Mais tout cela se situe à
un niveau différent. Pour ce faire, nous avons créé un tableau de données
dont les noms correspondent aux tags
du niveau entrant, du niveau d'où nous
partons,
et qui contient les
noms de départ des joueurs , ainsi que le niveau suivant. Maintenant, tout cela repose sur une structure composée
de deux boissons. Nous l'utilisons lors d'un événement. Dans l'instance de jeu, dont nous l'avons redit, il s'agit d'un plan global, et nous avons créé la
transformation
de niveau qui provient du portail, et nous obtenons ce résultat, qui correspond au nom de
ligne de la table de données, et nous obtenons une
sortie de cette ligne À travers les colonnes,
à travers la structure, nous démarrons le prochain joueur
actif et nous ouvrons le niveau suivant. Désormais, lorsqu'un niveau s'ouvre, nous annulons le début du joueur
choisi Et nous avons créé une
petite fonction qui recherche tous les acteurs qui
démarrent le joueur. Et puis si l'un d'eux
a le tag start, et qu'il en regarde un autre, s'il le trouve, c'est qu'il a
le tag de départ du joueur actif Donc, s'il a ses
étiquettes, tout va bien. Si ce n'est pas le cas,
nous aurons un message d'erreur. Mais s'il a tous ses tags en bon état, s'il trouve un joueur
actif, il définit ce joueur
comme point de départ par défaut. Continuons maintenant à utiliser ce système pour
démontrer une sauvegarde. Donc, ce que nous allons
faire, c'est
ajouter la porte ici et
à l'autre niveau. Choisissons la porte latérale, qui est très simple,
pas celle-ci. En tout cas, oui, une porte à sens unique, celle-ci. Nous allons l'
apporter ici. Eh bien, voici une question relative. Il est un peu
plus grand que ce qu'il est censé être, mais nous allons le réduire un peu. Peut-être un peu plus grand que ce 0,5. Disons 0,7. Non, 0,6. Je suppose 0,55 Oui. C'est bon. Cela n'a pas
vraiment d'importance. Je l'ai mis en face, mais vais
juste le faire pivoter et
c'est bon, parce que nous entrons par ici, donc la face avant
devrait être comme ça Et je dois le réparer à nouveau. Donc 0,57. Oui, 0,57 Cela s'est adapté instantanément. C'est bon. Passons maintenant au niveau
de transfert, la deuxième carte
du didacticiel. Où est le niveau ici ? Et ajoutons à nouveau la porte, qui est celle où se
trouve une porte à sens unique. Cette fois, nous devons
l'agrandir. Est-ce que ce serait cinq ? Cinq, c'est beaucoup. Deux, trois, 2,5, 2,2, ça me va. Appelons autour de vous. Alors peut-être 2.4. Oui, 2.4 semble bien. C'est bon. Le laisser tel quel, même s' il y a des lacunes, n'a pas
vraiment d'importance. Cette porte devrait donc
pouvoir économiser, par exemple. Passons à la carte. Laissez un code couleur sur les cartes pour
les retrouver facilement. OK, le rouge fera l'affaire. Donc, ce que nous voulons faire, c'est
pouvoir entrer d'ici,
entrer dans cette pièce. Ouvrez la porte,
revenez peut-être ou partez dans l'autre sens, et cette porte devrait
toujours être ouverte. Commençons donc par
une logique inverse. Commençons par la porte. De quoi aurait besoin cette porte pour charger son état ? Par exemple, nous devrons définir d'
une manière ou d'une autre l'état de la porte. Et en fonction de
l'état de stockage
, comme nous économisons
uniquement sur l'ouverture complète ou
sur la fermeture complète, nous aurions besoin des derniers
degrés d'ouverture ou de fermeture. Il faudrait donc définir
la rotation relative. Allons aussi chercher le larp. Et allons faire de la
place pour ces nœuds. Cela suffirait. Je n'aurais pas besoin d'un larp ici. J'aurais besoin d'une sélection et cela
dépendrait de l'État. Donc, quand il est ouvert,
il fait -90 degrés, -90 ou -90 Et quand il est fermé ou dans n'importe quel
autre état, c'est zéro. Eh bien, pour nous, nous ne faisons que
charger, ouvrir et fermer, donc l'ouverture et la fermeture ne
sauvegardent pas les degrés actuels. Et zéro serait également bloqué. Mais comment cette
porte sait-elle quelle porte ? Si j'en avais dix, comment sait-il de
quelle porte il s'agit ? Pour cela, nous
devons créer un identifiant personnalisé. Je
vais supprimer. Ce texte est-il utilisé quelque part ? Trouver des références ? Non. Mais pour
le D, je ne l'utiliserai pas. Je vais utiliser une chaîne. Appelons cette porte d'identification. Donc, cet identifiant de porte
dans le fichier de sauvegarde dirait : OK, ID, cette porte est restée
ouverte ou fermée selon ce qu'elle
contient s. Pour appeler cette modification, nous devons créer un appel dans
l'interface Blueprint Nous allons donc accéder à
notre interface Blueprint. Fabriquez une porte de chargement. Et cette porte de chargement doit au moins
retrouver l'
état de la porte. Il faudrait donc qu'il y ait une variable qui soit l'énumération de l'état de la
porte Mais lorsqu'il s'agit
d'une sauvegarde, il se peut que
nous ayons plus d'
une chose à enregistrer. Nous pourrions savoir s'il est verrouillé
comme l'élément clé ou non, non, c'est un mauvais exemple. Peut-être aurions-nous des diplômes
d'ouverture. Alors peut-être aurions-nous différentes
choses à enregistrer et à charger. Encore une fois, c'est là que
les structures entrent en jeu. Nous allons
créer une structure,
une nouvelle structure sous forme de plans, structure, et nous allons
appeler cette porte ST, enregistrer Ouvrons-le, et pour
la première variable, définissons l'état de la porte et
laissez-le être l'état de la porte E. Et prenons une autre
variable qui
serait la porte IE. Et ce serait une chaîne. Et pour être honnête, si vous
voulez modifier l'ordre ici, nous pouvons voir cette icône
ici, elle devient une main. Nous pouvons donc les glisser-déposer
en haut et en bas. Il est préférable d'avoir d'abord l'identification de
la porte. Je vais enregistrer
cette structure. Et dans nos portes BI, je vais
saisir les statistiques des portes, et ce sera cette structure. D, porte, sauvegarde. Alors maintenant, cette structure
nous donne, lorsque nous chargeons la porte, toutes les informations que nous avons enregistrées pour la porte. Pour le moment, c'est très simple. Il ne comporte que deux variables, l'ID et l'état, mais il pourrait devenir plus
complexe à notre guise. Alors maintenant,
retournons à notre porte. Et compilez. Et implémentons la
BI, les portes informatiques, l'interface
Blueprint Et maintenant nous y avons
accès Non, nous n'en avons pas car je n'ai pas compilé l'interface
Blueprint Mais maintenant que je l'ai fait, nous avons
accès à cette porte de chargement. Je vais donc
en parler ici. Je vais le connecter ici. Je vais casser la structure comme nous l'avons fait pour la transformation, et je vais relier
l'état de la porte ici. En gros, ce serait l'
événement qui chargera notre porte. Lorsque la porte est
appelée à être
chargée, nous en reparlerons
plus tard dans une autre leçon. C'est tout ce
dont il a besoin pour être chargé. Maintenant, encore une chose
lorsque nous serons en train de sauver la porte, et nous expliquerons plus de choses dans la prochaine leçon. Lorsque nous sauvegardons la porte, nous avons besoin d'une autre fonction. Appelons ça Get Door Starts. Et dans cette fonction, nous allons avoir une
sortie de la ST door save, appellerons door dots. Nous allons compiler,
enregistrer et retourner à notre porte. Et double-cliquez
sur Obtenir les statistiques des portes. Nous allons diviser
la structure. Nous allons connecter
l'identifiant de la porte
ici et l'
état de la porte ici. Cette fonction est donc utilisée pour obtenir n'importe quelle porte
commençant par des obligations. Maintenant, encore une fois, si cette structure
comporte plus de variables, nous devrons connecter plus
d'informations au nœud de retour. Je pense que c'est tout pour celui-ci. Nous allons expliquer le mécanisme de
sauvegarde dans le prochain chapitre. Au revoir.
39. Créer des mécanismes de sauvegarde de jeu pour maintenir la progression à travers les niveaux: Bonjour et bienvenue
sur Unreal Engine Five, Blueprint Mastery, Door Systems
et les portails interactifs Auparavant, nous avions commencé
avec notre Dor Save. Nous avons créé une nouvelle structure qui contient l'identifiant de la porte
et les statistiques de la porte. De plus, nous avons créé
deux nouvelles fonctions dans l'
interface Blueprint, la porte de chargement et la porte de démarrage La porte de chargement contient une
entrée de statistiques de porte
et les statistiques de getdor contiennent
une sortie de statistiques de porte Ensuite, nous avons emprunté
la porte Y Way, nous avons créé la porte de chargement d'événements à partir de l'interface Blueprint Nous avons cassé les statistiques de la porte. Nous réglons l'état de la porte sur
l'état de porte enregistré, et nous définissons la rotation relative fonction de la statistique que nous chargeons par rapport à l'
état de porte que nous chargeons. Nous avons également rempli le champ
get door starts avec une nouvelle variable appelée Door ID et door state. Et l'ID de porte doit être
une instance modifiable et exposée lors du spawn afin que nous
puissions le remplir nous-mêmes Parce que lorsque nous
sauvegardons les portes, elles ont besoin d'un identifiant unique. Ainsi, lorsque nous chargeons les portes, ils savent quelle porte est
laquelle, alors ils se chargent. Maintenant, pour ce qui est de la
sauvegarde du chargement, nous allons avoir besoin d'un
nouveau type de plan, sauvegarder le plan des objets de jeu Pour le créer, nous
allons cliquer. Nous allons accéder à Blueprints, à la
nouvelle croix Blueprint, et nous allons
rechercher une sauvegarde Et c'est ici. Je vais le sélectionner
et le nommer So Doors. Oui, donc Door. Ouvrons-le. Maintenant, c'est le fichier qui est en train d'être écrit
dans notre ordinateur. Il s'agit d'un fichier sérialisé. Cette propriété est une classe
sérialisable. Il est là pour capturer les données de
jeu à
stocker de manière persistante Cela peut contenir n'importe quel
type de données que nous voulons. heure actuelle, nous avons besoin d'
une structure, d'un ensemble de
structures, essentiellement, parce qu'il peut y avoir
de nombreuses portes, une porte SD, sauf. Et faisons-en un tableau. Appelons cette porte « porte sauve ». Démarre. Statistiques de sauvegarde des portes. Oui. Fermons
ça. Nous n'aurons plus
besoin des portes SO. Nous allons l'appeler
mais ne pas l'utiliser. Et passons à
notre instance de jeu pour créer notre mécanisme de sauvegarde. Maintenant, la première chose que nous allons
faire est de créer un événement personnalisé. Et nous allons l'
appeler Save Doors. Et la première question est : est-ce que la sauvegarde existe ? Désormais, ce nœud possède un
nom d'emplacement et un index utilisateur. Nous pouvons avoir plusieurs
emplacements à enregistrer. Nous allons donc
promouvoir la variable. Il peut s'agir du nom du
slot 1, du slot 2, du slot 3. Mais lorsque vous
chargez et sauvegardez, le nom du slot doit être le même pour que nous puissions mieux
le démontrer en action. Donnons-lui donc un
nom par défaut, sauf un. Mettons une branche ici
parce que c'est différent lorsque nous n'avons pas de sauvegarde dans cet emplacement et différent lorsque nous avons une ardoise dans cet emplacement. Cela revient à remplacer
la sauvegarde et à
enregistrer un nouvel objet dans cet emplacement Commençons par le
nouvel objet de cet emplacement. Donc, dans Folds, nous allons
créer une sauvegarde. Et l'objet de sauvegarde du jeu
serait les portes SO. Nous allons en
faire une variable. Nous allons l'appeler «
enregistrer un objet de jeu ». Désormais, nous n'aurons de mécanisme complexe
pour détecter nos portes. Ce que nous allons faire, c'est simplement
recruter tous les acteurs de classe. Nous pourrions avoir du tag,
mais la classe, c'est bien. Et cherchons une porte
à sens unique. Et à partir de toutes les portes
que nous trouverons pour chacune d'entre elles, nous allons
commencer par des portes. Donc maintenant, chaque porte qui existe, gros,
nous donne des statistiques. Et comme il s'agit de la première sauvegarde, la première fois que nous
sauvegardons, nous pouvons simplement obtenir notre objet de
sauvegarde, obtenir notre
liste de statistiques de sauvegarde de porte et simplement ajouter toutes ces
statistiques ici. Personne ne penserait donc
que nous avons fait une sauvegarde, comme si nous avions transmis les informations
à l'objet de sauvegarde du jeu. Nous avons obtenu les points de départ et les ajoutés à ce tableau.
Eh bien, pas exactement. À
la fin de cette opération, nous avons encore besoin de
chaque boucle pour enregistrer la partie sur la machine à sous. Et ici, nous avons besoin
d'une référence
du slot et du nom du slot. Encore une fois, c'est pourquoi j'ai dit
qu'ils étaient corrélés. Ils
sont liés entre eux et nous vérifions la présence de cet emplacement Nous ne devons pas changer
le nom de l'emplacement tant que nous n'avons pas terminé tout ce que
nous avons fait avec cet emplacement. Ce serait juste le cas où une sauvegarde n'existerait pas. Et s'il existe une sauvegarde de jeu ? Ensuite, nous allons charger le jeu sur la machine à sous et la machine
à sous doit rester la même. Et pourquoi nous chargeons parce que nous avons besoin des données de sauvegarde
actuelles. Nous voulons donc
manipuler ces données. La prochaine étape est donc de
lancer des portes
SO dans notre sauvegarde , car le jeu
que nous avons chargé depuis le lot n'a aucune amélioration, juste
un objet de jeu sûr. Nous ne savons pas lequel c'est. Donc, en ce moment, nous avons
chargé les portes SO. Peut-être que nous avons aussi fait d'autres sauvegardes. Nous avons fait une exception pour les fixations. Nous avons fait une sauvegarde pour les statistiques des
personnages. Nous avions une réserve pour les quêtes. Celui-ci est pour les portes. Encore une fois, nous allons
franchir toutes nos portes. Je vais donc copier le get all actors from class
et le four loop. En fait, j'ai aussi
eu besoin de toucher les portes. Je vais maintenant
créer une variable,
une variable Bolling
et l'appeler New door Je vais le
faire passer ici. Ensuite, je vais récupérer notre objet de sauvegarde que
je n'ai pas défini. Oui. Après le casting, nous devrions placer notre objet de sauvegarde
sur notre porte. Enregistrez car c'est la sauvegarde que nous
manipulons. Nous l'avons obtenu. Nous l'avons chargé, alors que
nous l'avions créé auparavant, nous l'avons enregistré instantanément
car il s'agit de portes SO, mais maintenant que nous le chargeons, nous ne savions pas de
quel type il s'agissait. Nous l'avons donc envoyé sur SO doors, et nous l'avons enregistré comme objet de jeu que
nous sommes en train de manipuler. Maintenant, cet objet possède notre
gamme de portes de départ. Et pour chacune des portes, nous voulons tirer sur chaque
boucle pour obtenir l'identifiant. Et ce que nous allons faire, c'est également
obtenir l'identifiant que nous avons
obtenu grâce aux quatre boucles de toutes les classes d'acteurs et
vérifier s'ils sont identiques. Désolé, cet équivalent n'
a pas de chaîne exacte. Et s'ils le sont, alors nous définissons simplement cet élément du tableau. À partir de là, définissez l'élément du tableau à partir du tableau car nous
ne voulons pas ces statistiques. Voici les statistiques de sauvegarde. Ceux que nous voulons sont ici. Je vais créer un
nœud de lecture pour le rendre plus clair. Et je lis ici et je
lis ici et ici. Les statistiques que nous enregistrons, les nouveaux départs
proviennent de tous les acteurs de notre classe, ceux qui gagnent la carte. Les démarrages que
nous comparons, s'ils portent le même
nom, proviennent de cette liste. Donc, s'ils ont le même nom, nous avons besoin de l'index de cette liste. Puis on ferme
la nouvelle porte parce qu'elle
n'est pas neuve. J'existe déjà. Maintenant, une fois ces quatre
boucles terminées, nous allons nous demander s'il s'
agit toujours d'une nouvelle porte, ou en avons-nous trouvé une
et changé les statistiques ? S'il s'agit toujours d'une nouvelle porte, nous allons l'
ajouter à ce tableau. Lisons ceci
ici et ici. Va un peu désaltérer. Et attendez. Maintenant, ce n'est pas une nouvelle porte
s'il s'agit d'une nouvelle porte, nous allons ajouter à
la porte commence par
le jeu de sauvegarde,
ajouter au tableau. Et nous allons
ajouter les statistiques que nous venons de recevoir sur
la carte. C'est bon. Maintenant, ce serait notre
sauvegarde pour le commenter, une presse et je vais
taper « save game ». Alors maintenant, il y a un commentaire. Je sais que nous n'avons rien
commenté, mais nous devrions au moins
afficher les commentaires Je pense que c'est tout pour celui-ci. Nous allons continuer
le jeu de chargement sur le prochain. Au revoir pour le moment.
40. Programmation de systèmes de chargement de jeux pour enregistrer la progression: Bonjour, bienvenue sur
Andrea Engine Five, Bluepin Mastery Door Systems
et les portails interactifs Auparavant, nous en avions terminé
avec notre mécanisme de sauvegarde. Nous avons vérifié si le
jeu existe déjà. Pour ce faire, nous avons utilisé un nom de slot. Et s'il existe, nous chargeons le jeu et nous le lançons pour vérifier si ce sont nos
objets de sauvegarde que nous avons créés. Nous enregistrons dans une variable. Nous passons en revue tous nos acteurs. Nous obtenons leurs statistiques. Nous définissons une nouvelle variable de porte, et nous bouclons toutes les portes de
sauvegarde existantes. Elles sont identiques si la
porte existe déjà, nous stockons les nouvelles données et si
nous vérifions si les nouvelles portes sont fermées. Si ce n'est pas le cas, nous l'
ajoutons simplement à la liste. Maintenant, j'aurais peut-être dû commencer par la branche de la force comme nous l'avons fait, et créer un jeu sûr. Nous ouvrons toutes les portes
et nous les ajoutons à la liste
des jeux sûrs, puis nous sauvegardons le
jeu d'une machine à sous à l'autre. Quelque chose que nous n'avons pas fait
ici et que nous aurions dû faire. Je vais donc copier cet objet de sauvegarde et emplacement de
sauvegarde, car nous
les transformons en variables ici. Et dans la première boucle, après avoir passé revue tous nos
acteurs sur la carte, nous les enregistrerons dans le slot. Maintenant, pourquoi le faisons-nous
ici et pas ici ? Comme il s'agit d'une boucle
imbriquée, cela signifie que pour
chacune d'entre elles, faites quelque chose pour
chacune d'entre elles Donc, une
fois cela terminé, il doit encore passer par
toutes les portes qu'il a trouvées. Ainsi, une fois qu'il a franchi toutes les portes qu'il a trouvées, nous économisons dans le slot. Passons maintenant au
jeu de chargement. Je vais donc créer
un événement personnalisé. Je vais l'appeler Load. Je
vais l'appeler load loads. Et commençons à coder. Donc, tout d'abord, encore une fois, nous demanderons si la
sauvegarde existe. Parce que si ce n'est pas le cas, cela ne sert à
rien, les nouvelles portes,
ni le nom
de la machine à sous. Inutile de
charger quoi que ce soit. Seulement si c'est vrai,
nous allons charger. Si ce n'est pas le cas, il
n'y a rien à charger. Nous allons charger le
jeu depuis Slods. Et le slot doit
être le nom du slot. Encore une fois, nous devons lancer sur O doors et en
faire l'objet de sauvegarde du jeu. La prochaine chose que nous faisons est d'
obtenir des statistiques de sauvegarde ou de sauvegarde. Je vais promouvoir
ces deux variables. Ensuite, nous allons faire appel à
tous les acteurs, un sens, dans un sens, parce que c'est
celle-ci que nous sauvons. Et nous allons effectuer chaque boucle et nous
allons démarrer les portes
. Pas celui-ci. Sur le message, l'un parce que l'autre était une sorte
d'appel interne. Maintenant, nous allons faire de même
avec les statistiques du coffre-fort des portes. Nous allons passer à une boucle.
Nous allons donc créer à nouveau
notre boucle imbriquée
et
comparer les noms
des portes
que nous venons de charger ici
à ceux du niveau Nous allons donc être exactement égaux. Nous allons ouvrir une succursale
et s'ils sont égaux, alors nous allons
avoir cette porte. C'est la référence de la porte,
et nous allons charger la porte. Encore une fois, pas celui-ci, le message qui définira les statistiques
de la porte chargée. C'est bon. Et ce
serait une charge. Comme nos portes, cela trouve la porte où nous
sommes, elle se trouve sur la carte, puis elle exécutera cette fonction. Il définira l'état et définira la
rotation relative en conséquence. Et maintenant, la question se quand économisons-nous et
quand chargeons-nous ? Et comment le jeu sait-il s'
il s' agit d'un jeu déjà chargé
ou d'un nouveau jeu ? Nous allons créer un système
très simple. Nous allons créer un lingot
dans notre mode de jeu, une variable de type Bullion, et nous appellerons
ce jeu chargé point de contrôle
ou
quelque chose Lorsque nous commençons le jeu,
nous voulons que cela soit désactivé. Mais notre première sauvegarde, notre premier point de contrôle, c'
est lorsque nous changeons de niveau C'est pourquoi j'ai maintenu le
plan du changeur de niveau activé. J'ai foiré quelque chose. Ouaip. OK. Donc, dans ce plan, lorsque nous modifierons le niveau et que nous utiliserons le
didacticiel GI pour le faire, nous allons terminer
le jeu
chargé et nous
allons également sauver des portes Ainsi, lorsque nous
franchissons le niveau, nous indiquons que
le point de contrôle est activé À notre retour, c'est toujours
activé car le mode de jeu, l'instance de jeu sont globaux. Il contient les statistiques qu'
il y a définies. Et à notre
retour, nous chargerons. Quand ce chargement,
quand allons-nous le charger ? Eh bien, dans le mode jeu, étant donné que le mode de jeu s'exécute à
chaque fois qu'un niveau est ouvert, nous demanderons : « W est le mode de
jeu ? C'est ici. Allons-y pour commencer à jouer. Après avoir créé le widget, nous allons accéder au jeu instantanément. Nous allons passer au casting de GI. Nous allons en
faire un pur casting, et nous
allons charger ce jeu. Donc, s'il s'agit d'un jeu chargé, nous allons mettre
une branche ici, nous allons charger des poupées, une fonction
qui
charge toutes les poupées. Maintenant, la dernière chose
à faire est d'aller identifier nos portes. Donnons un identifiant à la première
porte, celle-ci, celle-ci. Donnons-lui un F. Je ne sais pas pourquoi F,
mais c'est une bonne identification. Disons que c'est F deux. Maintenant, comme nous voulons que cette porte
corresponde, non pas à l'autre
porte du niveau deux, elles doivent avoir le même identifiant Donc celui-ci
serait également F deux. C'était une capitale ? Hmm.
Je vais aller vérifier tout de suite. Oui, utilisez le capital. OK, donc ces magasins partagent
le même fichier de sauvegarde, ils partageront
donc
le même état. J'espère que tout
ira bien. Allons donc tester.
Vérifions qu'il est fermé. Nous sommes de passage par ici.
Nous ouvrons la porte. Passons d'ici,
et la porte est ouverte. Notre chargement sécurisé fonctionne donc. Et si je
recommence le jeu, ils devraient être fermés. Donc oui, ils sont fermés. Et dès que je suis parti d'ici, je l'ai laissé fermé, donc
il sera fermé. l'heure actuelle, il l'a enregistré à l'état fermé,
donc il est fermé, passe d'ici, ouvre la porte, sort dans l'autre sens Je ne peux pas vraiment voir d'ici, mais je peux m'éjecter, et c'est ouvert Notre mécanisme de chargement sécurisé
fonctionne donc parfaitement, et je pense que
cela mettra fin à celui-ci, et nous allons passer
à la suivante avec notre porte VFX. Au revoir
41. Concevoir une porte avec des poignées fonctionnelles pour une interaction immersive: Bonjour et bienvenue
sur Unreal Engine Five,
Blueprint Mastery, Door Systems
et les portails interactifs Auparavant, nous en avions fini avec
notre mécanicien de chargement et de sécurité. Nous avons appelé notre jeu de chargement dans notre mode
de jeu à la troisième personne. Lorsque chaque niveau commence, puisque le mode de jeu est en cours d'exécution, nous nous sommes demandé s'il s'agissait d'un jeu de chargement, d'une variable que nous avions enregistrée dans l'instance de jeu, d'un jeu chargé. Ensuite, si c'est le cas, nous avons
chargé le jeu via notre événement que nous avons également créé dans
l'instance de jeu, qui charge le jeu en utilisant un
peu le même mécanisme. Mais au lieu d'économiser, nous chargeons chaque porte. Ensuite, nous avons ajouté
le changement de niveau,
les portes de sauvegarde et le jeu
chargé à true. Donc, le point de contrôle, la sauvegarde commence lorsque nous passons
au niveau suivant Et à notre retour, le jeu est toujours chargé, et nous pouvons voir les
effets de la sauvegarde et du chargement. Continuons avec
notre dernière porte, la porte VFX que nous allons
dupliquer avec la porte à sens unique Allons à nos portes. Trouvons la porte à sens unique, et nous allons
y ajouter une poignée. Je vais donc le dupliquer. Appelons cette
porte VFX, et ouvrons-la. Maintenant, pour le rendre encore plus spécial, nous allons changer
la couleur en rouge de la porte. Et nous allons également
ajouter un nouveau maillage commencé. Cela représentera le manche. Appelons-le donc handle. Et pour le maillage statique, nous utiliserons le foie. Je pense que c'en est un. Non,
deux. Oui, les deux foies. Mettons-le donc en place. Faisons-le pivoter.
Apportons-le ici. Elle est un peu grande. Je vais en faire une demi-taille. Donc, échelle de 0,5. Et avançons-le un peu,
et c'est très bien. Maintenant, au début de la partie, je vais enregistrer sa rotation. Donc, obtenez une rotation relative, et je vais promouvoir
cette variable et l'appeler gérer la rotation
relative d'origine. Ajoutons également les
sons de la porte, afin de pouvoir les
copier-coller. Apportons-le ici. Fermons tous les onglets sur
la droite, compilons et enregistrons, et ouvrons Let's
opens double door. Ouais Celui-ci avait des sons. Je vais donc
copier-coller les sons d' ici sur la porte des effets visuels Je vais fermer les deux.
Nous n'en avons pas besoin. Et je vais terminer sur
le ton le plus bas. Non, c'est en fait ouvert. R. Donc, le jeu commence dès début et le terrain inférieur doit être ouvert
parce qu'il se ferme. Et en fait, tu
sais quoi ? Connectons-le simplement pour inverser et jouer. La porte est donc plus animée. Il s'ouvre et se ferme pendant qu'il exécute l'animation d'ouverture
ou de fermeture. Et pour rendre cela plus complet, modifions la mise à jour du
widget pour qu'elle indique fermer lors de l'ouverture et
ouvrir lors de la fermeture. C'est bon. Et nous ne voulons pas supprimer le widget lorsqu'il s'
ouvre ou se ferme. Cela devrait donc aller en sens inverse et la fermeture devrait
entrer en jeu, car lorsque
nous fermons, nous ouvrons et lorsque nous
ouvrons, nous fermons. OK, je pense que ça suffira. Ajoutons maintenant l'animation de la
poignée. Nous le ferons avant
une fois, bien sûr. Nous apporterons la poignée et nous
réglerons la rotation relative. Je vais l'ajouter
ici. Et nous allons apprendre à utiliser un rotateur. En fait, tu sais
quoi ? Nous n' utiliserons pas la rotation
initiale de la poignée. Nous allons juste savoir quelle est
cette étrange rotation. Cela devrait être -90, 90 et zéro. C'est bon. Oui, cette rotation
était vraiment bizarre. S'il s'agissait de sauver cette rotation, ce serait très difficile. Maintenant, pourquoi cela se produit, il y a quelque chose
appelé Gimbal ok et quelque chose appelé
quardans of the screen Et parfois, ces choses
peuvent un peu gâcher. Passons donc de -90 à -90. Disons 40. N° 400, 40 et -90. Je pense qu'il devrait
également être de -40 parce que c'est 90 si
je le fais pivoter vers le bas C'est un positif de 40. Mais ici, c'est un inconvénient. Même si nous voyons du positif
sur l'axe ci-dessous. Quoi qu'il en soit, compilons et sauvegardons. Et pour Alpha, ce que nous allons utiliser, bien entendu, c'est le chemin le plus court. Et créons
un nouveau flow truck. Donc, chez le flow truck, appelons cela une transmission par poignée. Le premier lecteur
Alpha à une porte. D'accord. Je dois donc le faire à aide
de la souris. Si je fais juste un
zoom arrière, responsable du
contrôle
ne fait rien Donc deux points,
en fait trois points. Un c'est zéro, zéro. La question suivante serait : quel est le
montant de la première chronologie ? Une demi-seconde. Le manche devrait donc
être la moitié de celui-ci. Le total serait donc de 0,25. Cela pourrait redevenir zéro. Et le milieu
serait 12,5. Donc 125, et ce serait un. Compilons et sauvegardons, et connectons
notre handle à notre alpha. Cela signifie donc qu'il va pivoter
vers le bas et repivoter vers le haut. Et ce serait notre nom d'utilisateur. Alors amenons notre porte ici. Faites-le un peu joliment parce qu'il
a cet effet Glow Express Play. Nous devons voyager. C'est bon. Et il s'ouvre en face et
le manche reste là. Mais on voit que c'est animé. Très bien, alors passons à l'endroit
où il est ouvert. Mettons-le à 90. Faisons en sorte que le manche soit
un accessoire de la porte, pour qu'il bouge avec la porte. De plus, faisons en sorte que
notre joueur commence par ici afin que nous n'ayons pas à voyager
trois fois pour venir ici. C'est tellement vrai. Tout ce qui est ouvert, fermez-le pendant que nous
ouvrons et fermons. Déplaçons-le
un peu sur le côté. Et ajoutons quelque chose de plus. Ajoutons un effet
visuel réel qui
se produira lorsque la
porte sera terminée. Mais faisons-le pour la prochaine leçon. J'
irai te voir alors. Au revoir
42. Finaliser la mécanique de la porte de poignée avec des effets de particules et des améliorations visuelles: Bonjour et bienvenue
sur les portails Anreal Engine Five, Blueprint Mastery, Door Systems
et Interactive Auparavant, nous avions commencé
par notre porte VFX. Nous avons changé pour que la porte s'ouvre et se ferme pendant qu'
elle se ferme et qu'elle s'ouvre avec E en utilisant l'interrupteur et en utilisant les sorties d'ouverture
et de fermeture. Et nous avons également ajouté
une poignée à la porte, une poignée que nous avons
attribuée au treillis Srtic Et nous l'avons animée à l'aide de
notre chronologie en réglant la rotation relative du
manche sur un rotateur statique Maintenant, nous avons dit que nous allions
ajouter des effets visuels, mais ajoutons quelques éléments supplémentaires. Par exemple, ajoutons
un son à la poignée, et cette fois, nous allons
utiliser un composant audio. Donc pour démontrer son utilisation. Appelons donc cela le son D. Alors, qu'est-ce que ce composant
audio ? Comme les
composants du maillage statique et comme les autres composants,
il s'agit d'une coque. C'est une sorte de coque. Ce type est donc audio. Il est vide, nous devons donc
définir le type de son diffusé. Et nous n'allons pas le
faire sur les détails,
nous allons le faire pendant l'
exécution, car comme il s'agit d'un composant audio de la porte, il ne disparaît pas. Lorsque nous diffusons le son en D, il crée du son
et il disparaît. C'est maintenant un composant. C'est donc un son que nous
avons comme variable dans les composants. Vous pouvez en fait le trouver
dans le son ici, composant
audio, et le
réutiliser et le changer à chaque fois. Je vais l'apporter ici. Et en appuyant sur E, je
vais faire une séquence, et je vais tout d'
abord arrêter le son émis
par cette porte. La prochaine chose que je
vais faire est définir un nouveau son. Je vais donc utiliser
le nœud sonore défini, connecté ici,
peut-être un peu plus d'espace. Et pour le son, je vais
choisir une poignée de porte. La prochaine chose que nous devons
faire est de simplement jouer le son. Et ce serait tout. Mais utilisons le son de la porte, le composant audio
pour une seconde utilisation. Je vais
copier-coller tout ça. Je vais terminer la chronologie à
la fin. Et quand je ferme
la porte, pas toujours Juste au moment où je ferme, la
porte est fermée, pas ouverte, nous voulons faire de la place
pour que cela soit plus visible. Mettons-le ici. Et à la fin
de la chronologie, nous allons
essentiellement
relier cette logique Apportons-le ici. Alors maintenant, lorsque la porte
est réellement fermée, elle émet un son fermé. Alors choisissons la porte, fermons. Alors maintenant, notre poignée
émet un son, et lorsque la porte
est réellement fermée, c'est en fait
un son qui se ferme qu'elle se ferme. J'ai
terminé l'animation rapprochée à chaud, en gros. Testons cela.
Compilons d'abord. Jouons. OK. Comme vous pouvez le constater, lorsqu'il essaie
d' émettre le son de la poignée, il est envahi par le
bruit de la porte fermée D'accord. Maintenant, cela se produit
parce que nous
arrêtons le son de la porte et que nous émettons un
nouveau son par-dessus. Donc, comme ce son
n'est pas terminé, où est-il ici, n'a pas fini de
jouer lorsque nous fermons la porte,
il s'arrête. C'est quoi ? Par ici ? Ça s'arrête. Il
émet un nouveau son, et il émet un nouveau son. La prochaine chose que nous allons faire est,
euh, d'aller sur notre carte et montrer un peu
comment associer tous tag, parce que nous avons
démontré les acteurs à un
tag, parce que nous avons
démontré que nous
obtenons tous les
acteurs de la carte, puis nous
filtrons la classe, puis nous déterminons quels
acteurs sont ceux que nous voulons. Maintenant, nous allons le faire avec
un tag get all actors of tag, qui ne passe pas par
toutes les classes, tous les acteurs de
la carte, mais par les acteurs du tag. C'est un nœud bien plus optimal. Pour ce faire,
nous allons tout d'abord intégrer
notre système de particules NS Fireworks sur notre carte. Mettons-le quelque part. Ne l'activons pas. Je vais donc passer
à ses détails. Comme vous pouvez le voir, la
particule
est activée par défaut dès
que je l'ajoute à la carte. Maintenant, si je passe ici dans
les détails et que je
recherche l'activation automatique
sera désactivée et il
n'y aura plus de particules. Alors cherchons également un tag allons dans Actor Tanks
et ajoutons le tag P. Je vais le déplacer ici, le
déplacer ici, non ? C'est derrière la porte. OK. Maintenant, activons
cette particule. Et faisons un tour. Comme je veux que cela se produise, encore une fois, uniquement lorsque
la porte est fermée, activons la
particule, comme lorsque la porte est complètement fermée, puis la particule s'active, non lorsque la porte s'ouvre. Mais je veux que cela soit
courant dans les deux fonctions. Maintenant, je pourrais le séparer
et l'ajouter quelque part ici ou après car cela
met à jour le widget. Mais ce que nous pouvons faire, c'est juste vous montrer
un petit truc. Nous allons refaire
une séquence. Et maintenant, nous pouvons avoir cela comme
une fonctionnalité distincte, logique
distincte pour
le moment où la porte se ferme. Maintenant, je vais mettre une étiquette sur toutes les portes. Et le tag sera P pour la
particule que nous venons de créer. est
intéressant, c'est de voir que celui-ci réunit
tous les acteurs du tag, et
non tous les composants. Nous avons notre composante dans le lecteur de la
capsule qui est encore une fois P. Et ici nous avons un
acteur avec un tag P. Un acteur n'est pas un composant. Ce nœud ne
rechercherait donc pas
la classe du joueur. Donc, si je fais une chaîne d'impression ici, pour les deux, et en fait,
je n'en ai pas besoin. Je ne peux pas simplement faire une chaîne d'impression et en obtenir la longueur. Et connectez-le à
la chaîne d'impression. Ce que nous devrions voir lorsque j'appuie sur Play et que j'ouvre et
ferme la porte en est un. Comme vous pouvez le constater, il
ne recherche pas. Il ne trouve pas la composante du
personnage qui attaque P. Il cherche simplement des acteurs. C'était juste une démonstration. Nous n'avons pas besoin de la chaîne d'impression. Mais ce que nous devons faire c'est obtenir la première
copie du tableau. Il s'agit d'un autre
nœud de tableau dont nous pouvons obtenir un nombre dans la liste. Nous allons donc passer au casting de
Niagara System, l'acteur de Niagara. Parce que nous avons trouvé l'acteur, mais nous ne savons pas de quel
type d'acteur il s'agit. Nous n'avons qu'une étiquette. S'il s'agissait de Gepoactors of class, nous pourrions filtrer la classe, puis nous pourrions avoir un accès
direct à cette Mais maintenant que c'est
getOactOS of tag, nous devons convertir notre résultat pour demander si c'est la
classe que Et à partir de là, nous allons
obtenir le composant Niagara. Je pense que c'est en bas, oui, et réglez Activer. Et comme vous pouvez le constater,
j'ai de nouveau dû procurer le composant Niagara
car si je dessine à partir d'ici, que je l'
active, vous pouvez voir cela me mène directement
au composant Niagara. C'est un acteur de Niagara, mais ce que j'active, c'est la composante Niagara
de cet acteur. Je vais donc régler la réinitialisation. Cela signifie également jouer la
particule depuis le début et émettre un son
lorsque cela se produit. Et pour ce faire, nous n'
allons pas diffuser
le son à l'infini. Jouons 100 fois,
100 feux d'artifice. Cela ne sera pas corrélé à la particule, la particule restera en vie après les
cent sons joués Mais 100 sons, je pense que
c'est suffisant pour le faire. OK, donc nous allons faire N. Et au lieu de le
trouver ici, ce qui n'est
pas facile, appuyez sur N et
cliquez. Apportez simplement le D N. vais régler le N à 100. Je vais faire le
delay ici, qu'il ne joue pas un son
après l'autre instantanément. Nous allons créer un flotteur arrangé de manière
aléatoire. Nous lui donnons donc un
peu de randomisation. Faisons 0,5 contre un. Et jouons du son à D. Que nous allons également
jouer avec une tonalité. Nous allons faire
flotter aléatoirement la portée. Et ce
sera de 0,9 à 1,1. Pour le son, nous
allons choisir feux d'artifice, puis nous devrons l'
appeler à nouveau. Je vais créer
un événement personnalisé et appeler D et Fireworks. Je vais le connecter
ici
et je vais faire des feux d'artifice. Cela crée donc une petite boucle
qui sera jouée 100 fois, puis elle
ne sera plus jouée. Mais avant de le tester, ajoutons également un
peu de cinématique Ajoutons quelque chose qui nous voir les feux d'artifice
dans notre lecteur. Pour ce faire, je vais faire
venir un caméraman. Et je vais cliquer avec le bouton droit
sur la caméra et la piloter. Pas Pivot, pilote,
acteur de caméra, ici. Alors maintenant, je
déplace réellement la caméra. Vous pouvez voir ici, acteur
pilote, acteur de caméra. Donc, pour le moment, je suis
essentiellement la caméra. Je veux donc avoir une belle vue
de l'endroit où je veux peut-être
voir ici Pour être honnête, nous
pourrions tout voir. Et je vais faire confiance
à Came Actor. Et comment puis-je posséder
cet appareil photo ? Comment modifier la vue ? Eh bien, il existe un nœud très
simple appelé Bt view Par get Blend. Mais comme vous pouvez le constater, je
ne peux pas l'appeler d'ici. La raison en est que je dois d'abord me procurer une manette de
joueur,
car il s'agit d'une manette. Le contrôleur dispose d'une
caméra et d'un gestionnaire. C'est lui qui est
censé le faire. Donc, si je fais simplement glisser le pointeur depuis une exécution aléatoire,
cela ne peut pas me donner cela En fait, si je le fais, définir cible de
vue avec Blend
et désactive la contaity Je peux le voir ici. Vous
pouvez voir le joueur. Maintenant que le jeu pour joueurs et gestionnaire de
caméra sont
des enfants de la manette du joueur, ils sont inclus ici
dans un sens très large de la façon dont les classes fonctionnent et
héritent les unes des autres Quoi qu'il en soit, nous allons
définir un objectif de vue avec Blend. Et si je désactive le contentity,
je ne peux toujours pas le voir. Ah, c'est ici. Peut-être que
tout va mal. Quoi qu'il en soit, à partir de la
manette du joueur, nous pouvons l'obtenir. Désormais, la nouvelle cible de vision
serait notre caméraman Ops, et la précédente
serait notre manette. Je vais compiler et enregistrer, réglons le
temps de fusion à 2 secondes, 2,5, et testons-le. Donc, je vais appuyer sur Play
pour ouvrir la porte, et quand je la ferme, nous
sommes censés mélanger vue sur la cible et
le feu d'artifice. OK. Le feu d'artifice a fonctionné, mais pas la caméra
parce que j'ai laissé le remorqueur. C'était décevant. C'est donc la deuxième fois qui fait le charme. Nous allons ouvrir et fermer. Comme vous pouvez le voir, je peux
toujours déplacer le personnage, ce qui n'est pas grave. Mais si nous voulions arrêter cela, nous pourrions simplement aller ici, contrôler p
et désactiver la saisie. Mais j'aime bien pouvoir déplacer
le tapis, pour être honnête. Et maintenant je ne peux pas
déplacer le tapis. Maintenant, vous voyez, l'
ouverture est restée, il faudrait
donc un nouveau code ici pour
supprimer le widget, ce que nous pouvons facilement faire. En quelque sorte, copiez-collez ceci. Le widget
de suppression du mode jeu. Mettons les choses au clair
un peu. Jouons. Ouais. Le widget est retiré, la porte s'ouvre
et nous avons des feux d'artifice. C'est bon. Maintenant,
commençons par le début. Le joueur commence
par un tag start. Notre carte est donc complète. Et parcourons-le. On va ici, on s'approche
de la porte, elle s'ouvre. On vient ici, ça ferme. Pour ce faire, nous utilisons le
plan de niveau. Nous avons ensuite créé un plan de
porte qui s'ouvre avec E et se ferme Ensuite, nous avons
créé une porte qui s'ouvre, se ferme et
s'ouvre en face de la couche. Nous en avons fait une porte double et
nous y avons ajouté du son. Nous avons fabriqué une serrure à partir de
l'autre porte latérale, une porte raccourcie. Que le joueur doit
être de ce côté pour ouvrir. Nous avons fabriqué une porte
casse-tête avec un levier qu'il suffit d'un
seul levier pour ouvrir, et le foie ouvre, envoie la porte envoie la porte, le message à déverrouiller. Ensuite, nous avons créé un système à deux leviers dont la
porte contrôle les leviers Nous avons créé un peu
de physique ici avec les boîtes. Je crois que c'était deux,
oui, la triche, nous appuyons sur deux, et nous avons la porte coulissante
avec deux pressostats Nous avons un petit puzzle avec des boutons dont la porte s'ouvre et se ferme si
le puzzle est correct. Nous avons également un porte-objets. Si tu choisis le mauvais d'abord. Et puis il y a le télépot. Vers un autre emplacement de la carte. Nous avons notre magasin de physique. Nous avons une téléportation vers une autre
carte dont nous démontrons la capacité de sauvegarde. Nous pouvons
voir que la porte est ouverte ici Et si je recommence, on le ferme, on passe par ici. Je vais l'éjecter, et
nous pouvons le voir fermé, et nous changeons de niveau tout
au long de cette procédure, et puis nous avons notre boutique d'effets visuels Celui qui a une poignée crée des feux d'artifice
et change notre appareil photo. Et je pense que ce serait ça. Félicitations pour avoir atteint ce stade dans
le didacticiel de la série Door. Vous maîtrisez l'essentiel et êtes prêt à relever les
défis qui vous attendent. Merci de m'avoir suivi. Votre voyage ne s'arrête pas là, alors restez curieux et continuez à
explorer jusqu'à la prochaine
fois, heureux de gagner de l'argent.