Transcription
1. 00 Intro: C'est ce que vous allez construire les photographier complètement dans l'Unreal Engine Five,
entièrement selon un plan Je suis Rob, et au fil de
ces 27 sujets, cette série vous fera passer
d'une base de code vide à un jeu jouable terminé Nous allons créer nos propres mouvements de joueur
entièrement personnalisés fréquence d'images
par seconde, en utilisant le système de
saisie amélioré et abordant des sujets tels que la détection approfondie des
collisions Nous allons implémenter des classes de
pions pour les ennemis
et les avions des joueurs en mettant
l'accent sur l'héritage, donc une classe de base, qui
alimentera tous les types de navires, en ajoutant un système de projectiles
qui fonctionnera pour les deux camps, une classe unique entièrement
personnalisable Même les classes d'apparition que
nous créons sont dotées d'
une architecture adaptée aux une architecture adaptée ennemis et
aux arrière-plans, et vous pouvez l'étendre comme
bon vous semble Nous examinerons également des sujets tels que design et la simple amélioration du jeu avec des effets de
particules, du
son, des tremblements de caméra
et même des contrecoups Nous allons ajouter une boucle de jeu
complète afin que vous ayez un
jeu jouable d'ici la fin, y compris votre interface utilisateur Vous pouvez jouer, mourir,
redémarrer ou arrêter. L'accent sera mis
sur le fait de faire les choses correctement. Nous allons examiner architecture
propre, des systèmes
réutilisables et comprendre
pourquoi quelque chose fonctionne ou ne fonctionne pas au lieu
de simplement copier les notes. Chaque décision est expliquée. Je vais volontairement ignorer les fonctionnalités
intégrées à Unreal, puis vous expliquer pourquoi
nous avons Lorsque quelque chose est contre-intuitif,
je le dénonce et tous les actifs dont
vous avez besoin pour
suivre et obtenir les
résultats finaux sont fournis, ce qui
signifie que vous pouvez simplement vous concentrer sur la programmation et sur la une bonne structure de projet .
Je me suis occupé
de l'art pour toi. Votre projet
de classe sera ce jeu terminé,
entièrement
peaufiné et prêt à être
intégré dans un portfolio,
ainsi que toutes les nouvelles fonctionnalités
que vous déciderez d'ajouter Il pourrait y avoir de nouveaux
ennemis, de nouvelles armes, un système de points,
tout ce que vous vouliez. L'architecture sera
conçue de manière à ce que vous puissiez la
construire et l'étendre. Par exemple, j'ai transformé
le projet en
quelque sorte en l'espace de quelques mois
et j'ai ajouté un tas de
nouvelles fonctionnalités et de nouveaux actifs
à un projet étendu. La première vidéo
traitera de la configuration
du projet. J'ai
hâte de vous y voir.
2. 01 - Configuration: La plupart des projets irréels deviennent impossibles à gérer
en un mois. Les actifs seront éparpillés partout, sans aucune convention de
dénomination, et vous finirez par passer le plus clair de votre temps à chercher
plutôt qu'à créer quoi que ce soit. J'ai créé cette série avec l'intention de résoudre
ce problème dès le départ. Je vais vous aider à
créer un
shoot complet à partir de zéro, où chaque sujet
sera axé sur le fait de faire les choses correctement. Il s'agit d'une bonne structure, d'
une
bonne dénomination, d'une bonne architecture, de
compétences qui seront transférées dans n'importe quel projet
sur lequel vous travaillez. Nous travaillerons à la
création du jeu que vous pouvez voir en
arrière-plan ici en nous basant
sur le contenu officiel créé par Epic dans son package d'
exemples de contenu. Si c'est quelque chose
qui vous intéresse, alors allons-y et mettons en
place cette base Tout d'abord, je vous
recommande
d'accéder au lien de téléchargement
dans la description. Vous trouverez deux
options ici. Nous leur avons retiré les points de soulignement. Il contient les règles relatives aux
maillages et aux textures au cas où vous souhaiteriez modifier quoi que ce soit
dans Blender ou Photoshop Ensuite, vous avez le shoot
them up, le
tutoriel underscore underscore start, et voici le projet
complet Et ce sera celui
que vous voudrez suivre ainsi que les sujets
que nous aborderons. Par défaut, il
vous sera fourni sous forme de dossier zippé Vous devez donc vous assurer extraire de manière raisonnable Partir
du même projet signifie
simplement que nous travaillons
avec des paramètres identiques,
les mêmes actifs, que nous travaillons à
la même échelle, etc., ce qui facilitera un
peu le
dépannage en cas
de problème. La première chose à regarder à l'intérieur du dossier extrait, aller dans le dossier du didacticiel Shoot them up
Underscore Par défaut, le projet est
dans Unreal Engine 4.27 pour une compatibilité maximale si vous
souhaitez travailler avec une version du moteur légèrement
plus ancienne Si comme moi, vous
allez l'améliorer pour qu'il fonctionne avec l'
Unreal Engine Five La mise à niveau prend
environ 10 secondes. Sur Windows, vous pouvez simplement
cliquer avec le bouton droit sur ce
projet en forme de point U juste ici, et vous avez la
possibilité de sélectionner la version d' Unreal Engine pour
changer de version Dans le menu déroulant, sélectionnez
la version installée avec
laquelle vous souhaitez travailler, puis cliquez sur OK. Tu es prêt à partir. Je travaille
actuellement sur Linux, je vais
donc vous montrer une approche
alternative. C'est utile de toute façon. Cela fonctionnera sous Windows,
et c'est en fait une chose très utile à
connaître, car cela peut vous
aider à corriger des projets qui
ne s'ouvriraient pas autrement en raison de
plugins manquants ou de problèmes de plug-in. ce faire, je vais simplement cliquer avec
le bouton droit de la souris sur le projet
point U. Je vais ouvrir W, et vous pouvez choisir n'importe quel éditeur de texte. Cela pourrait être le code Notepad VS. Je vais travailler avec Zed, et nous pouvons voir ici sur
le côté gauche si nous regardons l'association
Engine, elle nous indique que
cela a été créé avec 4.27. Nous pouvons simplement changer cela. Je vais
travailler avec la version 5.6,
qui sera probablement
obsolète au moment où vous regarderez ce film,
mais elle sera suffisamment proche. Une fois cela fait, comme
avec n'importe quel éditeur de texte, nous pouvons simplement l'enregistrer. Nous pouvons fermer la fenêtre,
et c'est maintenant prêt. Pour démarrer le projet, il
suffit de double-cliquer sur
le point U du projet, et celui-ci commencera à se
charger en arrière-plan Sur Linux, double-cliquer sur un projet U par défaut ne
lance pas réellement le moteur Unrel Si vous vouliez ce type
d'intégration
avec mon programme d'installation personnalisé d'
UnrelEngine, cela vous permettra de
trouver toutes les versions téléchargées ou
installées localement d'Unreal, les
ajouter à un lanceur
automatique ici, et nous pouvons simplement lancer Impress Okay,
et nous pouvons charger le lanceur
assez standard que vous obtenez
normalement Ce n'est pas vraiment le
sujet principal de ce que nous allons
vivre, je vais
donc fournir un lien
supplémentaire vers celui-ci. Vous pouvez le vérifier dans
la description ci-dessous. Je fournirai les scripts
entièrement gratuitement, afin que vous puissiez également
les télécharger. Et cela va simplement aller
plus loin que ce que j' avais besoin de faire pour que
Linux soit opérationnel,
prêt et fonctionne de
manière assez fluide avec
le moteur UnRel Maintenant que nous sommes dans Unreal, votre interface peut être
légèrement différente de la mienne
selon la version avec laquelle
vous avez décidé de travailler Epic a tendance à réorganiser les choses peu près chaque fois que quelqu'un
s'ennuie un peu Mais nous pouvons nous concentrer uniquement
sur les concepts, non sur les boutons
et les emplacements exacts. Ils existeront certainement, et vous serez
opérationnel assez rapidement. La première chose à
vérifier est le navigateur de
contenu ou
le tiroir de contenu, qui se trouve en bas à
gauche. C'est là que réside tout
le contenu de votre projet. Nous pouvons cliquer dessus pour
voir la structure de notre projet. À l'intérieur du dossier de contenu, il y a un sous-dossier qui
correspond au nom du projet, didacticiel Shoot Them Up
Underscore C'est la convention de dénomination
recommandée par Epic pour les projets et les structures de
dossiers À l'intérieur, nous avons un dossier d'
actifs qui contient des éléments tels que nos maillages, nos
textures et nos matériaux Nous avons un dossier de plans
pour notre code et notre logique, et un
dossier Maps pour nos niveaux Il s'agit d'une structure simple, mais elle s'adapte à
n'importe quelle taille de projet. L'autre chose que vous remarquerez peut-être si vous
parcourez certains dossiers concerne
des éléments tels que les conventions de dénomination
qui ont été choisies. Nous avons des éléments comme MM
Underscore Texture, qui signifie matériau
principal Nous avons alors le soulignement MI, quel que soit le but du matériau, et c'est une instance matérielle Si nous passons aux textures,
nous avons des choses comme notre héros de l'avion en T Underscore,
et c'est T pour texture L'endroit d'où je
suppose que toutes ces conventions
de dénomination ne sont pas aléatoires Ils sont tous basés
sur le style AA. Vous voulez le rechercher sur Google,
vous pouvez le trouver ici,
afin que nous puissions simplement
rechercher Style Guide, et nous
recherchons la page Github, la première étant juste ici Un lien pour cela se trouvera également dans la
description ci-dessous. Nommer les choses est
censé être
l'un des problèmes
les plus difficiles de l'informatique, et cela résout l'un de
ces problèmes pour vous. Je recommande de le mettre en favori
pour référence. Ensuite, chaque fois que vous
créez un nouveau type de ressource, si vous ne savez pas
comment l'appeler, vérifiez ici et, par répétition,
cela deviendra automatique. Mais c'est une très bonne
ressource. Il fournit à peu près
tout ce que vous pourriez souhaiter. Vous n'avez pas besoin de
tout mémoriser en même temps. Il y a pas mal
de choses là-dedans. Mais si nous examinons les conventions
générales de dénomination, nous avons des choses comme les
maillages squelettiques, ce serait SK Bob Le matériau pour Bob
serait M nscore Bob, texture pour Bob serait T
underscore Bob, et ainsi de suite Si vous regardez les plans, nous
avons des éléments tels que le soulignement BP, puis nous pouvons
également vérifier des éléments tels que la structure des fichiers et des
dossiers Donc, exactement comme je l'ai
mentionné ici, le nom du projet, puis tous les dossiers dans une configuration
quelque peu logique et
significative. Il s'agit donc vraiment de la meilleure façon
de structurer
vos projets, garder les choses en ordre et
de vous organiser au fur et à Pour commencer, nous avons besoin d'un niveau
principal pour travailler avec lui. Avant d'entrer dans le vif du sujet, il y a quelque chose
que je voudrais faire
et
vous présenter juste pour que vous puissiez
voir mon écran un
peu plus facilement, mais il peut également être utile que
vous le sachiez. Je vais donc accéder aux paramètres d'
édition juste ici haut de
l'écran et
accéder aux préférences de l'éditeur. C'est ici que nous pouvons
modifier différentes fonctionnalités concernant la présentation de
l'éditeur , les raccourcis,
les raccourcis clavier, etc., que vous
trouverez ici Ce que je
veux changer, c'est l'échelle de l'application ici. Je vais juste le
changer en 1,25. C'est uniquement parce que
j'ai
un écran assez grand, donc il peut sembler un peu
étiré et les boutons peuvent sembler un peu petits
pour que vous puissiez les suivre. Donc, comme je l'ai dit,
c'est facultatif, mais il est utile de
savoir que cela existe. Et il y a bien d'autres
choses que vous pouvez faire dans les
préférences de
l'éditeur pour modifier l'apparence générale de votre éditeur si quelque chose ne
vous convient pas Cela se sauvegarde automatiquement, donc je vais juste fermer
la fenêtre, et nous pouvons maintenant commencer à créer
notre premier niveau. C'est simple et agréable. Nous pouvons aller en
haut à gauche. Nous avons notre bouton Fichier, et nous avons la possibilité
de créer un nouveau niveau. Une chose à surveiller,
ce sont les raccourcis. Nous pouvons voir toutes
les touches de raccourci. Nous avons
tendance à beaucoup jouer avec les nouveaux niveaux . Il vaut donc peut-être
la peine de s' souvenir dès le début pour
vous faire gagner un peu de temps. Dans la nouvelle fenêtre, nous allons simplement
sélectionner le niveau de base, pas le monde ouvert. Cela va être bien trop complexe pour ce dont
nous avons besoin actuellement. De plus, le
chargement dans l'éditeur prend plus de temps à chaque
fois que vous lancez une sauvegarde. Nous allons donc double-cliquer sur Basic, et nous sommes maintenant dans
notre nouveau niveau de base. Ensuite, assurons-nous que nous l'avons également enregistré
correctement. Par défaut, cela
s'appelle Sans titre, qui
signifie que nous ne l'avons pas encore
enregistré. Ce n'est pas stocké. Si nous clôturons le projet et
revenons , nous perdrons notre progression. Nous allons donc appuyer sur
Ctrl en S dans
la fenêtre d' affichage ici, en
contrôlant S pour enregistrer Nous allons nous rendre dans le du didacticiel Shootm up,
dans le dossier Maps, et
nous appellerons celui-ci principal Nous pouvons donner le nom
juste ici. Appuyez sur Enregistrer ou sur Entrée, et
c'est automatiquement enregistré. Dans le tiroir de contenu, nous pouvons accéder à notre dossier Cartes, et nous pouvons voir que notre
carte est juste là. Chose rapide à noter. UnRel utilise le mot carte et le niveau de
manière interchangeable Même chose, deux noms différents parce que c'est le cas, bien sûr. Nous pouvons voir qu'ici, en
fait, cela s'appelle un niveau, mais lorsque nous l'
utiliserons plus tard, Unreal nous demandera de
définir une carte spécifique Une autre chose à noter et sur laquelle
nous travaillerons assez souvent est le tiroir de
contenu. Ainsi, plutôt que d'appuyer constamment sur
le bouton en bas à
gauche, nous pouvons appuyer sur Ctrl dans l'espace, ce qui activera le tiroir de
contenu pour l'ouvrir
et le fermer Et cette partie est
vraiment importante. C'est là que les débutants perdent
toujours leur travail, ou du moins ils
pensent le perdre jusqu'à ce qu'ils reviennent et
obtiennent de l'aide. Sans cette étape, vous fermerez votre projet, vous le rouvrirez et vous vous
retrouverez devant une carte du monde vide et
ouverte ou quelque chose
que vous ne vous attendiez pas à voir Votre étiquette
principale existe toujours, mais Unreal ne sait pas qu'elle
doit s' ouvrir par défaut Pour modifier ce
comportement, nous
allons donc accéder aux paramètres du
projet. Nous allons passer à la modification
, puis aux paramètres du projet. Sur le côté gauche,
dans la catégorie supérieure, nous voulons trouver l'option
cartes et modes. Et puis, sur le côté droit, vous voyez la carte de démarrage de l'éditeur. Modifiez cette liste déroulante du modèle par défaut à
la carte principale que nous venons de créer, et cela indique au moteur
Unrel quel niveau ouvrir lorsque vous lancez le projet pour la
première fois Nous pourrions également définir
la carte par défaut du jeu ici comme étant également principale. Cela détermine ce que
le joueur voit si vous emballez réellement le jeu et le
remettez à quelqu'un
d'autre pour qu'il y joue. Ces paramètres sont tous enregistrés automatiquement, nous pouvons
donc le fermer. Nous pouvons rouvrir le projet, ce qui signifie que
vous reviendrez exactement là où vous vous êtes arrêté
tant que vous aurez pu enregistrer la
carte sur laquelle vous travaillez Cela peut donc sembler beaucoup de travail
supplémentaire et beaucoup de discussions
rien que pour le premier sujet. Mais ces principes fondamentaux s'aggravent
vraiment. Un projet organisé restera gérable après
10 heures,
100 heures , voire 1 000 heures, alors qu'un
projet désordonné ne le sera tout simplement pas Et c'est vraiment
l'objectif et l'objectif de toute cette approche
basée sur les projets. Les choses peuvent prendre un
peu plus de temps, mais à la fin, vous aurez compris
ce que vous faites et espérons-le, vous aurez adopté
certaines bonnes pratiques pour rendre vos futurs
projets beaucoup plus intuitifs et
faciles à utiliser. Mais cela dit, les
bases sont bien établies. La structure du projet, la convention de
dénomination et les paramètres sont tous correctement
configurés. Le sujet suivant portera sur
la création de notre pion de joueur
, que vous
pouvez réellement contrôler Et comme je l'ai mentionné,
je veux que vous appreniez réellement ce que vous
faites au fur et à L'une des meilleures
façons d'apprendre n'est pas simplement de
suivre les étapes. Une fois que vous sentez que
vous comprenez quelque chose, essayez de l'étendre. Même pour quelque chose d'
aussi simple que celui que nous avons fait jusqu'à présent, ajoutez vos propres dossiers ,
renommez certains éléments et prouvez-vous
simplement que vous comprenez le
modèle, et pas seulement les étapes Je vous
guiderai à ce sujet tout
au long de ce que
nous faisons de toute façon, mais je ne peux pas
faire grand-chose, et une grande partie du travail
proviendra de l'auto-apprentissage. Si vous apportez des modifications
qui fonctionnent bien, indiquez-les dans les commentaires
et les discussions ci-dessous. Et si vous pensez avoir compris quelque chose et que vous voyez quelqu' un
poster une question à
laquelle
vous pensez pouvoir répondre,
essayez d'y répondre. Expliquer quelque chose
que vous venez d'apprendre est l'un des moyens les plus rapides
et les efficaces d'intégrer les
nouvelles informations et de vous assurer de ne pas les
oublier à l'avenir
3. 02 - PlayerPawn n: Les projets sont maintenant en place, et nous avons besoin de quelque chose pour réellement
commencer à les contrôler. À la fin de cette
rubrique, nous aurons un pion joueur avec des veillées.
Il ne bougera pas encore. Ce sera la prochaine étape, mais
nous allons comprendre exactement comment et pourquoi Unreal décide de créer
des objets et où L'un des éléments essentiels du
développement est de planifier à l'avance et de vraiment
réfléchir à votre objectif
actuel et à la
manière de l'atteindre. Donc,
d'après les vidéos,
nous savons simplement que nous
voulons contrôler ce petit personnage dans
un petit plan bleu, pour nous assurer que personne ne soit
laissé pour compte. Si vous êtes complètement
nouveau dans tout ce domaine, je ne veux pas vous lancer dans
un jargon complet Je vais donc vous montrer des choses
vraiment basiques. Le plan que nous examinons est ce qu'on appelle
un maillage statique. Donc, si nous passons aux maillages
des actifs, nous pouvons voir ici qu'
il s'agit d'un maillage statique de notre petit personnage
dans le plan bleu Nous voulons donc
contrôler cela. Si nous le mettions
directement dans le niveau, nous ne serions pas en mesure de
contrôler un maillage statique. Nous devons nous baser sur ce
code et utiliser un type de classe de plan au moins
un type de classe de plan
pour y parvenir. Dans Unreal, c'est ce que l'on
appelle un pion, quelque chose que nous pouvons
posséder ou contrôler, essentiellement un type d'
acteur spécial Allons-y donc
et créons
correctement notre pion avec notre bonne structure de
dossiers Je vais donc accéder à
notre dossier Blueprints. À l'intérieur d'ici, nous
voulons créer un nouveau dossier. Nous pouvons cliquer avec le bouton droit de la souris et
rechercher la nouvelle option de dossier ici. J'ai tendance à utiliser les
raccourcis
Control Shift et N pour y créer un nouveau
dossier. Donc N pour neuf. Je vais renommer
ce dossier en CR. Ce seront nos principaux
mécanismes de jeu ou fonctionnalités de jeu. Et puis, dans cette
grande structure de dossiers, si nous cliquons avec le bouton droit de la souris, nous voulons accéder à l'option de
classe de plan juste ici, ce qui nous permettra de
créer un nouveau plan, et nous pouvons voir une gamme d'options
différentes Et c'est là que
la compréhension de la hiérarchie des
classes d'Unreal peut commencer à aider Bref, tout ce qui se trouve dans UnRel hérite de
ce qu'on appelle un objet s'agit simplement d'un conteneur de données, la classe la plus simplifiée à
laquelle nous ayons accès. Nous voyons alors assez souvent
ce qu'on appelle un acteur. Dans le
niveau actuel, tout est à la base une classe d'acteurs. Nous aurons des acteurs à maillage statique, acteurs de
caméra, des acteurs de lumière, mais ce sont tous
des acteurs à la base. Ajoute une présence
physique au-dessus des données de l'objet
, à savoir un emplacement, une
rotation et une
échelle appelés transformation. Ensuite, les pions avec lesquels nous
allons travailler ne sont qu'un acteur doté des
fonctionnalités nécessaires. Vous verrez dans certains tutoriels qu'ils utiliseront plutôt ce que l'on appelle
une classe de personnage, qui serait
exagéré par rapport à ce que nous cherchons à faire
avec ce shoot them up. Les personnages incluent des éléments tels que mécanique de
marche, la gravité, collisions de
capsules,
des éléments vraiment conçus pour les personnages humanoïdes qui
se promènent à pied Nous allons
fabriquer un vaisseau spatial, donc nous n'avons pas vraiment
besoin de tout Et cela implique
beaucoup de frais supplémentaires
dont nous aurions besoin pour travailler activement. Vous pouvez donc voir d'autres didacticiels
créer des éléments tels une manette de tank utilisant
une classe de personnage, et c'est justement là que le fait d'
être conscient de
telles choses vous permettra de vous rendre compte
que ce n'est peut-être pas la meilleure solution pour ce que
vous essayez de créer. Comme les pions sont un acteur ou un type de classe
assez couramment utilisé, nous pouvons voir qu'ils se trouvent en fait
ici, dans la section commune Nous pouvons
donc cliquer dessus créer une nouvelle classe de
pions pour Et nous voulons l'appeler base de pions
BP Underscore, car ce sera
la classe de base toutes les classes liées aux pions que
nous créerons à l'avenir, ce qui nous
permettra de réutiliser partie de la logique pour
nos ennemis, nommant pour ce qu'
elle est en général, pas seulement pour ce qu'elle est
censée faire tout d'abord, qui fonctionnera en
tant que Avant d'aller plus loin, voici
une autre solution
rapide pour améliorer la qualité de vie. UnrelEngine a des opinions
bien arrêtées sur la gestion des fenêtres,
et elles sont généralement fausses Donc, pour corriger l'un des problèmes
qui vont se produire, si nous double-cliquons pour
ouvrir notre plan maintenant, cela créera simplement
une fenêtre flottante peu près n'importe où
sur l'écran Cela peut être très embêtant. Cela signifie que
Windows peut se perdre derrière d'autres applications
et autres choses de ce genre. Donc, si nous revenons aux préférences d'édition,
puis de l'éditeur. Même endroit que je
vous ai montré précédemment où j'ai modifié l'échelle de l'application. Comme je l'ai mentionné,
nous pouvons apporter
de nombreux correctifs et changements à la qualité de vie. Je veux le trouver sous l'emplacement ouvert de l'éditeur
d'actifs. Nous voulons changer
cela par rapport à la fenêtre par défaut, qui est ouverte n'importe où, et nous allons la
remplacer par la fenêtre principale. Vous pouvez essayer différentes
choses et voir celle qui vous convient le mieux.
J'aime
bien la fenêtre principale. C'est donc un peu comme travailler
dans un navigateur Web, où vous travaillez avec chaque nouveau fichier ,
plan, ressource, Chaque fois que vous ouvrez une nouvelle fenêtre, un nouvel onglet
est créé et
ancré comme des
signets en haut de la Encore une fois, cela est
enregistré automatiquement, nous pouvons le fermer, retourner dans le tiroir de contenu, puis double-cliquer
à nouveau pour ouvrir la base du volet. Vous pouvez voir que cela s'ouvre ici, et c'est exactement ce que je voulais. Si vous avez fait la même chose que moi, où vous l'avez peut-être
ouvert deux fois, vous serez peut-être accueilli par cette vue
simplifiée contenant uniquement des données. Et c'est parfaitement bien.
Il n'y a pas lieu de paniquer. Il s'agit de tous les détails du cours qui nous
sont présentés essentiellement
sous forme de texte ou de liste déroulante. Pour revenir à l'éditeur de plan
complet, nous voulons simplement cette ligne
bleue de texture, l'éditeur de plans ouvert à quatre, qui nous ramènera là où nous voulons être OK, il y a donc beaucoup d' informations que je pourrais vous
communiquer en ce moment, mais vous en
oublierez probablement la plupart. Nous allons donc adopter une méthode
plus organique et naturelle
pour apprendre le moteur irréel Nous allons simplement
travailler avec de nouvelles fonctionnalités, et je les présenterai au
fur et à mesure
qu'elles deviendront pertinentes. La première chose que nous pouvons
voir pour le moment, c'est que nous sommes dans le graphique des événements dans
cet onglet juste ici. C'est là que nous
plaçons notre logique et code. Nous
reviendrons ici plus tard. Pour l'instant, si nous cliquons
sur le point de vue, nous pouvons regarder autour de nous
et voir à quoi ressemblera notre
classe de blueprint Les classes Blueprint sont généralement composées de différents composants, chacun ayant ses propres
caractéristiques et fonctionnalités Sur le côté gauche, nous pouvons
voir le panneau des composants, et nous voulons ajouter notre
représentation visuelle ,
ce maillage statique. Donc, si nous appuyons sur ad et
recherchons un maillage statique, nous pouvons
le voir juste ici. Ce sera
la première partie
du puzzle que nous allons
essayer de résoudre. fois le maillage statique sélectionné, sur le
côté droit de la fenêtre, nous pouvons voir notre panneau de détails. Cela nous dit tout sur le composant que nous avons
actuellement sélectionné. Nous pouvons voir que nous avons
ici une liste déroulante pour le maillage statique, et c'est la représentation
visuelle que nous voulons définir. Nous savons que nous voulons que ce
soit l'avion bleu Nous trouverons
donc le héros de l'avion
et nous sélectionnerons celui-ci. Dans cette fenêtre, j'
utilise simplement la molette de la souris
pour faire défiler l'écran vers l'avant et vers l'arrière. Si nous appuyons sur Alt et que nous cliquons avec le bouton gauche, nous pouvons faire glisser le pointeur
et afficher le modèle, et si nous appuyons sur le clic droit
et faisons glisser le pointeur autour de la souris, nous pouvons changer ce que nous regardons. Cliquez au milieu de la souris et déplacez Will Dolly ou Pan, je
pense que c'est une question. Et ce sont
les bases de la
navigation dans
cette fenêtre et
aussi dans la fenêtre du monde
plus tard, lorsque nous aborderons la construction de
niveaux et d'
autres choses de ce genre navigation dans
cette fenêtre et
aussi dans la fenêtre du monde
plus tard, lorsque nous aborderons la construction de
niveaux et d' autres choses Il est également utile de
savoir que si vous appuyez sur F lorsque vous avez
sélectionné quelque chose, vous vous concentrez dessus. C'est donc F pour focus. Maintenant, ce que nous venons de
créer est notre maillage statique, et nous pouvons voir dans
le panneau des composants que nous avons ce qu'on appelle
une racine de scène par défaut. Cela montre la structure de l'
acteur, et chaque acteur a besoin d'
au moins une racine de scène par défaut, un point dans l'espace où
tout le reste est attaché. La racine de scène par défaut que nous
avons n'est qu'un espace réservé Nous pouvons
donc récupérer notre maillage statique, et nous pouvons faire glisser notre maillage statique sur la
racine de scène par défaut et lâcher prise Donc, jambe gauche, nous avons créé notre maillage statique, ce que on
appelle
le composant racine,
c'est-à-dire l'élément de base de notre classe de
joueur ou de notre pion Autre chose, lorsque
nous arrivons à un stade où nous pensons
être plutôt satisfaits des progrès réalisés, nous devons nous assurer de
prendre l'habitude de compiler et de sauvegarder. Cela garantit simplement
que si quelque chose panne, nous
ne perdons pas notre travail Et en compilant, nous vérifions simplement les erreurs et
détectons les choses rapidement Nous avons donc maintenant notre
pion avec des visuels. Mais bien sûr, si nous
appuyons sur Play, nous ne le verrons pas pour l'
instant car nous n'avons pas demandé au moteur
Unreal de l'utiliser Et nous pouvons utiliser une entrée de jeu standard à la
première personne ici. WAS et D vous feront donc
voyager. Q et E
vous déplaceront de haut en bas, et bien sûr, la
souris regardera autour de vous. Mais, bien entendu, ce n'est pas tout à fait la fonctionnalité que
nous recherchions. Dans le sujet suivant,
nous allons donc résoudre ce problème en examinant le framework de jeu
du moteur Unreal Nous indiquerons au moteur
Unreal exactement ce qu' générer et où
nous voulons qu'il apparaisse Encore une fois, si vous
expérimentez par vous-même, ce que je recommande toujours, essayez ajouter d'autres composants
à la classe pawn Quelque chose d'
aussi simple qu'une lumière ponctuelle, un système de particules par défaut, juste pour voir ce qui
se passe lorsque vous attachez éléments à différentes
parties de la hiérarchie. C'
est vraiment ce genre d'expérimentation qui vous permettra de
faire en sorte que tout fonctionne.
4. 03 - Cadre de jeu: Une fois le pion créé,
nous avons appuyé sur jouer, et nous avons déjà vu
qu'en mode jeu, nous finissons par
contourner ce que
l'on appelle le pion par défaut. Nous
devons donc changer cela. Unreal spawns est par défaut et a complètement ignoré la
classe que nous avons créée Pour résoudre ce problème correctement, nous
devons réellement comprendre comment framework de
jeu d'Unreal
décide quoi générer,
où, puis nous pouvons lui dire quoi
faire Donc, pour commencer, un petit aperçu
du concept,
encore une fois, laissez-moi vous montrer ce qui se passe réellement dans les
coulisses. Tout d'abord, je
vais retourner dans la fenêtre principale et appuyer sur Play. À l'intérieur de Playode, c'est
ici que nous pouvons voler. Il est très
utile de savoir que vous pouvez appuyer sur la touche F 8 pour vous éjecter du jeu Je suis donc toujours en mode jeu. Mais je ne contrôle plus
la pornographie par défaut. Je suis maintenant essentiellement de
retour en mode éditeur Je peux
donc utiliser WAS et D, cliquer avec le bouton
gauche de la souris pour regarder autour moi
et voir ce
qui se passe pendant le jeu. Si nous regardons le plan
sur le côté droit, nous pouvons voir ce que l'on
appelle Default Porn Zero C'est ce que nous
avons réellement contrôlé dans le niveau. Et en fait, tout ce qui est
surligné en jaune ici a été créé par le framework de jeu UnrelEngine Nous n'avons placé aucun de
ces éléments dans le niveau. Ainsi, lorsque nous appuyons sur Play, UnRel
suit une chaîne spécifique. Tout d'abord, il
vérifiera s'il existe un mode de jeu, et si vous n'en avez pas défini un,
il utilisera une option par défaut. Le mode de jeu
décidera ensuite du pion à faire apparaître. Et encore une fois, si vous
n'en avez pas spécifié un, il utilise le pion par défaut
, littéralement
appelé pion par défaut Et c'est ce que
nous contrôlons actuellement au lieu de notre avion, car nous n'avons jamais demandé à Unreal d'utiliser
cette classe d'avion Appuyons donc sur Escape
pour quitter le mode de jeu, et nous pouvons commencer à prendre
le contrôle de notre projet. De retour dans le dossier principal. Donc, si vous n'êtes pas vraiment
là, les plans trouvent au
cœur du tiroir de
contenu Nous voulons créer une
nouvelle classe Blueprint Comme précédemment, cliquez avec le bouton droit de la souris et passez à la classe Blueprint Et cette fois, nous voulons créer une base de mode de jeu unique. Je vais donner à celui-ci le nom de la base du mode de jeu
BP Underscore Et un mode de jeu est essentiellement quelque chose que nous pouvons considérer comme un détenteur
de règles. Il indique à NRLEngine
les classes à utiliser pour tout
, le pan à générer, le
contrôleur à utiliser, Hud à afficher, etc. Si nous double-cliquons pour
ouvrir notre mode de jeu, nous pouvons voir
que cela ressemble un peu à un plan normal Nous pourrions accéder à la section du graphique des
événements du code si nous le voulions, mais tout ce que nous
voulons se trouve en fait sur le côté droit
dans le panneau de détails. Nous pouvons voir ici les
éléments que je viens de mentionner, les types de
contrôleurs Hud par défaut sont tous
exposés ici Ce que nous
recherchons, c'est notre
cours de pornographie par défaut, juste ici. Nous pouvons le supprimer et
le remplacer par base pornographique BP Underscore C'est à peu près tout ce que nous
devons faire ici. Nous pouvons appuyer sur Compiler et enregistrer pour nous assurer que tout
est mis à jour. Et nous pouvons en fait fermer
le mode jeu pour le moment. Je vais rester ouvert pour donner un exemple visuel de
quelque chose dans un instant, mais c'est à
peu près tout ce que nous devons
faire dans notre mode de jeu. Comme on pouvait s'y attendre, il ne suffit pas de
créer le
mode de jeu. Nous devons maintenant demander au projet de l'
utiliser réellement. Donc, si nous revenons l'option d'édition en
haut à gauche, nous allons revenir aux paramètres
du projet. Et nous sommes en train de
revenir à ce que nous étions auparavant, à savoir la section des cartes
et des modes. Vous pouvez voir sur le côté
droit
que le mode de jeu par défaut est juste un mode appelé
Game Mode base. Et si nous le déposons ici, nous pouvons réellement voir
ce qu'il utilisait. Il utilisait donc une classe Hod
par défaut, la classe de pion par défaut, celle que nous nous sommes littéralement vus voler, la manette du joueur
par défaut, etc. Nous ne pouvons pas
les modifier, c'est pourquoi nous avions besoin d'une
classe personnalisée avec laquelle travailler. Si nous supprimons cette option, nous pouvons la remplacer par la base du mode de jeu BP
Underscore Nous pouvons voir que cela est maintenant libéré. Et le plus important, c'
est que cela a maintenant changé pour devenir notre base de
pions BP Underscore La seule chose que je voulais vous
montrer très rapidement, c'est que si je modifiais cela ici,
je pourrais supprimer celui-ci. Je vais le changer pour quelque chose de
complètement unique. Nous l'avons remplacé
par le personnage Arc Vz. Nous pouvons effectivement voir que
la classe de mode de jeu que nous avons créée
en arrière-plan, c'est-à-dire notre base de mode de jeu BP
Underscore a été mise à jour en arrière-plan
pour devenir également Arc Vz Si nous cliquons dessus
ici et que nous le
remplaçons à nouveau
par BP Underscore Pawn Base, je voulais juste
souligner qu'
ils sont complètement connectés maintenant Donc, si nous changeons quelque chose
ici, cela sera mis à jour dans notre classe Blueprint Et si nous changeons quelque chose
dans notre classe Blueprint, cela changera dans les paramètres de
notre projet si nous l'avons connecté juste
ici Une fois cela fait, nous pouvons
fermer les paramètres du projet, nous
assurer de compiler
et de sauvegarder le mode de jeu. Si vous
jouez avec des objets, revenez au niveau principal, appuyez sur play, c'est-à-dire O et P, le raccourci pour entrer en mode jeu. Et nous sommes en quelque sorte
dans l'avion maintenant. En fait, nous sommes
littéralement dans l'avion. Encore un problème à résoudre,
mais on s'en rapproche. Si vous avez placé des objets manuellement plus tôt entre les deux, si vous
jouez avec des objets, il
se peut que vous ayez d'autres avions
dans le niveau. Assurez-vous de vous en débarrasser pour éviter toute confusion, mais nous pourrons en quelque sorte
voir ce qui se passe. Nous appuyons sur Play, nous
passons en mode jeu, puis si j'appuie sur la touche F
8 pour revenir en
arrière, vous pouvez voir qu'un avion
a maintenant été créé que nous pouvons contrôler Le principal problème, c'est que
nous sommes dedans. Je voulais juste souligner
une autre chose qui se passe avec le framework de
jeu, savoir l'utilisation
de notre point de départ pour les joueurs. Vous pouvez donc le voir
juste ici dans le niveau. Et dans l'aperçu, on peut voir cela s'appelle ici
le joueur Start C'est ce que le framework
recherchera pour confirmer où vous
souhaitez réellement faire apparaître le pion que
vous souhaitez contrôler Donc, si je le déplace
quelque part très loin en arrière, je le déplace jusqu'à
l'espace ouvert d'ici. Si j'appuie sur Play, nous sommes
toujours en train de faire apparaître l'avion, mais nous apparaissons maintenant au
grand jour Encore une fois, quelque chose d'
utile à savoir. Si nous n'en avons pas, nous pouvons les supprimer, mais Unreal doit maintenant deviner où nous voulons
faire apparaître notre truc Et il ne s'agit pas vraiment
de deviner juste pour
montrer ce qui se passe
dans ce scénario Si je me déplace dans la fenêtre d'affichage, j'utilise à nouveau le clic droit de la
souris pour regarder autour , puis W AS et D pour voler en
fonction de l'endroit où je regarde Si j'appuie sur Play, nous pouvons voir que l'avion
va juste afficher la dernière position de ma
caméra dans le viseur Encore une fois,
je viens de voir de
nouveaux développeurs faire trébucher les nouveaux développeurs parce que ce que faisait le
joueur au départ n'est peut-être pas très clair, surtout si vous travaillez sur
un projet où vous pourriez
avoir un personnage à la troisième ou première personne
avec gravité, vous travaillerez dans
le niveau, vous
concevrez certaines choses,
vous appuierez sur Play, puis vous
tomberez soudainement dans l'espace, évitant
complètement le niveau et vous serez un peu confus. Et c'est simplement parce que
vous vous êtes probablement débarrassé de votre point de départ en tant que joueur. Unreal ne savait pas où créer
votre personnage par défaut, il a
donc choisi le dernier endroit où
vous vous trouviez dans l'éditeur Si vous avez suivi
cette page, nous pouvons cliquer sur le bouton Ajouter en haut de la page. Nous pouvons rechercher un
joueur de départ juste ici, et nous pouvons simplement en
renvoyer un dans le niveau. Génial et facile, nous sommes
revenus là où nous étions. Il ne reste donc qu'un problème c'est que nous cherchons
au mauvais endroit. Cela signifie simplement que
nous avons besoin d'une caméra et nous devons indiquer à Unreal
laquelle utiliser Pour ce faire, nous devons revenir
à
la base de pornographie BP Underscore Si vous ne l'
avez pas vraiment ouverte,
souvenez-vous de cela dans
le tiroir de contenu, alors contrôlez l'espace et
double-cliquez sur la classe de base pornographique. Comme je l'ai mentionné, la plupart
des classes sont simplement
composées de nombreuses quantités
de composants, chaque composant essayant de remplir un rôle ou un cas d'utilisation spécifique. Dans ce cas, nous voulons
qu'un composant
de caméra examine notre correspondance statique. Avant d'ajouter un appareil photo,
je vais ajouter ce on appelle un bras à ressort juste
pour les présenter. Donc, si nous appuyons sur l'annonce ici, nous pouvons rechercher un bras à ressort.
Nous allons cliquer pour l'ajouter. Et il s'agit essentiellement
d'un bâton qui
tiendra la caméra à
une distance fixe. Il peut également gérer
des problèmes tels que les collisions, le
fait de
rapprocher la caméra lorsque nous
heurtons des murs et d'
essayer d'éviter des objets. Nous n'aurons pas besoin de ce niveau de
complexité pour notre jeu, mais il est utile de savoir
que ces fonctionnalités existent. Une autre utilisation très pratique
du bras à ressort est qu'il
nous évite d'avoir à
affecter directement le décalage, la position et la
rotation de la caméra. Nous allons donc le conserver
uniquement pour ces raisons. Le bras à ressort étant
toujours sélectionné, nous allons revenir
au bouton Ajouter. Nous allons
chercher une caméra. Et nous voulons sélectionner la caméra
par défaut ici en haut. Vous pouvez voir qu'il
est juste placé sur la caméra à la fin
du ressort, euh. Cela nous laisse un
peu de temps pour nous concentrer sur le moteur
Unreal et la façon dont
il traite la hiérarchie Nous avons déjà
examiné le fait que le maillage statique est désormais
considéré comme la racine du joint Ainsi, quel que soit l'endroit où passe la racine du joint, tout le reste
suit, y compris la rotation, l'emplacement et l'échelle Le ressort um est alors classé comme un enfant du maillage statique, et la caméra est un
enfant du ressort um Cela signifie donc que si je saisis le composant Spring um et modifie
ensuite quelque chose
dans la rotation, par
exemple, je sais que
je veux que la caméra regarde à 90 degrés vers le bas sur
le maillage statique. Ce sera -90 degrés. Nous pouvons voir que la
caméra hérite cette rotation que j'ai
donnée au ressort, euh Je vais agrandir le ressort, donc je vais
verrouiller l'emplacement, et je vais en faire une taille
de dix, nous pouvons voir que la caméra devient
également dix fois plus grande. Maintenant, nous ne redimensionnons pas la caméra
et le ressort de cette façon, mais je voulais juste
montrer comment
fonctionne la hiérarchie dans Unreal
avec les composants Cependant, nous voulons la
rotation de la caméra Je recommande
donc une rotation
d'environ -90, afin que la caméra
regarde droit
vers le bas sur le joueur Si nous appuyons sur Play, nous pouvons voir à
quoi cela ressemblera. Donc, peut-être un peu trop près, il pourrait être
difficile de voir
ce qui se passe
avec les ennemis
et les projectiles pendant le et les projectiles pendant Le Spring Hum a
une autre fonctionnalité qui nous y aidera C'est ce qu'on appelle la longueur de bras
cible, et vous pouvez le voir à nouveau
dans le panneau de détails. Ainsi, comme je l'ai mentionné,
avec le maillage statique, lorsque nous avons sélectionné
quelque chose, le panneau de détails contient uniquement toutes
les informations sur les composants que vous
avez actuellement sélectionnés. Le bourdonnement de printemps a
cette valeur appelée longueur de bras
cible,
qui est cette ligne rouge, et nous pouvons la régler à
environ 1 200,
ce qui correspond à peu
près à ce que nous voulons Nous pouvons donc appuyer sur
Play, et
nous pouvons voir un peu
plus de l'écran. Nous
reviendrons de toute façon pour peaufiner ce genre de
choses un
peu plus tard. Mais pour le moment, tout
ira parfaitement bien. Encore une fois, lorsque vous aurez apporté
des modifications qui vous conviennent, assurez-vous que nous appuyons sur
Enregistrer, et cela ressemblera un peu plus
à un jeu de tir du haut vers le bas. Donc, si vous nous avez
suivi et prêté attention, nous avons maintenant vu que
si nous ne disons pas au moteur Unreal
quelle carte utiliser, il utilise une carte quelque peu aléatoire Si nous ne lui
indiquons pas le mode de jeu à utiliser, il utilise un mode de jeu par défaut. Et si vous ne lui dites
pas quel pion utiliser, il utilise un pion par défaut Mais vous avez probablement
remarqué que nous ne
lui avons pas indiqué quel appareil photo utiliser, mais qu'il sait qu'il doit utiliser l'
appareil photo que nous venons d'ajouter. Cela enfreint donc en quelque sorte cette règle que j'ai
soulignée. Dans ce cas, cependant,
cela dépend toujours du comportement du
framework de jeu. Lorsque le framework possède un pion pour la
première fois, il examine l'intérieur
de cette classe et vérifie la présence de composants de
caméra Je simplifie
un peu les choses, mais c'est essentiellement le
processus qui est suivi S'il trouve une caméra,
il l'utilisera par défaut. S'il ne trouve pas de
caméra dans votre hiérarchie, il créera
une caméra par défaut, et
il
se trouve que la position à laquelle il la place est zéro,
qui dans notre cas se trouve directement à l'intérieur
du maillage plan, c'est pourquoi nous avons
examiné l'intérieur du corps. Encore une fois, nous pouvons maintenant comprendre pourquoi nous regardions l'intérieur de
l' avion et comment
nous avons annulé cela pour regarder l'avion
vers le bas Mais c'est le même schéma que
tout le reste. Le framework a ses processus
par défaut, et l'important est que nous soyons désormais plus conscients que nous avons la
possibilité de
les remplacer ou de vivre avec eux. Cela fait, nous
contrôlons désormais ce qui apparaît, où il apparaît et quelle
caméra nous regardons Le cadre fonctionne pour
nous plutôt que contre nous. Et encore une fois, vous serez peut-être
surpris du nombre de personnes qui
finissent par travailler contre le cadre
pendant assez longtemps. autre chose que je connais
bien lorsque les
étudiants se lancent
tête baissée dans des projets Quand je pourrai
voir le projet,
après avoir travaillé
dessus pendant un certain temps , ils auront trouvé des solutions pour le
visionner à travers
des caméras spécifiques,
forcer le
déclenchement de pions à certains moments,
détruisant ainsi le cadre et le combattant au
lieu de fonctionner visionner à travers
des caméras spécifiques, forcer le
déclenchement de pions à certains moments, détruisant ainsi le cadre et le combattant au
lieu mesure du possible, nous pouvons utiliser un grand nombre de ces bases du framework, et elles nous aident
plus qu'elles ne nous gênent. Bien sûr, nous
n'avons toujours pas bougé. Nous n'avons actuellement
qu'un pion assis là et une
caméra pour le regarder Ce serait donc la prochaine étape
, ajouter du mouvement. En fait, je vais
d'abord vous montrer la mauvaise façon d'ajouter du mouvement car c'est ce que vous verrez dans de nombreux tutoriels. Après avoir vu cela, je
vais vous montrer comment résoudre ces problèmes, afin que vous
sachiez à quoi faire attention. Si vous voulez expérimenter à nouveau, la petite recommandation, bien
que nous
en soyons encore à un stade précoce, serait essayer de régler la distance ou l'angle de la
caméra, peut-être d'opter pour une configuration
légèrement
différente l'angle sous lequel vous
regardez l'avion. Vous pouvez ajouter une deuxième caméra et voir ce qui se passe.
Lequel choisit-il ? Et si vous faites ce
genre de choses, commencez par
essayer de décrire ce que vous remarquez que fait
le framework, ce à quoi
vous ne vous attendez pas
ou ce que vous
comprenez en quelque sorte à ce sujet
5. 04 - LegacyInput: Avant que le joueur
ne puisse bouger, Unreal doit savoir sur quoi
le joueur appuie Cela peut être des touches du clavier, des
manettes, des déclencheurs. Tout cela passe par
le système de saisie. Unre prend ces liaisons et les convertit en valeurs d'entrée, et nous les lisons pour
notre système de mouvement La première étape
sera donc de comprendre comment ces valeurs fonctionnent réellement. Pour commencer, nous allons le
faire par
le biais de l'ancien système de saisie
qui est un peu démodé. Pour les trouver, nous
voulons revenir aux paramètres de notre projet. Nous allons donc passer aux paramètres de
modification et de projet. Nous allons descendre un
peu plus bas qu'auparavant. Et nous pouvons voir ici que nous
avons la section de saisie. Comme je l'ai mentionné, c'
est un peu démodé, et il y a même un
avertissement concernant le fait que l'ancien système de saisie est
désormais obsolète.
C'est très bien Il est toujours utile de le savoir
car vous
rencontrerez probablement des projets
qui l'utilisent encore. De nombreux exemples et projets utilisent toujours ce système. Il y a deux
types de saisie différents ici. Nous avons nos
mappages d'actions, qui sont binaires. Ils sont
pressés ou non, parfaits pour des choses comme tirer, interagir, sauter, etc. Nous avons ensuite nos mappages d'axes, convertissent
l'entrée du joueur en valeurs à virgule
flottante continues Parfait pour bouger.
C'est pourquoi nous allons ajouter un
nouveau mappage des axes juste ici, et nous appellerons
celui-ci move right. Comme nous avons
ici
cette valeur d'échelle que nous pouvons modifier fonction
des différentes entrées que nous fournissons, nous l'
appellerons move right. Il contrôlera également le
déplacement vers la gauche
en donnant à l'autre entrée
une valeur négative. Dans cette liste déroulante, nous pouvons
trouver toutes les entrées que nous voulons. Cela peut être vos pressions sur
le clavier, la souris, la manette de jeu, quel que soit
le cas Voici une chose que je ne
savais pas depuis trop d'années lorsque j'utilisais le moteur
Unrel C'est en fait un bouton.
Si nous cliquons dessus et appuyons sur la touche D , par
exemple, la
saisie suivante sera suivie par D, ce qui serait parfait
pour se déplacer vers la droite. Si nous appuyons sur le bouton plus,
nous pouvons ajouter une autre reliure. Je vais appuyer à
nouveau dessus, puis appuyer sur A, donc nous avons maintenant notre mouvement
vers la gauche La seule chose que j'ai
mentionnée est que par défaut, il s'agit
d'une valeur positive. Si nous changeons cela en une valeur
négative, donc moins un, cela permettra à l'entrée nous
déplacer vers la
gauche Si vous souhaitez
lier différentes clés à la même liaison d'entrée, nous pouvons simplement en ajouter deux
autres à titre d'exemple. Nous pouvons en ajouter une pour
la flèche droite et une pour la flèche gauche. Encore une fois, lorsque nous nous déplaçons vers la
gauche, nous voulons simplement nous
assurer d'ajouter la valeur
négative à celle-ci. Système simple et
suffisamment flexible pour ce que nous
devons faire en ce moment. Comme pour tout le
passé, cela est
automatiquement enregistré afin que nous puissions fermer
les paramètres du projet, retourner dans le tiroir de contenu, utiliser à
nouveau le contrôle dans l'espace pour récapituler
le raccourci et retourner
dans la base pornographique Si vous êtes toujours dans la fenêtre
d'affichage, nous allons maintenant passer
à l'onglet
du graphique des événements Donc, celui que
j'ai mentionné, c' est là que
va aller notre logique, et c'est ce que nous allons
faire immédiatement. Ici, nous pouvons
déjà voir quelques nœuds différents dans le graphique,
et je fais simplement cliquer avec le bouton droit de la souris
et faire glisser le pointeur pour me déplacer Tout d'abord, nous pouvons voir que nous avons
notre nœud de début de jeu, et cela ne s'applique qu'une seule fois
lorsque nous appuyons sur Démarrer Ci-dessous, notre événement est
coché tout en bas, et cet événement se déclenche en continu pendant que
le jeu est en cours. Vous entendrez peut-être des gens
dire des choses comme « nous évitons à tout prix d'utiliser Event
Tick », mais cela
simplifie légèrement Pour des fonctionnalités telles que le mouvement, lorsque nous
voulons qu'il soit fluide et réactif, ou le mouvement de la caméra, la physique, etc., c'
est exactement là que la
logique doit se situer. Nous devons simplement nous
assurer garder propre et efficace. Enfin, nous avons l'action
événementielle qui commence à se chevaucher. Il s'agit d'un contrôle de chevauchement, d'un contrôle de collision pour
l'ensemble de la classe. Dans notre cas, cela peut être
n'importe quoi, qu'il s'agisse
du maillage statique, du composant Spring um
ou du composant caméra. C'est un peu vague, donc j'ai tendance à ne pas l'utiliser et nous
traiterons les collisions par
composant plus tard. Nous pouvons donc récupérer celui-ci, appuyer sur Supprimer, et
nous nous en débarrasserons. Pour montrer à quoi sert le mappage des
axes, nous allons nous déplacer légèrement vers le
bas clique
donc avec le bouton droit de la souris et je fais
glisser le pointeur pour déplacer le graphique Cliquez ici avec le bouton droit de la souris,
et nous allons
rechercher la liaison d'entrée que nous avons
créée il y a un instant. J'ai appelé le mien Move Right. Nous avons deux
options différentes ici. Nous avons l'événement de l'axe
et la valeur de l'axe. L'événement créerait quelque chose qui
ressemble beaucoup à l'eventic fournissant cette épingle d'exécution afin que nous puissions en tirer
la logique future La différence avec
la valeur de l'axe est si nous cliquons sur celui-ci. Cela fournit juste
cette épingle verte. Cette épingle verte est une valeur flottante
ou décimale,
et elle fournira
une valeur et elle fournira en fonction de l'élément sur lequel
nous appuyons Si on n'appuie sur
rien, on obtient zéro. Si nous appuyons sur la gauche,
nous obtenons moins un, et si nous appuyons sur la
droite, nous obtenons un positif. Je peux vous le montrer dans une démonstration très simple, et je le recommande à tous ceux qui apprennent de nouvelles parties
du moteur Unreal Nous allons extraire
cette épingle d'exécution ici, faire glisser dans le
graphique et lâcher prise, puis nous allons
rechercher la chaîne d'impression du mot. Cela va donc simplement fournir un message de débogage sur notre écran,
sur le côté gauche,
si nous appuyons sur Play Nous pouvons donc voir qu'ici
est en train spammer la fenêtre
avec le mot bonjour Maintenant, pour éviter que cela ne soit
spammé car il s'exécute 120 fois par seconde, nous voulons le supprimer, changer la durée
à 2 secondes. Il est actuellement en cours
d'impression pendant 2 secondes, et nous allons le remettre à zéro. Cela devient alors une impression plus
constante ici, il
ne reste plus qu'à
imprimer le mot bonjour. De toute évidence, nous ne
voulons pas que cela vous dise bonjour. Nous voulons que cela nous montre
ce qui fait l'objet de pressions. Je vais donc prendre
la valeur flottante ici, tirer de cette épingle et la déposer
dans la chaîne de caractères. Le moteur Unreal
est suffisamment intelligent pour convertir automatiquement notre float en une chaîne de texte
afin que ce biais soit lisible Donc, si nous appuyons sur Compiler
et rejouer, vous pouvez voir
que cela imprime zéro, car je n'
appuie sur rien du tout. Si j'appuie sur la flèche gauche, elle affiche moins un, sur
la flèche droite, j'obtiens un positif et
pareil pour A et D. Nous pouvons donc voir que cela fonctionne. Il se passe
quelque chose ici. L'impression de la valeur
montre donc les données, mais il ne s'agit toujours
que d'un chiffre en ce qui nous concerne. Faisons donc quelque chose très rapidement pour que cet
effet soit visible. Nous n'allons pas ajouter de
mouvement pour l'instant. Nous allons aborder un
sujet distinct. Mais si nous tirons de notre chaîne
d'impression cette épingle d'exécution ici et recherchons set Act
scale three D. Nous voulons que ce nœud soit juste là, et tout ce que nous allons faire,
c'est affecter l'échelle globale de notre acteur en fonction de la
direction dans laquelle nous appuyons. Pour ce faire, nous allons
juste avoir besoin d' un tout petit espace entre les deux. Je suis donc en train de déplacer quelques
nœuds par ici. Nous allons faire en sorte que les
calculs soient vraiment très simples. C'est complètement
jetable et c'est juste pour visualiser certaines parties
du concept ici Nous pouvons
cependant prendre l'échelle trois D de notre
acteur défini, et nous pouvons contrôler cela en fonction de la direction dans laquelle
nous appuyons. Nous pouvons donc faire en sorte que l'échelle de l'acteur soit zéro moins un ou un. Et si nous ajoutons une entrée analogique, nous pourrions rendre
cette valeur vraiment simple. Nous allons prendre notre action d'
obtention que nous valorisons ici, donc je vais prendre ceci, appuyer sur Ctrl en D pour le dupliquer. Et nous allons juste
le brancher ici. Donc, comme je l'ai dit,
vraiment très simple. Cela ne sera utile pour aucun type de scénario d'
utilisation réel. Je voulais juste vous
familiariser
un peu avec le plan
avant de passer au mouvement Mais si nous appuyons sur compiler,
cela garantit simplement que tout a été vérifié
pour détecter les erreurs et qu'il fonctionne .
Appuyez sur Enregistrer pour ne
rien perdre de la progression. Et je pense que
je vais revenir à l' édition
, puis aux paramètres
du projet. J'ai connecté ma manette de jeu, et si nous revenons
à la section de saisie, pour ajouter
une nouvelle entrée ici, cliquez sur ce bouton, et je
déplace simplement le
stick analogique vers la gauche Donc, le stick analogique gauche, je l'ai déplacé sur l'axe X,
qui est à gauche et à droite. Nous pouvons laisser ce nombre
positif si nous
voulons inverser le mouvement
analogique Ainsi, par exemple, si je tire vers la
gauche, je me déplacerai vers la droite. C'est pourquoi nous souhaiterons peut-être
ajouter une valeur négative. Mais comme l'analogue possède
une gamme complète de mouvements et qu'il est suffisamment intelligent pour savoir prendre la bonne
direction en positif, la direction gauche
recevra automatiquement cette valeur négative. Nous pouvons donc clore ça. Nous
pouvons passer en mode jeu Nous avons en quelque sorte cassé l'
avion en ce moment. Donc, pour le moment, nous
imprimons zéro en haut. Cela signifie que nous passons
le chiffre zéro dans les X, Y et Z de l'échelle de notre plan, c'est
pourquoi nous ne pouvons pas le voir. Si j'appuie sur A, alors nous
inversons la taille Nous voyons
donc le
bas parce que nous allons maintenant
planer l'échelle
de cette valeur négative Et si j'appuie sur D, nous rendons l'échelle de l'
avion positive. La raison pour laquelle je veux
utiliser le stick analogique est que nous pouvons le visualiser un peu plus afin que je puisse obtenir des mouvements fluides en
déplaçant simplement le stick analogique. Si vous voyez le chiffre en
haut, il se situe entre zéro et moins un parce que je me
déplace vers la gauche. Et si je le déplace vers la droite, on passe entre
zéro et plus un. Donc, juste une sorte de visualisation
de la façon dont nous pouvons
utiliser ces valeurs et
les intégrer dans une logique
vraiment simple. Encore une fois, nous assistons à
une autre conversion. Cela prend la
direction de notre mouvement, donc moins un, zéro ou un, en la
multipliant par toutes
ces propriétés d'échelle Donc, les
propriétés de l'échelle sont irréelles. Vous avez le X, le Y et le Z. Juste pour visualiser cela comme
quelque chose de simple, comme un cube Je vais venir ici juste
pour te montrer ça. Si nous voulions
modifier les propriétés ou l'échelle de cet objet, nous pourrions utiliser uniquement l'axe X, et vous pouvez constater qu'il
s'allonge. Nous pourrions effectuer une mise à l'échelle sur
l'axe y pour l'élargir. Et encore une fois, nous pouvons modifier l'axe
z pour le rendre plus grand. tellement sympa et simple, et c'est
vraiment tout ce que nous faisions ici dans le code, mais nous
ne faisons que normaliser les sont donc tous nuls, moins un ou un,
en fonction de l'entrée. Donc, comme je l'ai dit, code
complètement inutile, un jetage
complet, mais j'espère que cela rendra
l'entrée et la façon dont nous pouvons utiliser cette valeur un
peu plus compréhensibles. Cela fait, nous avons confirmé que notre saisie fonctionne. La pornographie elle-même ne bouge toujours pas. Cette partie sera
la prochaine à venir. Et dans la
vidéo suivante, nous allons transformer cette entrée en un
véritable mouvement du joueur.
6. 05 - PlayerMovement: Mais configuré et testé, il est
temps de faire réellement bouger l'
avion. Encore une fois, attention,
nous allons toujours faire les choses de
la mauvaise façon, en commençant mouvement dépendant du
framework avec une sorte de mouvement rapide,
le remplissage, mais cela fonctionnera Et vous vous demandez peut-être pourquoi j' enseigne
sciemment
la mauvaise chose C'est parce que ce code exact apparaîtra dans de nombreux endroits. Cela provient d'exemples de contenu
officiels épiques, ce qui signifie que vous le verrez
dans d'autres didacticiels faisant référence à des
projets plus anciens dont vous pourriez hériter, et je suis sûr que dans
de nombreux autres endroits Quand je m'en suis rendu compte, j'ai
décidé que ce serait occasion
idéale de vous présenter le bogue à la fin de cette vidéo, où
vous comprendrez pourquoi il se produit et où vous
saurez comment le corriger. Nous devons donc toujours être à l'intérieur de notre base de pions BP Underscore. Nous pouvons effectivement nous débarrasser de tout le code que
nous avons actuellement. Nous allons nous débarrasser de cette chaîne de
mise à l'échelle et d'impression. C'était juste pour la
démonstration et le débogage. Pour le mouvement, c'
est très simple. Nous devons simplement considérer cela comme prise de direction. Nous ajouterons une sorte de vitesse
variable un
peu plus tard, et nous voulons
décaler la position de notre avion à chaque clic. Nous pouvons le faire en
puisant dans l'eventi,
l' épingle d'exécution qui se trouve juste ici Nous allons
rechercher ce que l' on appelle définir la localisation de l'acteur. Et ce sera
notre nœud, qui pilotera et
contrôlera
directement l'endroit où nous nous déplaçons. Pour que cela fonctionne, nous devons
calculer un décalage en
tenant compte de la position actuelle de l'
avion
et de l'endroit où nous voulons qu'il soit. Nous pouvons le faire en utilisant
une autre fonction intégrée. Nous pouvons cliquer avec
le bouton droit sur le graphique des événements, et je vais
rechercher Get actor location. Si nous les survolons également lorsque
nous les trouvons, au cas où vous ne le sauriez pas
, vous pouvez voir des
infobulles sur le fonctionnement de
ces fonctions Cela revient donc à l'emplacement
des composants racines, que nous savons être
notre maillage statique,
qui nous indique
essentiellement où nous
nous trouvons dans une image donnée. D'autre part,
nous allons extraire de cette épingle vectorielle l'épingle
jaune juste ici, et nous allons
rechercher le symbole plus, ou vous pouvez taper ajouter et
nous voulons le nœud AD. Nous pouvons faire des calculs vectoriels très
simples. Donc, ce que nous avons
ici, c'est notre
position actuelle , plus un décalage sera égal à l'endroit où nous voulons être, afin que nous
puissions l'intégrer directement. L'un des problèmes auxquels nous sommes
confrontés actuellement est que
nous voulons
contrôler directement l'axe Y. Donc, lorsque vous
travaillerez avec Unreal, je vais revenir sur le niveau juste pour vous donner un exemple
rapide. En ce qui concerne les
directions et les mouvements, si vous ne savez pas dans
quelle direction vous souhaitez vous déplacer, nous pouvons simplement faire quelque chose
comme saisir notre filet Déposez-le dans le niveau, et
nous obtenons ce widget ici, qui nous montrera les
directions dans lesquelles vous
pouvez vous déplacer dans Unreal La principale chose à essayer de
retenir dès le début, c'est le rouge, qui est l'axe X, c'est l'
avant dans le monde. Y, qui est vert droite et la gauche dans le
monde ou latéralement, et Z, qui
est bleu, représente le haut et le bas. C'est très pratique car Unreal Engine les code
couleur Donc, si nous regardons dans
le panneau de détails à droite, nous pouvons
voir ici que nous avons X, Y et Z, et qu'il y
a une petite icône en
forme de pilule rouge, verte et bleue. Nous avons la même chose pour la
rotation et l'échelle. Comme je l'ai déjà mentionné brièvement , ces trois variables, la rotation de l'emplacement et échelle, ne sont qu'une
structure qui constitue le trans et chacune de ces
variables, comme la localisation, et c'est juste une structure de valeurs à virgule
flottante individuelles. Dans l'exemple sur lequel j'ai montré que ce
projet est basé, l'avion se déplace évidemment d'un côté à l'autre et uniquement d'un côté à l'autre, peu comme les anciens envahisseurs de l'espace, et nous essayons de
recréer cela, afin de savoir que nous devons nous
déplacer sur l'axe Y. Donc, de retour dans notre code, cela signifie
que nous devons d'une manière ou d'une autre
exposer cette variable ici. Super simple à faire. Nous pouvons cliquer avec le bouton
droit sur l'épingle jaune, et nous avons cette option
pour diviser l'épingle de structure. C'est pourquoi j'ai
mentionné qu' on
les appelle des structures. Ils se présentent sous de nombreuses formes
différentes, mais ils ne sont généralement qu'une combinaison de
différentes variables, ce qui crée un type
de variable spécifique avec un cas d'utilisation
différent. Dans ce cas, il s'agit de
l'emplacement du mouvement
tridimensionnel. Si nous divisons l'épingle de la structure, vous pouvez voir qu'elle
est ensuite
rétablie en ses valeurs individuelles à
virgule
flottante , le X, le Y et le z, et notre
mouvement est déjà configuré C'est notre mouvement vers la droite, que nous pouvons simplement connecter à l'axe Y. Donc, ce que nous faisons
maintenant, c'est prendre notre position actuelle,
et à chaque image, nous ajoutons un, zéro ou moins un à la direction. Donc, si nous appuyons sur Play, nous pouvons voir que nous avons maintenant
une sorte de mouvement. A et D me feront donc me
déplacer à gauche et à droite, tout comme les arokis gauche et droit Nous avons donc fait un pas de plus vers
ce que nous voulons qu'il soit. Cela nous met dans une petite situation
où nous
avons maintenant un problème où ce jeu dépend de la fréquence
d'images par seconde. Je vais donc
vous montrer quelques points sur
les répercussions
de cela et comment vous pouvez en quelque sorte le tester et le
constater par vous-même. Donc, pour le moment,
souvenez-vous que nous déplaçons une unité par image si
nous appuyons sur un bouton. Donc, si je cours à
120 images par seconde, cela représente 120 unités par seconde. Un moteur rL calcule les
unités en centimètres. Cela
se déplace donc actuellement d'
environ 120 centimètres/seconde Maintenant, si je reviens
en mode jeu, je vais aller dans
la fenêtre principale, et je vais
vous présenter ce on appelle les commandes de console, où nous pouvons exécuter des
commandes simples pour tester des choses. Je vais également me
débarrasser rapidement de cet avion d'essai ici. De retour dans un mode de jeu, cliquez dans la
fenêtre d'affichage pour
vous assurer d' avoir le
contrôle total du mode de Et tu veux
trouver la clé Tilda. Sur la plupart des claviers, il se trouve à
côté de la ligne de chiffres. Si vous appuyez sur la touche Tilda, vous pouvez voir une petite console apparaître en bas de
l'écran. Je vais activer une commande de console très
simple
, déclarée Space FPS. Si j'appuie sur Entrée, nous pouvons
voir sur le
côté droit de l'écran. J'affiche maintenant le nombre d' images que j'exécute par seconde. Je vais appuyer à nouveau sur la touche
Tilda, et je vais
taper T point max FPS ou One Word, puis espace, puis je vais
régler ce paramètre sur 30 Nous pouvons maintenant voir sur le
côté droit que
mes images ont été plafonnées à 30
images par seconde. Maintenant, compte tenu de ce que
j'ai mentionné il y a un instant, si à 120 images par seconde, je me déplaçais à 120
unités par seconde, cela signifie maintenant que je me déplace
évidemment à 30 unités par seconde. Nous jouons donc au même jeu, nous avons le même code de
mouvement, mais le mouvement est
radicalement différent. Si je le rétablis,
je le déplafonnerai à 300. Je tourne à environ 300 images par seconde. Nous pouvons voir que nous nous
déplaçons maintenant beaucoup plus rapidement, car je
déplace maintenant 300 unités par seconde. Je vais le remettre à 30 et
vous pourrez voir le contraste. Maintenant, vous pouvez probablement commencer à
comprendre pourquoi ce n'est pas idéal. Et c'est ce que nous appelons la dépendance à la
fréquence d'images lorsqu' un jeu s'exécute spécifiquement
en fonction du matériel. Ainsi, les joueurs dotés de
systèmes plus rapides se déplaceront plus rapidement et les joueurs dotés de
systèmes plus lents se déplaceront plus lentement. C'est un bug qui apparaît dans bien plus
de jeux que prévu. Donc, avant de
passer à autre chose et d'
envisager ce que l'on appelle l'indépendance de la
fréquence d'images par seconde, nous allons modifier le reste de notre code de mouvement pour le moment afin de disposer de tous les
éléments sur lesquels travailler Pour le moment, déplacer une
seule unité par image n'est évidemment
pas très notable Nous allons
donc vouloir
multiplier notre vitesse par une valeur. Nous pouvons le faire très
facilement. Encore une fois, travailler avec les mathématiques dans les plans
est relativement simple Nous pouvons tirer de notre flotteur
ce contre quoi nous
voulons multiplier.
Faites-le glisser dans le graphique. Recherchez l'astérisque, le symbole de multiplication
ou tapez multipliez, et nous pouvons intégrer ce
résultat dans le Y. Cela signifie que notre direction de déplacement sera désormais multipliée par une vitesse de déplacement, nous pouvons régler de
manière aléatoire pour le moment, comme dix, et ce sera notre nouveau décalage qui s'appliquera à
chaque Nous allons donc maintenant plus vite,
mais nous allons toujours avoir
ce problème d' indépendance en termes de fréquence si je modifie la
fréquence d'images à
laquelle
je cours, je vais maintenant beaucoup plus vite. Cela devient donc
encore plus visible. Je voulais juste me concentrer sur
ce point également. Ce que je viens de créer ici est ce
que nous appelons un chiffre magique. Ce chiffre, dans ce contexte, quand j'y reviendrai
dans un mois ou deux, vous
oublierez probablement exactement ce que ce chiffre représentait sans regarder le
code en arrière. Je vous pose la question suivante :
pourquoi c'était dix ? Pourquoi n'était-ce pas 100 ? Pourquoi n'en
avait-il pas 1 000 et ainsi de suite. Pour atténuer un
peu ce problème, et encore une fois, en nous concentrant sur ces bonnes
pratiques de programmation et en essayant garder notre code ordonné
dès le début Nous allons partir de
cette épingle verte ici, et je vais faire
quelque chose qui s'appelle promouvoir cela en variable, et vous pouvez voir l'option juste ici pour le promouvoir
en variable. Nous allons donc cliquer dessus. Sur le côté gauche
se trouve l'endroit où se trouvent les variables. Nous pouvons prendre ce nom, et je vais renommer en vitesse de
déplacement Maintenant, en un coup d'
œil,
cela nous donne au moins une idée de
ce que fait cette valeur. Il s'agit donc de la vitesse à laquelle
nous nous attendons à nous déplacer, multipliée par une direction ajoutée à notre position active. Il commence à se lire un
peu comme un roman sur une page, et vous avez une idée de ce que
le code va faire, même sans l'
étudier en profondeur. C' est
ce que nous
voulons que notre code
fasse , qu'il devienne lisible par l'homme. Nous avons donc notre
vitesse de déplacement variable. Nous pouvons appuyer sur compiler ici, juste pour
vérifier que
le chiffre dix est renseigné, car nous avions
déjà cette valeur
sous forme de nombre magique. Revenons donc au bogue
de fréquence d'images. Nous devons nous assurer
que, quelle que soit la vitesse
de fonctionnement de notre
système, nous obtenions le même
type de mouvement. Cela ne dépend pas uniquement
du résultat du joueur, mais en tant que concepteur,
lorsque nous créons notre jeu, nous
peaufinons tout. Nous voulons que tout soit aussi fluide,
réactif et réactif
que prévu. Nous peaufinons l'ensemble du jeu
pour qu'il joue d'une manière spécifique. Et évidemment, ce
sera complètement gâché si quelqu'un
qui joue sur un système deux fois plus
rapide que le nôtre obtient un résultat
différent. Pour cela, nous avons besoin de ce que l'on appelle les secondes Delta, parfois appelées Delta simplement le nombre
de secondes écoulées depuis
la dernière image. Plutôt que d'utiliser
cette épingle pour nos calculs,
car, bien entendu, fils se chevaucheraient et commenceraient à introduire du code
spaghetti Nous allons
cliquer avec le bouton droit sur le graphique et
rechercher des secondes Delta. Vous pouvez voir ici
que nous avons l'option, obtenir des secondes dans World Delta, et nous pouvons la brancher
et en faire usage. Nous
voulons simplement prendre toutes les valeurs que
nous avons ici et les multiplier par nos secondes
Delta. Encore une fois pareil. Nous allons rechercher
multiplier, l'intégrer, intégrer
le calcul au résultat, et nous nous
rapprocherons de ce que nous voulons. Maintenant, permettez-moi de
montrer rapidement ce que fait réellement
Delta seconds et ce que représente la
valeur. C'est un moyen très rapide de
le faire. Je voudrais ajouter une chaîne d'impression
comme nous l'avons déjà vu. Je vais le mettre à zéro
pour la durée, saisir le nœud Delta seconds, dupliquer, le brancher juste pour que nous puissions
voir ce qui est imprimé. Dans mes 300 images par seconde, nous n'
allons pas utiliser ce nombre, donc je vais le ramener à 120. À 120 images par seconde, nous obtenons
une valeur d'environ 0,008 seconde
entre chaque image. Si je le ramène à 60, nous verrons ce chiffre
descendre à 0,016 Et puis si nous
le réduisons encore à 30, nous obtiendrons
un nombre de 0,033 Donc, à peu près, pas exactement, mais environ la moitié du nombre à chaque fois que nous
réduisons la fréquence d'images de moitié. Et voici en quoi cela est
utile et comment cela résout nos problèmes liés à la fréquence
d'images. Si vous jouez à 30 images par seconde, chaque image vous fait avancer, mais ce sont des pas plus importants, mais vous faites moins de
pas par seconde. Alors qu'à 120 images par seconde, chaque image vous déplace moins. Ce sont des
étapes plus petites,
mais vous en
faites quatre fois plus. Et ce que nous obtenons,
c'est que la distance totale par seconde reste à
peu près la même. Et ce, que vous utilisiez
30 images par seconde ou 120 images par seconde. Nous obtenons l'indépendance en termes de fréquence d'images, et c'est ce qui fait la différence
entre un jeu qui semble juste sur tous les supports un jeu qui a des expériences
différentes sur des systèmes
haut de gamme ou bas de gamme. Une chose à noter, étant donné que
nous multiplions maintenant nos valeurs par ce nombre
incroyablement petit, la vitesse à laquelle nous nous
déplaçons
va évidemment sembler beaucoup plus lente, très lente, presque Nous devons donc en tenir compte dans
la vitesse de déplacement. Je vais augmenter
ce chiffre à 500 au lieu
de dix, appuyer sur compiler et jouer,
et le résultat sera à peu
près le même. L'essentiel, encore une fois, c'est
que nous avons affaire à un I jump de 30 à 120 FBS Cela semble plus fluide, mais nous n'allons pas sensiblement
plus vite ou plus lentement La seule différence que
nous observons est la fluidité du
mouvement en raison de la
fréquence d'images que nous
examinons . C'est donc
vraiment l'objectif ici. Donc, avec ça, le
mouvement fonctionne. Nous avons résolu le
problème du framework, mais il n'est vraiment pas
tout à fait réglé. Nous pouvons remarquer que c'est assez
rapide lorsque nous le déplaçons. Si nous appuyons sur une direction, nous sommes
instantanément à pleine vitesse. Une fois que nous sortons, nous
sommes instantanément arrêtés. Il n'y a aucune accélération,
aucun élan. Les vrais véhicules ne
fonctionnent pas de cette façon. Même nos plus
téméraires auront du poids, nous devrons
donc envisager d'
ajouter une accélération douce Et toute cette approche que
nous adoptons en ce moment, la localisation de l'acteur. Ce faisant, chaque image
n'a aucune intégration physique, aucune réponse appropriée aux collisions,
et tout va parfaitement bien. C'est pourquoi il est fourni
dans les exemples de contenu Epics. Le modèle fonctionne
parce qu'il est simple, et non parce qu'il s'agit d'une bonne pratique. Nous avons donc des mouvements.
Nous comprenons le bogue du framework que nous
avons rencontré et comment le corriger, et nous savons pourquoi cette approche est courante et pourquoi elle n'est pas idéale. Ensuite, nous allons déplacer les sites. Nous ajouterons de l'accélération, des
inclinaisons rotationnelles, visant généralement quelque chose qui
ressemble davantage à un avion. Si vous voulez
essayer d'expérimenter, vous pouvez toujours essayer d'
ajouter un mouvement vertical C'est le même schéma. Utilisez simplement l'axe différent, l'axe X au lieu
du Y, ou ajoutez-le. Vous devrez probablement également
introduire une nouvelle liaison de saisie, ainsi qu'un petit conseil.
7. 06 - SmoothMovement: À l'heure actuelle, notre mouvement fonctionne
techniquement, mais il semble très robotique. Démarrage instantané, arrêt instantané. Nous aborderons cette question dans
cette vidéo en ajoutant un peu d'accélération et de rotation
bancaire, afin que vous ayez l'impression de piloter une sorte d'avion
Arcade. Nous utiliserons ce que l'
on appelle l'interpolation, qui est le lissage
entre deux points Ce sera également la
prochaine étape pour hériter bogues contenus dans l'épique contenu d'apprentissage
officiel Nous le trouverons, nous le
reconnaîtrons et nous le corrigerons un
peu plus tard. Donc, à l'heure actuelle, le problème
est que notre vitesse est directement
prise à partir de l'entrée. Juste ici, nous avons le déplacement vers droite multiplié
par la vitesse de déplacement. Donc, si nous appuyons sur la droite,
c'est un multiplié par 500. Nous passons directement à la
vitesse de 500 unités par image. Si nous appuyons sur la
gauche, c'est moins
un multiplié par 500, donc moins 500 est appliqué directement
à notre vitesse de déplacement. C'est pourquoi nous avons obtenu ce démarrage
instantané et arrêt instantané. Bien entendu,
dès que nous relâchons une touche, nous multiplions
la valeur par zéro, ce qui nous permet d'obtenir une vitesse de déplacement directe de
500-0 Pour un mouvement fluide, nous allons
avoir besoin de deux valeurs différentes. Nous voulons une vitesse cible, celle que nous voulons
atteindre, et nous avons besoin notre vitesse actuelle, c'est-à-dire
celle où nous en sommes actuellement. Ou utilisez-les pour passer
progressivement notre vitesse actuelle à
notre vitesse cible. Pour commencer, nous pouvons
très facilement créer un nouveau flotteur ou la
vitesse actuelle que nous
allons suivre. Nous pouvons saisir notre
vitesse de déplacement ici, cliquer dessus avec le bouton droit de la souris ou appuyer sur
Ctrl en D pour dupliquer. C'est ce
que nous appellerons la vitesse actuelle. Et ce que nous allons faire, c'est
prendre cette valeur que nous sommes en
train de calculer ici, essentiellement notre vitesse de déplacement, et ce sera la cible que nous utiliserons un peu plus tard. Si nous voulions mettre de l'ordre dans tout cela, nous pourrions certainement le rendre
plus lisible visuellement Si je déplace cela, nous pouvons récupérer ce calcul juste ici. Je vais appuyer sur la touche
Ctrl en X pour la couper, sur la touche Ctrl en V pour la coller ci-dessus, nous allons en tirer un extrait et nous allons la promouvoir
en tant que nouvelle variable. Nous allons promouvoir
celui-ci à
ce que nous appellerons vitesse cible. Et on peut
le brancher juste ici. Vous verrez pourquoi dans un instant, cela ne change
rien vraiment pour le moment, mais cela rendra les choses
un peu plus lisibles. Maintenant, en plus de simplement
cacher des objets pour avoir un peu
plus d'espace pour travailler, n'oubliez pas que nous devons
revoir notre vitesse cible que
nous sommes en train La seule différence est
que nous avons essentiellement donné un nom à cette épingle. Encore une fois, c'est juste un
peu plus lisible. Nous allons atteindre
notre objectif de vitesse. Et si nous le
déposons directement sur la goupille de circulation en Y qui
est maintenant exposée, cela le connectera automatiquement
pour nous. que vous
me verrez faire assez souvent également, c'est ce que je viens de
faire. Donc, ces épingles autour desquelles nous
étions en
quelque sorte des fils flottaient
un peu. Si vous saisissez plusieurs nœuds, appuyez sur un repère qui alignera automatiquement
les fils pour vous. Nous pouvons donc garder les choses un
peu plus en ordre au fur et à mesure. Il est également utile de
savoir que si vous souris sur l'épingle juste
ici, par exemple, et que vous appuyez sur un signal sans
saisir les notes, le nœud connecté prendra le nœud
connecté et
les alignera également donc pas quelque chose que vous devez
absolument faire, mais je le mentionne simplement
parce que je me rends compte que je fais ce genre
de chose avec la mémoire musculaire, donc je le fais pendant que
je parle parfois. Et je voulais juste que tu connaisses les raccourcis
que j'utilise. Bon, revenons
au sujet principal. Nous voulons atténuer ce mouvement grâce
à une interpolation
flottante Si nous cliquons avec le bouton droit sur le graphique des
événements ici, nous allons
rechercher F interp two Il s'agit d'une
interpolation basée sur des valeurs flottantes jusqu'à une certaine valeur. Nous pouvons voir ici certaines
choses qui ont été données. Nous commençons donc par
notre valeur actuelle, qui est, comme je l'ai mentionné,
où nous en sommes actuellement. L'objectif est de savoir
où nous voulons les remplir directement. Nous avons déjà ces valeurs et elles sont nommées en conséquence. Nous pouvons donc récupérer notre vitesse actuelle et la déposer
ici sur Current. Nous allons donc
partir de notre vitesse actuelle et atteindre
notre objectif de vitesse. Il nous suffit donc de le
glisser-déposer également. Vous pouvez voir que nous
devons ensuite brancher le Delta Time. Nous avons donc les secondes
Delta ici. Je vais sélectionner
celui-ci, appuyer sur la touche Ctrl, voire dupliquer avec ma
souris ici, et nous pouvons l'
intégrer aux secondes Delta. Ici, le temps Delta permet l'interpolation E de rester
indépendante de la fréquence d'images,
avec quelques bizarreries Mais encore une fois, nous y
reviendrons lorsque nous verrons ce problème, et nous le
réglerons plus tard. Enfin, nous
avons l'interp qui
contrôle la rapidité avec laquelle nous accélérons pour atteindre la vitesse cible
qui nous est donnée Des valeurs plus élevées ici signifient
une réponse plus rapide. Des valeurs plus faibles signifient qu'il semblera
un peu plus flottant. Je vais commencer par
la valeur de quatre, qui a parfaitement
fonctionné lors des tests. Et puis, bien sûr, nous
ne voulons pas de chiffres magiques dans notre code. Nous
allons donc partir d'ici. Nous allons le promouvoir
en tant que variable. Je vais donner à celui-ci un nom
sensé,
un peu comme « mouvement », «
interprétation de la vitesse ». Nous avons donc maintenant les
quatre F interp deux. Le résultat de cette
interpolation
deviendra notre nouvelle valeur de vitesse
actuelle C'est très important ici.
Nous allons devoir nous
donner un
peu plus d'espace. Je vais supprimer la
chaîne d'impression ici. Nous n'en aurons plus
besoin, et nous allons
le déplacer ici pour neuf heures. Nous allons éviter
tout code spaghetti et nous allons garder les
choses en ordre au fur Cela devra être
calculé ici. Nous avons d'abord besoin de notre vitesse cible, donc de la valeur que
nous savons que nous allons atteindre. Et nous devons également maintenant définir. Donc, en utilisant un nœud
comme celui-ci pour définir la valeur de notre vitesse actuelle. chose que je ne pense pas avoir encore
abordée, c'est que nous avons d'
autres moyens d'intégrer nos
variables dans le graphique. Si nous maintenons la touche
Ctrl du clavier enfoncée et que nous saisissons , par
exemple, la vitesse
actuelle et que nous la
faisons glisser dans le graphique,
nous obtenons un nœud. Ce nœud mince est
appelé getter. Il fournit essentiellement de la
valeur. Nous pouvons lire ceci. C'est obtenir de la valeur pour nous. Si nous maintenons la touche Alt et recommençons
la même chose, saisissez la vitesse actuelle et faites-la glisser dans le graphique,
tout en maintenant la touche Alt enfoncée. Cela fournit
ce qu'on appelle un setter. C'
est donc le contraire. Cela nous permet d'écrire sur
la valeur que nous avons ici. Cela nous permet donc
de lire la valeur. Cela nous permet d'
écrire sur la valeur. Nous voulons conserver la version inscriptible ici
à la vitesse actuelle, donc je vais me
débarrasser du getter Et nous voulons exprimer
notre valeur ici. Comme je viens de le dire, c'est ainsi que notre
vitesse actuelle sera suivie. Nous allons donc intégrer
cela à la vitesse actuelle, et nous devons juste nous
assurer de connecter les épingles d'exécution juste ici. Et juste pour essayer de conclure et assurer que cela a du sens, car je suis consciente que cela peut sembler un
peu confus. Nous devons tout
d'abord savoir sur quoi nous
appuyons et à quelle vitesse
nous essayons d'atteindre C'est pourquoi nous
fixons actuellement d'abord la vitesse cible. Si nous imaginons que nous
calculons cela dès
la première image, nous savons déjà que notre vitesse
cible est le mouvement multiplié par ou plus précisément, notre
direction par la vitesse de déplacement, multipliée par Delta.
Nous obtiendrons donc une valeur de 500 multipliée
par petite valeur basée
sur la fréquence d'images. Nous avons donc un
objectif clair à atteindre. La première fois que nous l'
exécuterons, il est évident la vitesse
actuelle sera
probablement nulle. Nous allons donc passer de
notre vitesse actuelle de zéro, donc nous ne
bougeons pas du tout, à 100 unités de mouvement pour
obtenir un chiffre clair. Nous allons à nouveau prendre en compte le
temps de Dw pour garder ce cadre
indépendant, en quelque sorte,
et nous avons notre vitesse de déplacement,
la vitesse de
déplacement par interpolation, pour
fournir différents niveaux
de lissage fournir différents niveaux
de Ensuite, à l'image suivante, évidemment, la vitesse
actuelle aurait été calculée sur cette base
pour être un peu plus élevée. Nous allons donc partir de
cette vitesse légèrement supérieure. Disons simplement deux ou trois, puis nous allons passer
de cette valeur de deux ou trois, essayant
toujours d'atteindre les 100 unités de vitesse que
nous devons atteindre. Et nous allons le faire continuellement au fil du temps,
ce qui permettra de lisser les Enfin, nous ne
voulons pas utiliser directement la
vitesse cible. C'est juste notre vitesse
que nous voulons utiliser, quelle que soit la
vitesse du moment. Nous allons donc supprimer celui-ci. Nous allons reprendre
notre vitesse actuelle. Et encore une fois, nous
allons simplement le faire
glisser sur notre épingle verte ici, et cela le
connectera automatiquement pour nous. Et c'est tout. C'est
presque prêt à être utilisé et à
tester la fluidité du mouvement. Vous pouvez donc voir ici, alors que je
fais des allers-retours, dès que je relâche la touche, un
peu de lissage se produit alors que nous descendons
à une vitesse nulle Nous avons donc une certaine décélération
et une certaine accélération à venir Maintenant que nous le
faisons au fil du temps, le mouvement peut sembler un
peu plus lent Donc, l'une des autres choses vraiment
utiles, qu'il s'agisse de promouvoir nos nombres magiques en variables c'est que je peux simplement saisir
la vitesse de déplacement. Je peux peut-être le doubler, donc
nous allons simplement le mettre à 1 000 parce que cela
semble un peu lent. Je n'ai pas eu besoin
de lire le code. Je n'avais pas besoin de savoir
où cela se passait. C'est vraiment bien nommé,
donc je sais que cela contrôle la vitesse à
laquelle je vais me déplacer. Je peux appuyer sur Play. Je
peux le tester à nouveau, et nous avons un plan de
sensations complètement différent. me sens donc beaucoup
mieux. Cela exagère vraiment un peu plus l'accélération et la décélération Encore une fois, tout cela a été fait modifier une propriété complète de l'ensemble du
système de mouvement
en saisissant simplement la vitesse de déplacement
et en la branchant Bien entendu, nous avons ajouté
le mouvement fluide, c'est
pourquoi nous avons
dû apporter cette modification. Si vous vouliez jouer avec certaines choses, vous pourriez
faire la même chose, saisir la
vitesse d'interpolation des mouvements et voir si vous voulez que cela prenne plus ou moins de temps
pour atteindre la valeur finale, la vitesse actuelle
que nous ciblons Ce ne sont donc que
des ajustements
variables basés sur la façon dont vous voulez que
votre jeu, votre avion se Un principe de conception que j'ai
entendu très tôt et qui m'est
toujours resté en tête est d'essayer d'exagérer la variable Donc, si vous n'êtes pas sûr de ce
qu'ils font, ou si vous ne savez pas si vous voulez
que ce soit beaucoup
plus rapide ou beaucoup plus lent, cela plus rapide ou beaucoup plus lent représente le double ou le triple de la
valeur sur laquelle vous travaillez. Je pourrais le régler de 4 à 12 parce que vous voulez d'abord
atteindre un extrême, savoir si cela fonctionne,
s'il est trop haut ou trop bas, puis l'
affiner entre les deux Je peux donc voir que c'est
à nouveau presque rapide. Il y a une certaine accélération et une certaine décélération, mais pas beaucoup Donc, je devrais peut-être
réduire ce chiffre à six parce que 12,
c'est définitivement trop élevé, et nous nous sentons un
peu mieux ici. Comme je l'ai dit, j' aime bien l'impression que cela donne à quatre ans,
mais un principe général
de conception consiste à porter la valeur
à un niveau extrême, double, le triple, la moitié, quel que soit le cas, et vous
serez rapidement en mesure de vous concentrer sur ce que vous vouliez
donner à votre propriété. Pour ce qui est de mes besoins, je vais
maintenir la vitesse
d'interaction des mouvements à quatre, et nous pourrons passer
à la fonctionnalité suivante Ajoutons donc maintenant la rotation
bancaire. En fait, cela
va être très simple. Il s'agit essentiellement d'une répétition
de ce que nous venons faire avec des fonctions légèrement
différentes. Essentiellement, lorsque nous nous
déplaçons d'
un côté à l'autre, nous voulons que l'avion s'incline légèrement pour qu'il ressemble un peu plus à un véritable avion. Voici un bref rappel
de l'axe. Je ne pense pas avoir encore abordé
ce sujet à l'automne. Je vais récupérer un maillage
statique très rapidement. Je n'ai pas besoin de suivre. C'est juste pour visualiser
ce que nous sommes en train de faire. Je vais appuyer sur E à l'intérieur
du point de vue pour passer
en mode rotation, et nous pouvons voir nos axes ici. Je l'ai déjà mentionné, nous avons cette transformation,
l'emplacement, rotation et l'échelle qui
définissent la position de notre acteur dans l'espace mondial.
Les emplacements sont très simples. Nous avons X, Y et Z, qui sont en avant, latéralement, en haut
et en bas. La rotation, c'est
relativement simple. C'est la même chose. Nous
avons trois couleurs. Nous avons le rouge, le vert et le bleu, donc le
X, le Y et le z. Mais si nous
les survolons, nous pouvons voir ici qu'ils ont en fait
leur propre nom unique Nous avons le rôle, le
terrain et le rôle. Cela n'a pas trop d'
importance, mais si jamais vous essayez
de modifier ces fonctionnalités, d'
ajouter les vôtres, et vous ne
savez même pas sur quels axes je dois faire
pivoter ou autour de quels axes Je voulais juste
vous montrer un petit visuel qui est en fait
très simple à découvrir. Donc, dans ce cas, je
veux que l'avion s' incline dans une direction basée
sur la façon dont il se déplace. Donc, si j'essaie juste
quelques choses au hasard, si j'essaie la verte
et que je vois ce que cela donne, nous pouvons récupérer la
valeur verte ici et je vais simplement la faire glisser pour la
faire pivoter. Et nous pouvons voir que cela nous
donne une sorte de rotation
du plan vers le haut et vers le bas ici. Ce serait probablement une bonne chose si vous
avancez et reculez. Vous pourriez peut-être en ajouter un
peu pour exagérer le mouvement d'
avant en arrière Si je prends le z et
que je fais la même chose, je prends juste
ceux dont je sais qu'
ils ne fonctionnent pas au départ, pour
les éliminer Nous pouvons voir qu'il tourne
autour des axes de l'avion. Encore une fois, cela ne sera pas très utile
à moins de faire quatre
tons ou quelque chose comme ça. Donc, celui que
nous voulons utiliser sera l'axe X ici. Alors que nous nous déplaçons à
gauche et à droite, nous allons
vouloir légèrement nous incliner et rouler comme ça, en fonction de
la direction que nous allons prendre. C'est ainsi que vous
pouvez facilement entrer, jouer avec les
différents widgets présents, faire pivoter dans une certaine
direction et voir quel axe vous souhaitez
appliquer la rotation. Comme je l'ai dit, c'était juste
pour une démonstration visuelle. Je vais supprimer le maillage statique. Nous allons revenir à la base de la casserole. Déplacez cela un
peu et nous pourrons reprendre la rotation. Pour la rotation ici, nous avons quelques
fonctions très similaires que nous avons déjà utilisées. Nous allons partir de
l'emplacement de l'acteur sur le plateau, et vous pouvez probablement deviner que nous allons
rechercher ce on appelle la rotation des acteurs du set. C'est très similaire, des
mises à jour de la rotation, et ce sera pour
chaque image parce que nous l'
ajoutons à l'événement. Maintenant, nous allons également vouloir utiliser une fonction très similaire, nous voulons utiliser une
interpolation pour Maintenant, pour la rotation, nous n'
utilisons pas l'interprétation F, nous allons utiliser
ce qu'on appelle interpréter deux. Nous faisons donc un clic
droit ici. Recherchez l'interp 2, y pour la rotation, et nous allons
prendre celui-ci ici L'autre raison pour laquelle nous
procédons de cette façon, c'est nous pourrions potentiellement saisir une
seule
valeur flottante, car nous ne voulons le
faire que sur le X. Nous pourrions faire une chose très similaire ici et utiliser un interpréteur F. Maintenant, je m'en tiens à
la parité ligne par
ligne avec le projet d'exemples de
contenu Unreal Engine C'est donc exactement comme
ça qu'ils l'ont fait. Ils ont utilisé une interprétation F pour l'emplacement et une
interprétation R pour la rotation. Je voulais donc montrer à nouveau
le code qui existe et comment nous pouvons le corriger au cas où des questions se poseraient, pourquoi faisons-nous cela
légèrement différemment. Mais l'essentiel, c'est
quand même très utile, car nous pouvons voir que nous obtenons les mêmes propriétés que celles dont
nous avons besoin pour alimenter. Nous avons une rotation actuelle, donc là où nous en sommes actuellement, nous avons une rotation cible vers
laquelle nous voulons effectuer une rotation. Et nous avons le temps de Delta de rendre cette
fréquence d'images indépendante, encore une fois, en quelque sorte. Et puis nous avons
la vitesse d'interp, qui est le lissage entre les deux Donc, le courant est en fait
très simple. Nous avons un autre assistant
très similaire à celui que nous avons utilisé auparavant Si nous cliquons avec
le bouton droit sur le graphique
des événements et recherchons Get
actor rotation. Cela fournira, comme l' emplacement de l'
acteur que nous avons utilisé, la rotation de l'acteur
à cette image donnée. La cible est en quelque sorte un nombre arbitraire
aléatoire, et je dis que ce n'est que parce
que cet exemple épique n'a fait que prendre
la vitesse actuelle Je vais
donc faire glisser la vitesse
actuelle dans le graphique pour
obtenir la vitesse actuelle à laquelle nous nous
déplaçons et la multiplier
par une valeur. À partir de
là, nous allons donc sélectionner multiplier. Et je pense que le leur était
quelque chose comme 1,5. Nous allons donc
multiplier par 1,5
la vitesse à laquelle nous nous déplaçons, qu'
il s'agisse d'une valeur positive
ou négative qu'
il s'agisse d'une valeur positive
ou négative. Et ce sera la
cible vers laquelle nous voulons faire pivoter sur l'axe X. C'est quelque chose que je
voulais te présenter. Nous l'avons déjà vu ici. L'utilisation de l'épingle à
structure divisée pour transformer notre vecteur à trois points en virgules flottantes individuelles. Le rotateur est exactement le même. Nous pourrions simplement cliquer avec le bouton droit sur épingle de structure
divisée et l'insérer dans les X, Y et Z. Cela peut devenir un peu
compliqué lorsque vous avez autant de
flotteurs différents Donc, une chose qui
peut être très utile, et plus que tout, c'est juste pour la
propreté du code, c'est que nous allons extraire de la cible ici et rechercher quelque chose appelé make Nous voulons cette
option inférieure juste ici, et elle fonctionne exactement comme son nom
l'indique. Il s'agit de créer un rotateur à partir
d'un X, d'un Y et d'un Z individuels. Cela permet
de conserver ces deux flotteurs d'eux-mêmes,
donc plus faciles à lire, et cela nous permet de simplement inscrire
notre valeur ici dans le X, d'une manière différente pour atteindre le même objectif qu'
auparavant Aucun d'entre eux n'est
moins ou plus efficace, et cela peut en fait se résumer à ce qui est le plus lisible
dans un certain cas. Je ne dirais pas que
c'est trop illisible, car il ne s'agit que d'un vecteur que nous avons divisé. C'est où ? Il y a déjà
un tas de flotteurs, et il est devenu un peu
difficile de les
souder en les séparant est devenu un peu Comme nous l'avons vu
précédemment, nous voulons que notre résultat final soit la
nouvelle rotation que nous avons ici Je vais
donc prendre
cette interpolation et l'intégrer
au nouveau résultat Et cela ne nous laisse que
quelques points à remplir. Nous voulons donc notre heure Delta, donc je vais venir ici, prendre un Get World Delta Seconds, appuyer sur Control ID ici pour dupliquer et le brancher. Ensuite, nous avons juste besoin de
notre vitesse d'interpolation. Encore une fois, cela
se situe entre les deux. Je suis en train de tester, je pense qu'une valeur d'environ dix
a très bien fonctionné, et c'est l'une de ces valeurs que
vous allez simplement modifier pour que la rotation soit exactement
comme vous le souhaitez Encore une fois, il n'y a pas de chiffres magiques, nous allons
donc partir de là,
promouvoir une variable. Donnez à celui-ci le nom de la vitesse d'interp de
rotation. Et avec cela, nous sommes
à
peu près prêts à le faire tester. Mais il y a une chose qui
m'est venue à l'esprit. Cela agit essentiellement comme un facteur d'inclinaison ou une force d'inclinaison, plutôt que d'avoir ce chiffre
magique que nous allons tirer d'ici, de
distance à variable. Je vais simplement utiliser Tilt Factor, qui est maintenant
prêt à être testé. Nous pouvons donc appuyer sur
Compiler, appuyer sur Play, et nous pouvons voir que nous
avons des banques. Nous avons maintenant un autre
problème, dont j'ai complètement oublié
qu'il allait se produire. Nous allons donc régler ce problème dans un instant, mais le secteur bancaire et la
rotation fonctionnent bel et bien. Maintenant que j'ai potentiellement donné le mal des transports à tout
le monde, la caméra tourne
autour de l'avion. Nous l'avons confirmé,
à tout le moins. La raison pour laquelle
les problèmes de caméra se produisent est la caméra hérite de la
rotation du parent Nous l'avons vraiment vu
dans la hiérarchie. Les caméras sont fixées
au ressort, euh, le bras à
ressort au maillage statique, et celles-ci suivent toute
la rotation et la position appliquées au moyeu statique.
C'est vraiment simple à corriger. Et l'une des raisons pour lesquelles je
voulais utiliser le ressort, c'est que
j'ai juste oublié de le cocher avec le ressort
sélectionné dans le panneau
de détails
sur le côté droit Ce composant unique nous
fournit une solution. Epic savait que ce genre de chose
serait un problème potentiel. Ils nous ont donc donné
quelques cases à cocher ici. Nous pouvons décocher les valeurs héritées du
pitch, du U et de la rotation. N'oubliez pas les noms des
X, Y et Z de rotation. Donc, si nous les décochons,
cela revient essentiellement ne pas laisser le bras à
ressort suivre la rotation du composant
parent Et comme les caméras sont
issues du bras à ressort, cela s'appliquera également
au composant enfant de
la caméra. Donc, si nous appuyons sur
compiler, appuyez sur Play, nous pouvons entrer et nous pouvons voir que nous pouvons bien voir la rotation. Et nous n'avons pas le mouvement de
caméra
potentiellement nauséabond que nous avons
connu il y a un instant Une autre chose que je viens de réaliser avec le ressort sélectionné, c'est
que je l'avais toujours cochée
aussi. Faites un test de collision. Si vous avez eu un problème
lorsque la caméra semble se déplacer ou
être
projetée dans le
sol ou quelque chose comme
ça, c'est peut-être
parce que le test de collision est en cours Que se passe-t-il ici
juste pour visualiser cela ? Si quelque
chose est détecté entre la caméra et l'objet qu'elle regarde ici, donc si quelque chose entre en
collision à cet endroit dans
le bras à ressort rouge, c'est là
que se déroule le
test de collision. Si quelque chose passe par là, c'est là
que la
caméra
essaiera de se déplacer automatiquement ou
de se cacher derrière quelque chose
pour éviter la collision. C'est vraiment utile pour les jeux à la
troisième personne où vous pouvez placer
la caméra contre un mur et où elle se rapprochera un
peu plus du joueur. C'est donc une fonctionnalité
très intéressante. Dans un jeu comme celui que nous sommes en train de créer,
nous pouvons avoir des problèmes
lorsque la caméra semble agitée si des projectiles ou des traces et des objets de ce
genre passent à travers la
caméra, la ligne de la Et encore une fois, c'est
quelque chose d'autre que l'on voit dans projets
pour débutants
où l'appareil photo est peu agité ou pétillant. C'est probablement
parce qu'ils ont une sorte de test de collision en cours entre la caméra
et ce que vous regardez. Nous allons donc désactiver cela. Nous n'en aurons pas besoin pour
ce type de jeu. Une fois cela fait, la
caméra reste à plat. L'avion s'incline naturellement,
on se sent beaucoup mieux. Maintenant, nous pouvons
enfin voir où l' exemple d'
Epic se
décompose un peu. Je voulais juste mentionner que cela
n'a rien
à voir avec le projet d' exemple,
Epic ou quoi que ce soit d'autre. Je soulève
cette question uniquement parce que je me rends compte que c'est une opportunité
pédagogique parfaite, quelque chose qui est
tellement couvert utilisé par de nombreuses chaînes de
didacticiels, moi y compris, que vous
allez voir du code qui ne
fonctionne pas, même à partir de sources
officielles. donc très utile de le savoir et
de
pouvoir sera donc très utile de le savoir et
de
pouvoir y faire attention. Le problème que nous rencontrons pour
le moment est donc de savoir si nous
allons passer en mode jeu. À une fréquence d'images élevée, je vais rétablir mes
statistiques de fréquence d' Donc 120 FPS, ça a l'
air plutôt correct. Mais si je le ramène
à 30 images par seconde, concentrez-vous sur le degré de
rotation appliqué. Encore une fois, vous pouvez voir qu'il ne s'agit pas simplement d'un cas où l'un d'
entre eux
semble légèrement plus lisse et l'
autre un
peu moins lisse
à cause de la fréquence d'images par seconde. Il s'agit littéralement d'une
différence de mécanique, même code, même entrée, rotation
complètement différente. À 30 images par seconde, nous faisons presque pivoter l'aile
dans le sol, selon
la distance entre l'avion et le sol. Et c'est l'une de ces choses. Ce n'est même pas une rupture de gameplay. Mais si vous avez configuré un
système pour qu'il soit super fluide
et qu'il soit exactement tel que vous le
souhaitez, et qu'il soit exactement tel que vous il soit
le plus attrayant pour le joueur
, mais qu' un joueur utilisant un système moins performant joue et obtient
le deuxième résultat Vous allez évidemment
être déçu, ils n'auront pas l'
expérience que vous souhaitiez. Et c'est pourquoi il est
vraiment important de se concentrer sur ce point. Et c'est ce que je
voulais dire par ce bogue qui existe dans les exemples de
contenu officiels d'Epics, même code, même problème, inclus dans la documentation elle-même Et c'est pourquoi, même en se fiant aveuglément aux exemples officiels,
même la
documentation de première piété peut Testez donc toujours les cas extrêmes et faites attention à ce genre de
choses. C'est ce que j'
essaie vraiment de faire comprendre. Comme je l'ai déjà dit,
cela va être un peu trop long
pour ce seul sujet. C'est donc quelque chose que
nous allons
corriger un peu plus tard, et nous allons entièrement reconstruire le système de
mouvement. Mais pour l'instant, nous allons simplement
reconnaître que le bogue existe. C'est toujours très
bien de travailler avec ça. C'est une base parfaite
pour poursuivre la construction. Nous reviendrons et
nous allons retravailler complètement
le système de mouvement, et nous corrigerons tous les
bugs une fois que nous aurons terminé. Maintenant que nous avons vu
l'avantage de ne pas utiliser chiffres
magiques, nous avons
notre vitesse de déplacement, qui
contrôle la vitesse à laquelle vous pouvez aller, la vitesse d'interpolation des
mouvements, c'
est-à-dire la rapidité avec laquelle vous
atteignez cette vitesse, notre facteur d'inclinaison sur l' l'
avion aux
différentes vitesses, et même la vitesse d'
interpolation de rotation, rapidité avec
laquelle nous atteignons ces valeurs
d'inclinaison. Tout cela est réglable
sans toucher à la logique. Si vous voulez de l'action d'
arcade rapide, nous pouvons augmenter
la vitesse d'interp. Si vous voulez un
espace lent et flottant, vous pouvez l'abaisser. L'ambiance du jeu vient
alors entièrement
des chiffres. Nous
pouvons donc en rester là. Nous avons un mouvement fluide et plutôt
satisfaisant, avec de bonnes opérations bancaires. Et oui, il y a le bogue de fréquence lequel nous allons
revenir, mais au moins nous le
connaissons, et nous le corrigerons plus tard. Ensuite, nous pouvons passer
au système de saisie amélioré. Il s'agit du remplacement
moderne par Unreal de l'ancien système de saisie
que nous utilisons actuellement Si vous vouliez
expérimenter, comme je l'ai dit, vous avez maintenant toutes ces
valeurs prêtes à être utilisées. Essayez d'ajouter un peu plus de
hauteur à la rotation et éventuellement de l'ajouter
avec les mouvements vers l'avant. Même schéma, axe
différent pour la rotation
et le mouvement
si cela ne
va toujours que dans un seul sens.
8. 07 - EnhancedInput: Configuration du mouvement et fonctionnement
jusqu'à un point testable. N'oubliez pas que l'ancien
système de saisie que nous utilisions et qui, comme je l'ai
mentionné, est obsolète L'entrée améliorée est
le remplacement moderne. La configuration initiale est un peu
plus importante, mais elle est nettement
plus flexible Nous obtenons des éléments tels que des schémas de contrôle
remplaçables à chaud, des zones mortes
intégrées, reliaisons
d'exécution,
tout ce que vous auriez à
coder vous-même à l'aide de
l' Commençons donc la migration. La première différence principale est que
le système de saisie amélioré possède
en fait son
propre ensemble de classes. Retournez donc
au dossier des plans, cliquez avec le bouton
droit de la souris ici ou
appuyez sur Ctrl Shift dans n pour
créer un nouveau dossier, et nous l'appellerons entrée La saisie améliorée divise
les éléments en deux parties. Nous avons nos actions de saisie, qui définissent ce qui peut
arriver , comme tirer, déplacer, redémarrer. Ensuite, nous avons ce que l'
on appelle les contextes de mappage des entrées, qui définissent quels boutons déclenchent les actions
mentionnées précédemment, séparant ainsi les préoccupations. Et la raison pour laquelle cette
séparation s'avère utile, c'est qu'elle permet aux
schémas de contrôle de changer sans qu'il soit nécessaire de redéfinir toute
la logique du jeu En code, nous pouvons simplement appeler le système de saisie pour basculer
entre les commandes de menu, les commandes de
jeu, les
commandes du véhicule, etc. Ils peuvent partager les
mêmes mappages d'actions des boutons spécifiques, mais ils peuvent s'exécuter dans des contextes
différents. Une ligne de code, et
tout est changé. le dossier de saisie,
nous allons cliquer avec le bouton droit de la souris, et je vais accéder à la catégorie
Entrée juste ici. Nous pouvons voir que nous avons la section
d'action de saisie, nous allons
donc en créer une. Donnez-lui le nom de
IA Underscore Fire. Nous allons sélectionner celui-ci Breast Control, en effet, à dupliquer. Nous en avons besoin de deux autres.
Nous allons donc les dupliquer deux fois, et nous appellerons un mouvement de soulignement
IA
et un redémarrage du trait de
soulignement IA Ensuite, nous voulons ouvrir notre classe
IA underscore move. Nous allons double-cliquer pour l'ouvrir
. Et la principale chose que
nous voulons examiner est juste ici, nous avons le type de valeur. Par défaut, ce paramètre est défini sur un booléen
numérique ou une boule, ce qui est très similaire
à ce que nous avons configuré dans les paramètres du projet avec
les mappages d'actions Nous devons les supprimer de toute façon. Nous allons revenir à
Modifier, aux paramètres du projet. Nous allons redescendre pour saisir. Et juste pour le contexte, le booléen
numérique qui aurait été
activé ou désactivé aurait été si nous avions créé un
mappage des actions ici Par exemple, nous aurions pu
créer quelque chose appelé feu, lier à un bouton, et faire tirer chaque fois
que nous voulions appeler un projectile Pendant que nous sommes ici, je
vais également me débarrasser
des mappages d'actions afin ne rien avoir de restant Cela provoquera également un
petit bogue dans notre code, mais cela permettra de trouver
les choses plus facilement
et de les affiner lors de la mise à jour de notre code. Nous allons donc simplement appuyer sur
Supprimer pour supprimer également nos
mappages d'accès Encore une fois, cela
enregistre automatiquement que nous pouvons le fermer et revenir dans
le trait de soulignement IA Nos actions de saisie de
démarrage et de redémarrage. Ils ont tous deux besoin de lingots
numériques, c'est
pourquoi je ne les
ai pas ouverts Ils sont parfaitement
corrects par défaut. Soit nous appuyons sur le bouton de
tir, soit nous ne le faisons pas. Il en va de même pour
le bouton de redémarrage. Pour le mouvement, cependant,
nous voulons le déplacer vers le bas, et nous voulons utiliser
ce flotteur en D sur l'axe 1, qui fournit
essentiellement la même
chose qu'un mappage d'axes, fournissant une valeur
comprise entre moins un et plus un ou zéro si
rien n'est pressé. C'est donc le seul changement
que nous devons apporter dans le cadre de notre action de saisie. Nous pouvons appuyer sur Enregistrer. Nous
pouvons fermer celui-ci, et nous pouvons retourner
dans notre dossier de saisie. Nous voulons maintenant accéder
à notre contexte de cartographie. Ce seront les
boutons qui déclencheront, les actions. Si nous cliquons avec
le bouton droit sur le dossier ici, nous allons retourner
dans la section de saisie, et cette fois nous allons créer
un contexte de mappage d'entrée. La convention de dénomination sera IMC. Soulignez, puis le nom de la chose dont
il sera responsable Nous n'aurons qu'un seul type d' entrée dans ce projet plus
simple. Je vais donc appeler celui-ci
principal pour notre contribution principale. Double-cliquez pour l'ouvrir, et nous verrons comment cela fonctionne. Maintenant, ce type de fichier
représente les paramètres du projet que
nous étions en train de modifier plus tôt. En haut à
gauche, nous voulons cliquer sur ce bouton plus
et le faire défiler vers le bas. Nous devons rendre chacune de
ces entrées unique, c'est
pourquoi elle est
actuellement en cours de gradation Nous ne pouvons
donc pas ajouter d'autres mappages
tant que nous
n' aurons pas de
propriétés uniques dans celui-ci Si nous supprimons cette option, nous pouvons la régler sur Ia underscore fire Ensuite, si nous faisons défiler
la catégorie juste ici, c'est là que nous pouvons commencer à faire le même type de cartographie
que celui que nous avons vu plus tôt. Donc, si je voulais que la fonctionnalité
Fire soit appelée sur la barre d'espace, je peux appuyer sur le bouton ici, appuyer barre d'espace, et nous
avons une liaison Si je voulais aussi qu'il réagisse
au clic gauche de la souris, je peux cliquer ici et
faire un clic gauche de la souris. Je vais également faire la même chose une dernière fois pour la manette de jeu Je vais appuyer à
nouveau sur le bouton et appuyer sur le bouton
inférieur, sur
le bouton A de la manette de jeu,
et c'est réglé Nous avons donc maintenant trois boutons différents ou
trois entrées différentes, qui peuvent tous appeler la fonction fire lorsque nous
arrivons à l'implémenter. Nous voulons refaire la
même chose pour nos autres actions de saisie. Nous allons donc appuyer sur le plus. Nous voulons lier quelque chose
au redémarrage. Ce sera sympa et simple,
donc je vais d'abord le faire. Encore une fois, nous pourrions avoir R pour redémarrer, et peut-être que je vais en ajouter
un pour la manette de jeu, et j'en ferai
le bouton de démarrage C'est donc le bouton spécial
droit. Juste pour noter que j'utilise le
shift vers la gauche et que j'appuie sur les flèches, qui ramènera
tout à zéro. Si vous voulez des
raccourcis ici, maintenez la touche Maj enfoncée, cliquez avec le bouton gauche de la souris
et vous verrez que
chaque élément est déplié C'est donc un bon moyen rapide de déplier
ou de replier les
choses correctement lorsque nous parcourons ces
différents La cartographie finale que je voulais créer
sera le mouvement. Nous allons donc en ajouter
un autre. Nous allons lier cela à I A underscore. Nous allons le supprimer. Et encore une fois, nous allons vouloir
ajouter quelques clés ici. Si nous commençons de la même
manière que précédemment,
nous allons cliquer sur
le bouton ici, appuyer sur D pour obtenir un mouvement vers la droite
par défaut, puis cliquer sur un
autre, appuyer sur A pour obtenir notre mouvement vers la gauche. Maintenant, c'est là que les choses
changent un peu, et cela est propre aux paramètres de saisie
améliorés. Même si nous les avons définies
comme un axe unidirectionnel, une valeur à virgule flottante pour
notre mouvement de soulignement IA, vous pouvez voir que nous
n'avons
aucune valeur flottante à modifier ici pour inverser le A et
faire bouger les choses vers C'est plutôt là que les modificateurs entrent en jeu avec le système de saisie
amélioré Donc, si nous cliquons sur le
signe plus sur le modificateur, nous
pouvons le faire défiler vers le bas
et vous pouvez voir un tas de
fonctionnalités utiles préintégrées. Nous pouvons ajouter des éléments tels que
des zones mortes pour les sticks analogiques, des
scalaires
automatiques, etc., qui peuvent être appliqués
à l'entrée Celui que nous voulons est juste là,
nous voulons donc en annuler la valeur La valeur par défaut sera
un. Si nous le nions C'est ce qui
nous donne un résultat négatif. C'est tellement agréable et simple à utiliser juste une approche légèrement
différente. Je vais refaire la
même chose. Je vais juste en ajouter deux autres. Un pour la flèche droite.
Un pour la flèche gauche. Nous allons ajouter le même modificateur
sur la flèche gauche. Enfin, je vais
ajouter une dernière entrée par mouvement, et je vais à nouveau déplacer le stick
analogique gauche. Maintenant, la même chose
se passe ici. Nous n'avons pas besoin d'ajouter des points négatifs ici, car Unreal sait qu' un stick analogique a un potentiel gauche et un potentiel droit sur l'axe X. Il renvoie automatiquement un
point négatif lorsque je le
pousse vers la Tout est
configuré et prêt à être intégré dans le cadre de l'IMC
Underscore Nous allons donc appuyer sur Enregistrer et
nous pouvons fermer celui-ci. Nous n'aurons plus besoin de modifier
quoi que ce soit là-dedans. Cela a donc peut-être semblé
un peu fastidieux. Comme je l'ai mentionné,
sa configuration initiale est un peu plus complexe,
mais vous ne devez la configurer qu'une seule fois, et ces actifs peuvent
ensuite être copiés très
facilement vers deux autres projets si vous constatez que vous
utilisez des modèles similaires Et l'essentiel est
que dans le cas de projets plus importants, cela vous fera gagner
beaucoup plus de temps, car il est beaucoup plus flexible que
l'ancien système de saisie. Nous voulons maintenant revenir à notre
cours basé sur la pornographie. C'est une autre étape sur laquelle
j'ai vraiment besoin que vous vous concentriez, car
c'est l'étape que tout le monde oublie souvent avec le système de saisie amélioré Le contexte de mappage existe, mais rien ne
l'utilise pour l'instant. Et contrairement à l'
ancien système de saisie, notre
système de saisie amélioré doit être explicitement lié à une classe. Nous pouvons le faire très
facilement, et c'est l'étape que tout le monde oublie
souvent de faire Dès le début du jeu, nous
pouvons cliquer avec le bouton droit de la souris
quelque part près d'ici, et nous allons
rechercher la fonction
intégrée de la manette G Player. La manette du joueur reçoit les informations
directement de nos appareils
physiques,
les transmet Unreal
et décide de la manière de
les gérer dans l'autre partie du plateau
qu'elle contrôle peut-être Cela peut également s'appliquer à l'IA, ce serait
donc
l'entrée que l'IA donne au pion IA
contrôlé À partir de la manette,
nous allons
tirer de l'épingle et
rechercher
ce que l' on appelle le sous-système de lecteur local à
entrée améliorée G. nom vraiment accrocheur
. Nous voulons que celui-ci soit juste ici
avec le F rose, donc cela indique qu'il
s'agit d'une fonction. Il va simplement
renvoyer une certaine valeur, à savoir cette entrée améliorée, un sous-système de lecteur
local Et à partir de là, c'est la
fonction dont nous avons vraiment besoin. Nous allons appeler le contexte de mappage
publicitaire. Joli et clair. Nous pouvons voir exactement
ce que cela va donner. Cela ajoutera un contexte de mappage
spécifique, celui que nous
venons de créer pour être lié à la classe dans
laquelle nous nous trouvons actuellement. Nous allons donc nous assurer de
les connecter à l'épingle d'exécution, déposer ici le contexte de mappage
que nous voulons utiliser, et nous n'avons que celui pour lequel nous
avons IMC underscore Man La façon dont vous l'utilisez
peut-être, comme je l'ai mentionné, est que vous avez peut-être une manette spécifique plus
avancée, qui suit ce que vous
pourriez faire pendant le jeu
. Pendant les moments de jeu,
il s'agit de s'assurer que le contexte de mappage
utilise l'IMC du jeu, et vous pouvez également avoir quelque chose
comme un IMC du menu principal , afin
que vous
puissiez naviguer avec le clavier dans votre menu principal Lorsque le joueur appuie sur
pause ou sur Escape, le contrôleur du
joueur est chargé de modifier le contexte de mappage pour passer
du gameplay au menu. Et c'est là que cela devient
vraiment très flexible. Comme je l'ai mentionné, c'est un
peu exagéré pour le type de projet que
nous créons, mais il est utile de le savoir,
et vous pouvez vraiment tirer parti dans
n'importe lequel de vos projets Et ce que j'ai vraiment
envie de
ramener chez moi , c'est que cette étape est essentielle. J'ai vu tellement de personnes tout
configurer parfaitement. Toutes
leurs entrées sont configurées. Toutes les
fonctionnalités du mouvement fonctionneraient correctement. Ils appuient sur Play et
rien ne se passe. Vous passez une heure à déboguer, puis vous vous
rendez compte que vous avez oublié de lier le contexte de
mappage Ne soyez donc pas cette personne.
La dernière chose que
nous voulons faire ici est donc nous voulons faire ici est remplacer l'ancienne
entrée que nous avions. Si nous appuyons sur Compiler, parce que nous avons supprimé l'ancienne entrée des paramètres
du projet, c'est
ce
que je voulais dire : nous recevrons en fait une erreur
ou un avertissement très utile ici. Il nous indique maintenant
qu'il essaie de faire
référence à quelque chose qui
est un axe inconnu. Si nous appuyons sur ce texte
souligné ici, cela
nous ramènera directement à l' endroit où les problèmes
se produisent. Tellement agréable et facile. Tout ce que nous avons à faire
est de récupérer ce nœud qui n'existe plus dans
les paramètres du projet. Appuyez sur Supprimer. Nous pouvons cliquer avec
le bouton droit de la souris ici, et nous voulons rechercher
notre mouvement de soulignement IA Même chose, très similaire à l'ancienne entrée.
Nous avons deux options. Nous obtenons les événements d'action, ce qui créerait un nœud
comme celui-ci où nous avons une épingle d'exécution et
la variable flottante, ou nous pouvons utiliser l'action de l'axe
ici, la valeur de l'action. La même chose que
la valeur de l'axe que nous avions précédemment.
Nous allons donc sélectionner celui-ci. Cela nous donnera juste
la valeur à virgule flottante, et nous pourrons la reconnecter. Le code lui-même est donc à
peu près identique. Rien n'a
vraiment changé. C'est juste la façon dont nous
allons configurer la saisie améliorée pour
nous fournir ces informations. Cela rend la transition
relativement fluide, et toute notre logique de mouvement
restera exactement la même. Si nous appuyons sur Play,
nous pouvons tester cela. A et D font donc
la même chose, gauche et à droite, et
voici à nouveau le stick analogique. Tout fonctionne donc exactement
comme prévu. Tout ce que nous avons eu à faire est de
mettre à niveau la couche d'entrée située sous notre
code principal. Et c'est tout. Nous avons maintenant intégré le système de saisie
amélioré dans notre projet, entièrement configuré, qui a demandé un peu
plus que l'ancienne configuration de saisie, mais il est beaucoup plus flexible
et en vaut vraiment la peine. Nous utiliserons d'
autres fonctionnalités ultérieurement, telles que les
événements d'incendie pendant le tir, le
déclenchement en boucle d'
entrées maintenues, puis le bouton de redémarrage unique
. Le prochain sujet
que nous voulons aborder sera
toutefois celui de
nos limites de jeu. heure actuelle, nous pouvons passer
à l'affinité, ce qui n'est pas vraiment génial
pour un shooting up. Et, bien entendu, si vous voulez expérimenter,
vous pouvez essayer d'ajouter
des éléments tels modificateurs de zone
morte pour
la saisie par joystick, voir comment les minuteries ou les pulsations peuvent fonctionner à l'aide de la
fonctionnalité intégrée Aucun code requis et juste
quelque chose avec lequel jouer.
9. 08 - Limites: Nouveau système de saisie, nous avons toujours ce problème où nous pouvons
actuellement nous envoler vers l'infini. Vous finiriez par rencontrer une sorte de problème de
précision à virgule flottante, mais bien avant cela,
le jeu deviendrait injouable et
surtout assez ennuyeux Pour ce type de jeu,
nous allons avoir besoin d' une caméra fixe et murs de délimitation,
de murs invisibles. La caméra que nous avons est actuellement
attachée au pion, et pour les photographier, une caméra horizontale serait
tout simplement plus logique Donc, si nous revenons à la base
panoramique BP Underscore, nous pouvons saisir le sélecteur de commande du
bras à ressort, la caméra, et nous les supprimerons
simplement Si nous appuyons sur Play, nous sommes maintenant de
retour à l'intérieur du vaisseau Nous avons
donc le problème à
nouveau, mais nous sommes sur le
point de le résoudre presque immédiatement. L'essentiel est
que vous connaissiez maintenant le cadre
de jeu et que vous sachiez pourquoi nous
examinons l'intérieur de notre vaisseau. Si ce n'est pas le cas,
revenez sur quelques sujets. Si nous revenons
au niveau principal, nous voulons simplement ajouter une caméra. En haut, juste
au-dessus de la fenêtre, il y a un petit cube,
qui est notre bouton d'ajout Si nous le déplaçons vers le bas, nous voulons rechercher l'option caméra. La plupart des options proposées
ici ont tendance à déplacer les
catégories toutes les quelques versions
irréelles. La recherche peut
donc être
un peu plus rapide, La recherche peut
donc être
un peu plus rapide car la vie est trop courte
pour rechercher des appareils photo Celui que nous voulons, c'est
notre acteur de caméra. Il sera diffusé directement dans le monde si
nous le sélectionnons. La caméra devra
regarder
où le joueur
va apparaître,
et nous savons déjà à nouveau, grâce
au framework de jeu, comment nous gérons cela et
où cela va se passer Donc, un petit
raccourci pour vous. Si vous saisissez le point de départ du joueur, c'est-à-dire l'endroit où le
joueur apparaît, nous allons accéder au panneau de détails sur
le côté droit, cliquer avec le bouton
droit sur la propriété de
localisation, et nous pouvons copier l'
emplacement réel du départ du joueur Si nous prenons l'appareil photo,
nous ferons la même chose, mais nous allons
cliquer avec le bouton droit de la souris ici et coller la propriété
que nous venons de fournir. Nous avons donc maintenant la
caméra directement au point de départ
du joueur. Nous voulons également lui donner
une certaine rotation. Ainsi, à l'intérieur de la fenêtre, nous pouvons appuyer sur F pour nous concentrer sur
l'appareil photo Si vous le souhaitez, vous pouvez passer en mode
rotation et
utiliser les widgets juste ici. Maintenant, je sais que pour nos besoins,
nous voulons simplement faire pivoter la caméra de -90 degrés
sur l'axe Y. Je vais donc le faire à partir
du panneau des détails, et nous regardons maintenant
directement le sol. C'est peut-être un
peu trop près. Donc, la prochaine chose que nous
allons vouloir faire est déplacer la caméra vers le
haut dans l'axe Z. Encore une fois, si nous saisissons
la valeur Z ici, je placerai une valeur de 2 400 Je pense que c'est similaire à
ce que nous avions auparavant. Nous pouvons voir maintenant que nous allons
regarder directement le point de départ du joueur et l'endroit où l'
avion va apparaître. Vous ne serez peut-être pas tenté d' appuyer sur Play pour voir ce qui se passe. La raison en est toute simple si
nous avions cinq, sept,
20 caméras dans la scène ? Comment pourrait-elle savoir
laquelle choisir ? Comme pour les autres règles
que nous sommes en train de définir, nous voulons en avoir
le contrôle et les définir manuellement. Donc, avec l'
acteur de caméra sélectionné, nous voulons simplement rechercher
dans ce panneau juste ici, dans le panneau des détails,
nous voulons rechercher ce que l'on appelle l'activation
du lecteur automatique Nous pouvons voir que nous avons
cette option ici. L'activation automatique pour le joueur est
actuellement désactivée. Si nous laissons tomber cette option
et que nous sélectionnons le joueur zéro, ce sera le
premier et le seul joueur de notre partie solo. Maintenant, le framework sait qu'il faut utiliser la caméra que
nous venons de sélectionner. Si nous appuyons sur Play,
nous pouvons le voir. Nous devrons faire
quelques ajustements pour tout soit bien
centré, mais nous cherchons maintenant à
peu près où nous voulons être. Donc, en ce qui concerne le
placement de la caméra, nous allons
vouloir que le joueur soit plus
proche du bas de l'écran, peu comme Space
Invaders, et encore une fois, recréant
un peu la configuration en recréant
un peu la configuration des exemples de contenu
que nous avons choisis Le problème avec l'
éditeur et la convivialité ici, c'est que le démarrage du joueur ne comporte aucune visualisation. Il sera donc un
peu difficile voir où les vaisseaux du
joueur vont réellement apparaître et de
positionner la caméra en conséquence Voici une petite astuce que
je voulais vous présenter nous pouvons ajouter une
sphère ou une forme temporaire, quelque chose comme ça pour montrer
où le joueur commence. Si nous allons sur le
bouton Ajouter ici, nous pouvons accéder à notre option de formes. Je sais que j'ai toujours
la position enregistrée depuis le début du lecteur
plus tôt lorsque je l'ai copiée. Je vais annuler la
recherche d'Autoplayer ici, cliquer avec
le bouton droit de la souris et coller l'emplacement du
joueur de départ Et je regarde cette sphère, qui se trouve directement sur
le point de départ des joueurs. Si nous retrouvons le
caméraman, cela nous aidera,
car nous pouvons maintenant voir exactement ce que la caméra
va regarder. En appuyant sur F, je vais
revenir en arrière pour
regarder exactement l'appareil photo et nous pouvons
le faire glisser vers sa place. Donc, si nous avançons la
caméra ou si nous pouvions inciter les
joueurs à prendre le départ, l'un
ou l'autre ira
parfaitement bien. L'essentiel est que
nous voulons que le vaisseau du joueur se trouve
à peu près ici. C'est donc un moyen
simple et agréable de mettre les choses en place
rapidement et rapidement. Si je prends la sphère,
je peux la supprimer. De toute évidence, nous ne voulons pas
que cela reste dans le laboratoire. Vous pouvez appuyer sur Play pour que les joueurs se rapprochent de l'endroit où nous
voulions que ce soit. Une autre astuce concernant l'appareil photo
que je voulais juste vous
montrer très rapidement est de le saisir à nouveau, pendant que vous
jouez. Si vous ne vouliez pas que cette fenêtre de
démonstration automatiquement désactivée lorsque
vous sélectionnez autre chose, nous pouvons choisir cette petite icône en forme d'
épingle ici, qui épinglera cette
fenêtre dans votre fenêtre d'affichage Donc, si vous deviez entrer, déplacez les joueurs vers
quelque chose pour voir ce
qui se passe à
travers le champ de
vision de la caméra, un autre petit conseil : nous pouvons garder cela à
l'écran temporairement. Lorsque vous voulez que cela
disparaisse, nous
pouvons simplement appuyer à nouveau sur l'épingle, et cela se détachera
de la fenêtre d'affichage Juste quelques points avec lesquels commencer
à se sentir à l'aise
et à se familiariser. Je vais prendre une autre
forme juste ici. Je crois l'
avoir mentionné plusieurs fois, mais si vous appuyez sur F avec
un objet sélectionné, vous vous concentrez sur l'
objet que vous voulez regarder. Vous pouvez cliquer pour ensuite le faire pivoter
directement autour de l'objet. Et une autre chose
qui peut être très utile est que si nous plaçons
quelque chose comme ça, nous pouvons maintenir la touche Shift enfoncée, cliquer avec le bouton gauche sur la direction du widget,
puis le faire glisser. Donc, si nous commençons à
faire glisser un objet ici, puis que nous appuyons sur Shift, s'
il bougeait, nous pouvons
faire en sorte que la caméra dans la fenêtre continue de suivre l'
objet que nous déplaçons Très pratique si vous
essayez de jouer à quelque chose et que vous ne
voulez pas continuer à le
déplacer, à déplacer la caméra, à la déplacer
à nouveau, etc. Voici donc quelques conseils rapides pour vous familiariser
avec le viewpot Nous allons maintenant vouloir commencer à examiner les limites. Encore une fois, à partir du bouton Ajouter, nous allons
rechercher
ici ce que l'on appelle un volume bloquant. Nous pouvons voir comment nous avons la
possibilité de bloquer le volume. Nous allons sélectionner
celui-ci, et ce qui nous est
donné, c'est ce cube invisible. Cela représentera
notre mur invisible, et nous voulons simplement le
disposer à travers le niveau pour bloquer les endroits où le joueur ou les ennemis peuvent frapper. Pour mettre cela en place, je vais refaire la
même chose. Je vais
cliquer avec le bouton droit de la souris et coller le lieu de
départ du joueur . Cela nous
placera ici. Pour celui-ci, nous pouvons le placer sur le côté gauche de notre zone de jeu,
ce qui, d'après les
tests, serait un bon point négatif de 1 240 Cela placera ça juste au-dessus. Prêt parfaitement
bien sur l'axe Z. C'est suffisamment haut pour que l'avion
entre effectivement en collision avec cela Si nous le plaçons à la position
X de zéro, cela placera ce
type de milieu de niveau sur l'axe Ford. Ensuite, ce que nous voulons
faire ici, c'est redimensionner le cadre pour couvrir toute
l'étendue. Maintenant, une façon de le
faire est d'allonger l'axe X
ici beaucoup plus long. Cela va changer de boîte. C'est un peu exagéré
pour l'acteur lui-même. Lorsque nous travaillons avec des
éléments tels que les volumes, nous avons une autre option. Je vais donc revenir
à la façon idéale de
travailler avec eux qui consiste à modifier les paramètres du pinceau ici. C'est donc la taille de la boîte que nous
avons actuellement, qui fait 200 centimètres de diamètre. Donc, si nous le définissons plutôt sur quelque chose de
beaucoup plus grand, j'ajouterai simplement
quelques zéros ici Nous aurons donc une
boîte de 20 000 unités juste pour encapsuler l'
ensemble de la zone de jeu et un peu plus,
probablement beaucoup plus Mais c'est parfaitement bien. La raison pour laquelle nous
voulons procéder est que
cela change l'échelle du composant réel à l'intérieur,
ce composant
de la boîte à pinceaux. Alors que cette valeur ci-dessus est l'échelle de l'acteur
dans son ensemble. Donc, si nous pouvons garder cela
uniforme et propre, alors si jamais nous avons besoin de
vérifier des choses dans le code, il sera un peu
plus facile de travailler avec. Et encore une fois, cela permet de garder notre
structure un peu plus ordonnée. Pendant que nous sommes
ici, je vais juste augmenter un
peu la hauteur du mur Nous pouvons donc définir ce
paramètre sur quelque chose comme 1 000 sur le Z, juste pour nous
assurer que nous bloquons
absolument tout. autre chose qui peut être
un peu confuse, c'est si c'est un
peu difficile à voir, nous avons des options pour
modifier l'opacité, nous pouvons ajouter un volume
ombré à l'affichage, puis nous pouvons commencer à voir
où se trouve le cube réel Encore une fois, cela ne s'
affiche pas en mode jeu, mais cela se voit
à travers l'appareil photo, ce qui le rend un
peu plus facile à voir. Et l'essentiel
est de pouvoir
évaluer où se produira réellement le
volume de blocage. Cela fait, je
vais simplement appuyer sur Ctrl en D après avoir sélectionné le
volume de blocage que nous avons configuré. Je vais le régler à 1 240, donc nous l'avons sur le
côté droit du terrain de jeu Donc, le YX est là. Et juste pour le rendre visible,
comme sur le bord gauche, je vais simplement
faire défiler la page vers le bas. Activez le volume
ombré de l'écran, et les deux se ressembleront .
Soyez également au courant. Je pense que lorsque nous
dupliquons des éléments, Unreal essaie de déplacer l'acteur
dupliqué de plusieurs unités deux sens afin qu'elles
ne se chevauchent pas complètement Vous pouvez donc voir que sur
le volume droit, nous avons quelques décalages sur le X. Cela ne poserait
aucun problème Mais juste pour apaiser les
voix et mon cerveau, je vais remettre tout ça à
zéro et tout redevenir
beau, bien rangé et
bien entretenu Une fois que de telles
modifications ont été apportées, vous pouvez
appuyer sur Ctrl Shift et S pour enregistrer tout
ce sur quoi nous avons travaillé. Maintenant, nous pouvons passer au playode. Nous allons regarder à
travers notre caméra. Cela va être un
peu difficile à voir car nous ne pouvons pas voir le volume de collage
réel ici. Donc, si nous voulions tester des
choses et
nous assurer de savoir exactement à quel moment nous
risquons
de traverser un mur, une
autre option, un
peu longue, est revenir aux formes.
Nous pourrions ajouter un cube. Si vous souhaitez accéder aux paramètres de
collision dans le panneau de détails sur
le côté droit, et juste pour nous assurer que
nous ne vérifierons que
notre volume de blocage, nous pouvons sélectionner le préréglage de
collision juste ici et le
régler sur l'absence de collision. Nous examinerons plus en détail les collisions
un peu plus tard, mais c'est juste pour
obtenir quelque chose de visuel. Encore une fois, je vais revenir
aux détails, coller ceci dans l'emplacement et mettre ce -1 240. Pour des raisons de rapidité et de
simplicité, je vais juste garder à peu près de la même taille. Il n'est pas nécessaire que ce soit exact, alors nous allons prendre le cube. Sur l'axe Y, nous devons placer
ces deux unités sur le Y pour
obtenir à peu près la taille de notre volume de
blocage. Encore une fois, nous allons l'
agrandir beaucoup sur le X pour qu'il couvre tout, puis l'
agrandir encore une fois sur le Z. Nous n'avons pas besoin d'être aussi
prudents Ici. L'essentiel,
c'est juste quelque chose visuel qui nous permet de voir si et quand le joueur va franchir le mur, comme
nous pouvons le voir ici. La raison principale est
que je savais que la collision
ne fonctionnerait pas, et je voulais juste éliminer
immédiatement le fait que nous traversons effectivement
la zone de liaison, qui devrait
entrer en collision avec nous La raison pour laquelle je
voulais vous présenter cela, car je savais que cela
allait se produire, nous donne un petit exemple
de la façon dont nous pouvons procéder au débogage C'est très important pour
le développement, car il s'agit de comprendre
comment résoudre les problèmes ,
retravailler les choses et
découvrir ce qui se passe. J'ai déjà en quelque sorte répondu à l'
un des problèmes. Tout d'abord, nous n' aurions pas su
si nous
avions
simplement survolé le mur ou non. Nous avons donc déjà oublié
le fait que nous
n'atteignons pas le mur Nous pouvons atteindre la
pointe du mur et aller plus loin sans qu'aucune
collision ne se produise. C'est donc une option de la liste de contrôle
complètement cochée Si je trouve le volume bloquant sur la gauche, nous essaierons
d'abord de résoudre ce problème. Le premier suspect pourrait être les propriétés de
collision que
je viens de vous montrer. Donc, sur le côté droit,
dans le panneau des détails, nous allons revenir sur
les propriétés de collision. En cas de collision, nous pouvons voir que ce préréglage est réglé
sur mur invisible. Si nous réduisons cela, nous pouvons voir
ce que cela signifie. Et ce sera un très bref aperçu
de la collision. Encore une fois, cela
sera beaucoup plus approfondi dans les prochains sujets. Mais pour l'instant, tout ce que nous devons
savoir , c'est qu'il en existe trois types
différents. Nous avons Ignore,
Overlap et Block. Ignorer fait ce que
vous pensez. Il ignore tous les autres
collisionneurs et interactions. La superposition consiste à
rechercher deux objets qui se trouvent dans le
même espace physique, mais qui ne sont pas en contact physique avec des éléments tels que la physique
et qui se bloquent mutuellement. Et puis nous avons un
bloc, qui serait constitué deux objets physiques s'
impactant et essayant de s'éloigner l'un de l'
autre afin qu'ils n'habitent pas le
même espace physique Bref, le mur invisible est
installé exactement comme nous le souhaitons. Il est conçu pour bloquer absolument
tout dans le monde. C'est donc notre deuxième
suspect, d'ailleurs. Nous savons que nous
atteignons le mur et nous savons qu'il y a une collision entre le
mur. Ensuite, nous allons
examiner la collision des casseroles. Donc, si nous allons passer
à la classe de pions, nous allons passer au
maillage statique, et la collision actuelle est
gérée sur le maillage statique Donc, dans le panneau des détails, encore une fois, nous allons vouloir faire défiler la page vers bas et trouver la collision. Nous allons faire défiler les préréglages de
collision, et nous pouvons voir qu'ils sont
configurés pour bloquer toutes les dynamiques Maintenant, cela
n'a pas vraiment d'importance. Encore une fois, l'important
de ces cases à cocher est ici. Cette case est également cochée pour tout bloquer
absolument. Et si nous retournons dans
le monde très rapidement, nous aurons un
cours intensif très rapide sur les collisions Nous pouvons voir que le mur
invisible est configuré comme si
son type d' objet était
défini sur le monde statique. La pornographie elle-même est adaptée
à la dynamique du monde. Cela cherche donc à bloquer les objets statiques
du monde, et cela cherche à bloquer les objets dynamiques
du monde. Donc, tant que ces deux-là
cherchent à interagir, nous devrions assister à un certain blocage
physique. C'est donc le troisième
suspect, d'ailleurs. La collision pornographique est
en fait correctement configurée. La
seule chose qui reste, c'est que nous avons probablement fait quelque chose de
mal dans notre code. Et attention spoiler, je
sais déjà que c'est le problème. Donc, si nous examinons le graphique des
événements relatifs à l'événement, nous allons passer à notre
fonction de définition de la localisation des acteurs ici. Et c'est l'une de ces
choses où il
serait assez difficile de reboguer et de savoir que
c'est le problème
sans vraiment en avoir fait l'
expérience Les deux éléments à surveiller ici sont
les booléens de balayage et de téléportation
lors de l' Si nous survolons le balayage, nous pouvons voir ici la description
que nous obtenons indiquant si nous balayons l' que nous obtenons indiquant si nous balayons emplacement de destination, ce qui déclenche
des chevauchements en cours de route.
C'est vraiment important. Contrôler également
si nous nous arrêtons avant la cible si quelque chose
est bloqué par quelque chose. Ce qui est vraiment important, c'est que si cette case n'est pas
cochée, nous
ne vérifierons pas notre
position est bloquée, ce qui signifie que nous n'
allons rien toucher Bref, décocher la
case balayage revient techniquement à nous téléporter là
où nous voulons être Donc, si nous cochons cette case,
appuyons sur compiler et enregistrer, nous reviendrons en arrière et testerons à nouveau. Nous pouvons maintenant voir que lorsque nous survolons, nous
sommes bloqués. Nous n'avons donc pas eu besoin de
modifier les préréglages de
collision Nous y reviendrons
un peu plus tard. Cela signifie
également que le mur sur le
côté droit fonctionnera parce qu'il est configuré
exactement de la même manière, donc c'est parfaitement bien. C'était juste une chose très
simple, très facile à oublier
dans notre code. Je voulais donc inclure
cela simplement parce que, comme je l'ai mentionné, les choses
ne se passent pas toujours parfaitement, et vous devez
être à l'aise débugger
un peu et d'essayer corriger
les éléments qui, selon vous pourraient
logiquement
être à l'origine du problème C'est l'une de ces choses qui finit par être un
piège très courant C'est vraiment facile de le
rater. C'est vraiment difficile à déboguer si vous ne savez pas
ce que vous recherchez Mais si cela avait échoué, même en
tant que développeur expérimenté,
j'aurais été un peu à
court de pistes de réflexion. J'aurais dû simplement me tant que développeur expérimenté, j'aurais été un peu à
court de pistes de réflexion tourner
vers Google ou RDI ou quelque chose comme ça
et essayer de trouver si quelqu'
un avait eu un problème similaire Il suffit donc de faire un petit nettoyage
avec les limites maintenant. Je vais y retourner.
Je vais me débarrasser de ce cube blanc ici. C'
était juste pour la visualisation. Nous savons maintenant que nous sommes en
train de frayer au bon endroit et que nous sommes
bloqués par les deux murs d' ici.
Donc, une fois que c'est fait. La caméra est fixe. Il est maintenant
en place là où nous le voulions. Les limites sont définies, et
lorsque nous commencerons à ajouter des ennemis, ils détecteront les murs
et rebondiront entre eux. Évidemment, une fois que nous aurons
implémenté ce code. Mais avant cela, nous allons commencer
à examiner les matériaux, les principaux
éléments visuels de notre projet. Nous serons en mesure de personnaliser
l'apparence de nos navires afin que tous les ennemis ne soient pas identiques aux
yeux du joueur. Comme toujours, si vous
voulez expérimenter, le
moment,
essayez quelque chose de simple. Essayez d'ajouter une limite supérieure et
inférieure, surtout si vous avez
déjà un certain mouvement vers
l'avant et vers l'arrière Encore une fois, même
processus, différents axes, histoire de vous familiariser et
d'essayer différentes choses.
10. 09 - Instances de matériaux: À ce moment-là, si nous nous
lançons directement dans la création de nos ennemis, ils
ressembleront exactement à notre joueur. Même avion bleu, pas moyen de
vraiment les différencier. C'est pourquoi nos
matériaux sont utilisés, ce qui nous permet d'associer différentes
couleurs et images à
nos trois modèles en D
afin de
les différencier et d'ajouter de la variété. Nous ne créerons pas de
matériaux à partir de zéro, car ce serait notre
propre terrier à lapins. Comme je l'ai mentionné,
nous nous concentrons principalement sur la programmation, les pratiques et les projets,
les trois P. Mais je vais vous montrer
comment nous pouvons créer des variations de
couleurs à partir de ce que
j'ai réellement fourni. Bien que nous ne créerons pas de
nouveaux matériaux à partir de zéro, je tiens à vous montrer les
matériaux que nous possédons déjà. Si nous examinons les documents du
dossier des actifs, comme je l'ai déjà indiqué à
propos des conventions de dénomination, nous avons
quelques points à examiner. Nous avons deux soulignements MM pour
l'eau et la texture, et nous avons quatre traits de soulignement MI, qui sont les instances du
matériau Mm, qui est un préfixe
pour le matériau principal. C'est là que se produit la véritable logique du
shader. Nous ouvrons la base de texture, nous n'allons
rien modifier ici, mais je voulais juste vous
montrer une partie de la terminologie et des détails que vous
devez connaître. Si nous nous déplaçons sur le
côté gauche du graphique,
cela ressemble beaucoup au
schéma directeur, nous pouvons simplement cliquer avec le bouton
droit de la souris et faire glisser
le pointeur pour nous déplacer La principale chose que nous avons, ce sont trois entrées d'échantillons de texture. Nous avons la couleur de base,
qui est notre palette de couleurs, le bleu, le
grain du bois, la peinture. Et tout cela est tiré de la carte
Ubi sur le modèle tridimensionnel Nous avons alors notre texture
normale ou la carte normale qui ajoute détails à la
surface sans géométrie.
Ces bosses, nervures, lignes de
panneaux, etc., le
tout truqué en manipulant la façon dont la
lumière rebondit sur tout truqué en manipulant la façon dont la
lumière Le dernier élément important
est la texture ORM. Dans ce cas, c'est quelque chose que
j'ai créé personnellement, et mon flux de travail est légèrement
différent. Je l'ai créé en tant qu'ORME
spécifiquement cette fois. Il s'agit essentiellement de
quatre images en niveaux de gris entassées dans un seul
fichier de texture, les canaux RGBA Cela s'explique principalement par le fait que toutes les données qu'ils peuvent être extrapolées
par le biais Cela permet d'économiser de la mémoire et c'est juste un peu
plus facile de travailler avec. Dans ce cas, le canal rouge
est l'occlusion ambiante. C'est là que la lumière
aura du mal à atteindre. Le canal vert est la rugosité, ce crée une surface lisse comme un miroir par rapport surface
mate dans
différentes zones Le canal bleu est
métallique. C'est binaire. Il est métallique
ou non métallique, et le
canal Alpha est émissif, indiquant quelles parties pourraient briller est utile Lorsque vous
travaillez avec des matériaux, il est utile de
savoir qu'au lieu d'avoir simplement cette
représentation sphérique ici, nous pouvons modifier ce qui
apparaît dans cette fenêtre aide d'une astuce d'éditeur pratique Si nous ouvrons le dessin du contenu et que nous
accédons au dossier des maillages, choisissez un maillage que vous souhaitez visualiser avec votre matériau Dans ce cas, ce sera
le héros ordinaire. Nous n'avons
rien à faire avec ça. Nous avons juste besoin
que cela soit sélectionné. Nous pouvons revenir
au matériel jusqu'à ce que nous nous
souvenions de ce que
nous avons actuellement sélectionné dans
le tiroir de contenu Cela peut changer la représentation, la visualisation
de notre matériau ici pour en faire des choses comme un
cylindre, un plan, un cube. Et puis plus précisément
cette icône en forme de brique ici. Si vous avez
sélectionné un maillage statique et que nous cliquons dessus, cela nous donnera une
représentation, une visualisation de notre plan ou du maillage que nous avons actuellement sélectionné dans le tirage au sort du contenu. Cela peut donc être très
pratique pour visualiser les choses et voir exactement qui
est responsable. Mais que se passe-t-il lorsque vous modifiez
différentes propriétés et que vous recevez
un feedback immédiat ? Ensuite, je veux que vous vous concentriez sur ces nœuds nommés partout. Ils sont
appelés nœuds « reroot ». Au lieu de fils qui s'
étendent sur notre graphique, peu comme un panneau de preuves de
la théorie du complot Nous pouvons plutôt choisir de créer des connexions
nommées une seule fois, puis nous pouvons
les référencer absolument n'importe où dans notre
Shader. Complètement optionnel. Vous ne les verrez pas toujours utilisés dans d'autres exemples,
mais c'est le cas encore une fois me
permet
de garder toute ma logique de Shader sur le côté gauche, puis appeler les choses quand j'en ai besoin
sur le côté droit L'une de ces choses
où l'outil existe, alors pourquoi ne pas l'utiliser. Comme je l'ai mentionné, cependant, je
ne recommanderais pas de modifier quoi que ce soit à l'intérieur du
matériau principal à moins que vous ne
sachiez ce que vous faites, ou à tout le moins d'
en
faire un duplicata et d'y apporter quelques modifications afin d'avoir
toujours quelque chose sur
lequel vous appuyer La principale raison, dans le
prochain sujet que nous aborderons concerne les instances matérielles
et la façon dont l'instance fonctionne consiste à générer les informations directement
à partir de ce matériau principal. Donc, si quelque chose entre par
effraction ici, vous
risquez de casser toutes
les instances qui en dépendent. Donc, de retour dans le dossier
des matériaux, si vous vous êtes déplacé, pour gagner un peu
de temps, nous pouvons utiliser un point de départ assez logique. Nous avons déjà un avion. Il contient la plupart des
textures et tout configuré exactement comme nous en avons besoin, le lecteur MI
Underscore Plane Alors allez-y, prenez
celui-ci, appuyez sur la touche Ctrl, en effet, pour le dupliquer et le renommer
en avion ennemi, en gardant le MI à l'avant Si nous double-cliquons dessus
et que nous l'
ouvrons, nous pouvons maintenant commencer
à examiner les instances matérielles. Nous pouvons constater que c'
est très différent de notre matériau principal. Une chose à
surveiller ici se trouve sur le côté droit
dans le panneau des détails. Je dois mentionner que vous
remarquez probablement des tendances ici Chaque fois que nous sommes dans un panel, qu'
il s'agisse de matériaux, plans, de composants, de
pots de vue , lorsque vous saisissez quelque chose, il y a normalement un
panneau de détails qui s'attarde
quelque part pour vous donner informations sur ce que
vous recherchez, qui est certainement l'un des
avantages d'Unreal Lorsque vous commencez à apprendre
certaines parties des ensembles de fonctionnalités, cela est transféré aux différentes fonctionnalités du moteur. Mais ce que j'allais dire, c'est que si nous examinons le panneau des détails, le parent
est indiqué ici, ce qui montre qu'il s'agit texture
du soulignement MM. Nous pouvons donc
double-cliquer dessus, et cela nous ramène simplement
au matériel que je
viens de vous montrer. Donc, comme je l'ai mentionné,
toutes les informations proviennent directement de
ce matériau principal. Autre chose, ce serait bien visualiser
à nouveau l'avion. Donc, juste pour récapituler, retournez
dans le dossier des maillages, prenez le plan et appuyez sur
l' icône en forme de brique ici à l'intérieur
de l'instance de matériau Les principales choses que nous
voulons changer sont les textures. On voit que c'
est très différent. Nous n'avons aucune information
sur le graphique ou sur
ce shader ici Tout cela est spécifiquement
utilisé dans le matériau principal. À l'intérieur de l'instance,
nous avons plutôt des éléments que j'ai
spécifiquement choisi d'exposer. Tout cela a nommé de
grandes notes ici, les textures, la couleur de la texture. Ce sont des
variables paramétrées que j'ai exposées afin que nous puissions
les voir dans l'instance Donc, ce que nous voulons
surveiller si nous abandonnons les catégories de Dan, sont toutes les
choses que je viens montrer sur les propriétés exposées. En les exposant
à l'intérieur des instances, nous obtenons un
environnement de travail vraiment agréable où nous pouvons simplement apporter un changement et voir cette mise à jour immédiatement. Nous pouvons donc le faire pour trouver
notre premier type d'ennemi. Si nous faisons défiler cette couleur de base de
texture, donc les informations de couleur, nous partirons à la
recherche de l'ennemi vert. Je pense que je vais rendre
les ennemis verts. J'ai fourni de nombreuses couleurs de texture
différentes ici si vous vouliez développer cela et créer vos propres types d'ennemis. Je pense avoir inclus le jaune, le violet, peut-être l'orange ou le rouge. Je vais opter pour la texture de base
verte, et nous pouvons voir que cela
changera immédiatement nos informations sur
la plaine. La plupart des textures normales
et OIME sont probablement à peu près les mêmes, mais je
les ai exportées individuellement par texture lorsque je les ai
créées. Nous pouvons donc tout aussi bien aller de l'avant
et reprendre la normale. Nous allons donc
chercher à nouveau le vert, et nous allons trouver
le héros vert ordinaire. Mais cette fois, nous voulons
la texture normale. Enfin, nous allons
supprimer l'emplacement OIME, et nous allons à nouveau
rechercher le vert, et nous allons simplement le remplacer par le vert héros OI ME OK. Donc, juste pour m'
assurer que cela correspond exactement aux modèles que j'ai créés à l'intérieur du mixeur, au
cas où quelqu'un serait curieux, je les ai texturés et j'ai intégré
toutes ces informations
dans Substance Painter Ainsi, comme je l'ai mentionné, vous pouvez voir des flux de travail similaires mais légèrement
différents. Tout dépend de l'artiste et de la personne
qui les crée. La principale chose à
noter, cependant, c'est que nous avons reçu ces commentaires
immédiats. Dès que nous modifiions quelque chose,
il n'y avait pas de recompilation, nous voyions la nouvelle texture
appliquée au matériau, ce qui constitue l'un des principaux
avantages des instances matérielles n'est certainement pas exclusif
à cet avantage, et nous devons toujours essayer d'utiliser instances
matérielles dans
la mesure du possible, où les objets partagent des propriétés, des
caractéristiques et des valeurs
similaires à celles
que nous pouvons exposer. Donc, au-delà des textures,
ce serait un excellent point final si vous êtes satisfait de cette
apparence telle qu'elle est. Je voulais juste
fournir un peu plus d'informations sur les instances
matérielles, ce qu'elles font et comment
nous pouvons les utiliser. Certaines des autres propriétés
que j'ai exposées ici sont des valeurs à virgule flottante
ou des couleurs que nous pouvons directement modifier et remplacer par la couleur ou
la
teinte générale appliquée
au matériau
ou par des éléments tels que le degré de
spécularité de la valeur La spécularité est donc
très facile à examiner. Si je coche sur la spécularité ici, cela
nous permet de le modifier Et pour le moment, nous sommes à 0,5,
soit à peu près la moyenne de la spécularité C'est la quantité de lumière renvoyée
par une surface, ce
qui donne aux objets un aspect un
peu plus plastique ou plus caoutchouteux au fur et à mesure
que la spécularité augmente En général, nous n'avons rien avec lequel nous
interagissons quotidiennement qui
n'a aucune spécularité Il est donc
assez réaliste de commencer quelque part
autour de
0,3 ou 0,5. Si nous réduisons ce chiffre à zéro, nous obtenons un feedback immédiat. Je veux dire, j'ai une surface
complètement mate et totalement non
réfléchissante Si on met tout
cela jusqu'à un, alors la lumière
rebondit d'
autant plus Encore une fois, vous pouvez modifier des
fonctionnalités comme celle-ci et essayer de vous faire une idée de ce à quoi vous voudriez que les
vôtres ressemblent Vous pouvez également
jouer avec des éléments tels qu'un masque de couleur
ou une teinte de couleur. Donc, si nous adoptons le masque de
couleur ici, il agit essentiellement d'un pourcentage
normalisé de 0 Donc zéro n'est pas masqué
et un est un masquage complet. Si nous activons la
couleur de texture, les deux fonctionnent ensemble. Le masque de couleur
masque donc le remplacement de la
couleur de la texture ici. Si je fais en sorte que cela soit
vraiment évident, comme une couleur rouge, puis désactive
le masque en le
rendant efficace à 100 %, laissant
ainsi passer 100 % de la
couleur. Il passe donc à la valeur un. Nous avons maintenant un avion entièrement rose. Nous pouvons donc contrôler
cela très facilement. Et ce qui est vraiment bien, c'
est
que nous recevons des commentaires immédiats et
des mises à jour immédiates lorsque
nous apportons ces modifications. Si vous vouliez que ce soit un
peu plus subtil, nous pourrions changer le masque
de couleur en 0,5, et nous ne laisserons passer que la
moitié de cette couleur
. Redescendez à
0,2, et nous obtenons juste une teinte bleu très clair
sur le dessus de notre avion vert. Baissez-le
complètement à zéro, et aucune
couleur ne transparaîtra du tout. Il s'agit donc d'une autre chose avec laquelle
vous pouvez jouer, ainsi que les différentes
textures que vous pouvez utiliser, puis les
propriétés émissives fonctionnent de la même manière Maintenant, je n'avais rien ici qui puisse vraiment faire briller, comme des lampes frontales ou
quoi que ce soit de ce genre L'émission était donc plutôt un
simple moyen de vous donner différentes
propriétés avec lesquelles jouer. Si j'active la force d'émission, nous devons lui donner une
valeur supérieure à zéro Et puis si nous activons
la couleur émissive, le
moment, c'est le noir Maintenant, évidemment, le
noir est juste zéro, zéro, zéro dans la valeur RGB. Donc, si nous multiplions le
noir par un ou 100, nous allons toujours obtenir du
noir, ce qui n'est rien. Nous devons donc lui donner une
couleur si nous le
changeons jaune ou orange, et nous devrons peut-être augmenter un peu plus
la force. Et c'est l'une de
ces choses
où , en exploitant
différentes textures,
dont certaines, je me suis rendu compte qu'
un canal
émissif riche en textures n'
aurait aucune utilité un canal
émissif riche en textures Donc, si vous voulez
contourner la propriété émissive, vous pouvez
passer à la texture OME ici et nous la remplacerons
à nouveau par le plan bleu Ici, les avions sont bleus.
Il va falloir le modérer un
tout petit peu. Peut-être, mais il y a quelque chose qui ressemble
plus à un ou 0,5, donc cela ne
remplace pas complètement la couleur Et vous pouvez faire briller un peu tout l'
avion ici. Ainsi, vous avez également
le contrôle de la propriété émissive Comme je l'ai dit,
je n'ai malheureusement pas pensé à intégrer certains
phares à l'avance, mais je voulais en améliorer
les propriétés émissives afin vous
puissiez faire briller
l'ensemble de l'avion
et vous amuser Cela pourrait être utile si vous vouliez l'animer en train de
exploser ou quelque chose comme ça Vous pourriez le faire clignoter entre sa
couleur normale et, par exemple,
un rouge avant que l'explosion ne
se produise, une idée C'est juste pour aider à visualiser ce qui se passe ici
et comment fonctionnent ces textures, en particulier l'OIME Je me rends compte que cela
peut prêter à confusion. Je vais juste le désactiver
, et je vais
les remettre en place parce que je ne
veux pas annuler aucun d'entre eux Et je vais
remettre la texture au vert pour
l'OIME, car je sais que celui-ci a été
cuit spécialement pour cette propriété de couleur Je voulais juste vous
montrer très
rapidement les textures
et ce qui se passe. Donc, quand je dis qu'ils
ont été intégrés dans différents canaux, si nous allons dans le dossier
des
textures, nous trouverons que peu importe
lequel, honnêtement. Nous pouvons simplement trouver
le héros bleu uni et je vais
ouvrir la chaîne OIME Donc normalement, la plupart des textures, des
couleurs et tout ce que nous voyons ici
proviennent des canaux RGBA
combinés en même temps Si vous en emportez,
vous n'aurez que des couleurs étranges et
boueuses comme celle-ci où le rouge et bleu combinés nous donneront
évidemment du violet Le rouge et le vert nous donneront une sorte de
couleur orange et ainsi de suite. Nous ne l'utiliserions donc pas de cette façon. Avec le processus ORME, c'est
un peu différent. Et c'est parce que ce que j'ai
fait, dans le canal rouge, c'est notre occlusion ambiante Ainsi, tout ce qui est
blanc n'est essentiellement bloqué par aucun autre
élément du modèle. La lumière a donc un
impact total sur nous, puis tout ce qui
passe au gris ou noir présente une sorte d' occlusion provenant d'une autre
partie du modèle, peu comme le
roulement sous la roue Et il y appliquera
un peu de fausse ombre pour
mettre en valeur les ombres Dans le canal vert,
c'était notre rugosité. Encore une fois, en passant
d'une valeur de zéro à un, les
différentes zones semblent
plus rugueuses, comme celles qui fournissent
des détails approximatifs, alors qu'elles seront
beaucoup plus lisses. Le bleu était le métal, donc encore une fois, c'était métallique
ou non. Ce serait donc l'
avant de l'hélice. Il y a quelques petites pièces
métalliques sur les roues et d'autres
petites caractéristiques de ce genre. Ensuite, le canal Alpha a été cuit, et comme
vous pouvez le voir ici, c'est essentiellement
le corps entier de l'avion qui a été intégré
dans le canal émissif Ainsi, en extrayant ces informations et en
les
multipliant par rapport à nos propriétés de
couleur et
à d'autres éléments du matériau, nous pouvons manipuler
des éléments spécifiques du modèle par le biais de
nos canaux de texture C'est donc une
façon intelligente de faire les choses. Cela permet d'économiser de la mémoire
et nous donne un peu plus de flexibilité
dans nos matériaux. Juste quelques autres choses
avant de terminer sur ce sujet. Si vous vouliez
jouer avec plus de matériaux, il vous suffit de vous montrer
différentes manières de créer différentes instances de
matériaux. Je vous ai montré comment dupliquer notre contenu original pour les joueurs. Le contrôle en D le
dupliquera. Si vous savez que
vous voulez simplement
créer quelque chose de complètement nouveau, un tout nouveau matériau avec lequel
jouer, nous allons simplement passer au matériau
et nous le sélectionnerons. Si vous avez déjà
un matériau principal sur lequel travailler et que vous
souhaitez créer une nouvelle instance,
vous pouvez cliquer avec le bouton droit sur
le matériau principal ici, naviguer vers le haut ici et créer une nouvelle instance de
matériau. Cela vous donnerait
quelque chose de très similaire
au plan du joueur ou à
ce que j'avais auparavant, et il y aurait juste des valeurs préremplies
par défaut, essentiellement le même résultat. Je vais donc me débarrasser de celui-ci.
Je n'aurai pas besoin de le garder. Je voulais juste vous
montrer comment vous pouviez
travailler avec ceux-ci. Je dis
cela parce que c'est probablement
l'un des sujets les plus faciles à
aborder, et nous n'allons pas entrer beaucoup plus en profondeur que ce que nous avons fait ici. Je recommande vivement de
prendre du temps entre les sujets pour suspendre les vidéos
et prendre du recul. Créez peut-être quelques
instances de matériaux avec des couleurs différentes. Cela vous donnera la possibilité plus tard d'avoir un ennemi vert, un ennemi violet, un ennemi
rouge, selon votre
vision du jeu. Vous pouvez également essayer de
donner des jetons
différents, des valeurs de laïcité différentes, d'
ajouter une petite propriété missive
à certains
d'entre eux
ou de leur donner une teinte de couleur Donc, si vous vouliez vraiment
commencer à en savoir plus sur le moteur et vraiment
comprendre ce qui se passe, considérez cela comme un petit devoir entre
ce sujet et le suivant et essayez de créer quelques
instances matérielles entre les deux. Mais une fois cela fait, notre
matériel est en quelque sorte couvert, et nous sommes prêts
à utiliser du matériel ennemi pouvoir commencer à créer
nos nouvelles classes. À l'aide d'instances de matériaux,
nous avons pu créer cette nouvelle variation sans
toucher à aucune couche, en utilisant la
classe de matériau parent que j'ai fournie, avec toute
une gamme de possibilités pour les instances
de matériaux qui en découlent.
11. 10 - EnemyMovement: est temps de se faire des
ennemis. Attention, nous allons d'abord le faire de la manière
sous-optimale. Vous pourriez remettre en question certains
des choix si vous connaissez Unreal Encore une fois, c'est
tout à fait intentionnel, et cette fois c'est pour
nous permettre de refactoriser notre travail Le refactoring fait partie de
tout développement réel. Il s'agit de prendre la base de code ou le
projet que vous avez déjà, améliorer le code qui
fonctionne que vous souhaitez conserver et de supprimer
ce dont vous n'avez pas besoin. Je veux m'assurer
d'avoir l'occasion passer en revue tout cela avec vous afin vous montrer comment rendre le processus un
peu plus indolore Mais bien sûr,
nous allons d'abord avoir besoin de quelque chose qui
nous permette de nous refactoriser Pour ce faire, nous allons
créer notre pion ennemi. Donc, si nous accédons
au tiroir de contenu situé à l'intérieur du plan
et du dossier principal, nous allons
cliquer ici avec le bouton droit de la souris, accéder à l'option de classe de plan
et créer une nouvelle classe de pion Nous allons donner à celui-ci le nom
de BP Underscore pawn Enemy. Entrez pour l'ouvrir, et
ce sera presque identique à ce que nous avons déjà configuré pour notre joueur. Et cela fait essentiellement
partie du problème initial. Nous allons dupliquer un certain nombre de travaux que
nous avons déjà effectués Nous examinerons la
meilleure solution plus tard, mais pour le moment, nous allons
simplement nous baser sur ce que nous avions auparavant
avec notre joueur. Ainsi, dans le panneau des composants, nous savons que nous voulons ajouter
un nouveau maillage statique. Nous allons récupérer
notre maillage statique et déposer sur la racine de scène
par défaut. Une fois le maillage statique sélectionné, nous allons
passer sur le
côté droit du panneau Détails, et nous allons choisir d'utiliser le héros du plan de soulignement
SM Bien entendu, nous ne voulons pas que
ce soit de la même couleur. Et si vous ne pouvez pas
voir vos matériaux dans le panneau de détails pour le
moment, il suffit de cliquer sur le maillage statique pour trouver
l'autre composant. Sélectionnez à nouveau le maillage statique, et vous pouvez voir que
notre matériau est maintenant sélectionné. L'élément zéro est le
corps de l'avion. C'est la
couleur principale et le détail. Le premier élément est une fente de matériau
séparée créée exclusivement pour
l'hélice en bois Cela nous permet de faire des choses comme animation basée sur les
sommets à travers le shader pour donner l'
impression que l'hélice se Un peu complexe
pour ce projet, mais les fonctionnalités s'y trouvent si vous
vouliez l'étendre ultérieurement. Si nous faisons tomber l'élément zéro, nous voulons rechercher
le matériel ennemi. Et bien sûr, si
vous avez suivi les étapes supplémentaires recommandées
entre les sujets, vous aurez peut-être le choix entre différents
matériaux. Nous allons sélectionner
celui-ci, et vous verrez que mon avion est devenu vert Il devrait
donc se démarquer du
modèle et du matériau de
l'avion par défaut du joueur. Ensuite, nous allons vouloir
ajouter du mouvement à notre ennemi. Donc, si nous passons au graphique
des événements, nous faisons la même chose que précédemment, supprimant le chevauchement des Acta begin Nous ne l'utiliserons pas, et nous
pouvons nous concentrer sur le cas échéant. Il est toujours utile de
prendre l'habitude de vraiment planifier à l'
avance les fonctionnalités que vous
allez implémenter. Nous pourrions le faire, par
exemple, en examinant
le
projet d'exemples de contenu
sur lequel nous nous basons et en analysant les fonctionnalités de base et
les
caractéristiques dont le
projet d'exemples de contenu
sur lequel nous nous basons et en analysant les fonctionnalités de base et
les disposeront les ennemis La première est que le mouvement n'est pas le même que celui des joueurs. Il n'y a pas
ce faux élan ou ce genre de
pseudophysique C'est plus rapide,
je me déplace simplement vers la gauche, droite et le bas de l'écran.
Nous avons donc un mouvement en diagonale. Cela nous permet de planifier un
peu à l'avance , car
nous pouvons également voir des choses lorsque l'ennemi heurte le mur, il
change de direction. Nous savons donc que nous devons effectuer des
mouvements latéraux et des mouvements
vers l'avant, et lorsqu'ils heurtent
des murs, nous devons faire quelque chose pour tenir compte
d'un changement de direction Structurer nos projets de
cette façon
nous permet de décomposer de manière assez
logique un problème plus vaste en sous-problèmes qui seront plus faciles à résoudre,
et nous pouvons les
aborder étape Donc, pour commencer, la première
chose que nous allons vouloir
faire est d' ajouter
le décalage de l'acteur,
le même type de décalage de position
que celui que nous avions auparavant Donc, à partir de l'épingle
EventiceExecution ici, nous allons
rechercher la position définie de l'acteur Encore une fois, c'est très similaire à ce que
nous avons fait dans le lecteur. Nous voudrons également utiliser la même approche
pour savoir où se trouve
l'acteur en ce moment
, puis y ajouter un décalage. Nous allons donc utiliser le
get actor location, et nous ferons des choses très
similaires auparavant. À partir de là
, nous
rechercherons « ajouter » ou nous appuierons simplement sur
le bouton plus. Nous allons d'
abord faire le calcul avant de brancher
quoi que ce soit, puis une fois que tout sera
terminé et prêt à fonctionner, nous pourrons le connecter et le tester pour nous
assurer que nous
partons du bon pied Nous savons déjà que nous
ne voulons pas de nombres magiques. Nous pouvons
donc tout aussi bien
créer quelques variables dont je peux déjà voir qu'elles
nous seront nécessaires. La première sera une valeur à virgule
flottante pour la vitesse de déplacement. Juste un petit conseil ici. Si vous créez une nouvelle variable ici, par défaut, ce
sera un booléen En fait, nous pouvons
garder celui-ci. La façon dont nous conduisons le
mouvement consiste à vérifier si
nous nous déplaçons à gauche ou à droite. Alors tant que nous l'avons ? Allons-y et appelons
celui-ci B, bouge vers la gauche. C'était donc juste pour
dire que chaque fois que vous créez une nouvelle variable, vous
recevrez un booléen Un raccourci que j'aime
prendre, sachant que j'ai besoin d'une valeur à virgule flottante
pour la vitesse de déplacement, similaire à ce que
nous avons utilisé auparavant. Nous pouvons tirer parti de
cette épingle verte ici. Le vert indique que le delta des secondes est
une valeur flottante. Déposez-le dans le graphique
, puis cliquez sur Promouvoir en variable. Nous allons donner à celle-ci le
nom de vitesse de déplacement. Et ce n'est qu'un moyen rapide d'
obtenir une variable du type que vous recherchez
sans avoir à utiliser le menu déroulant pour la trouver dans
le graphique Vous pouvez le faire de toute
façon, mais c'est
bien si nous avons besoin d'un
vecteur, par exemple, nous pouvons trouver un vecteur aléatoire, déposer dans le graphique,
promouvoir la variable, puis lui donner un nom comme celui-ci. La seule chose est que nous
devons faire un peu de nettoyage, nous allons
donc supprimer les nœuds Nous n'en aurons pas encore besoin. Mais je voulais juste vous
présenter différentes
manières travailler avec l'éditeur de graphes Unreal
Engine Le vecteur n'était qu'un exemple, alors sélectionnez-le et supprimez également
cette variable. Et
nous sommes prêts à continuer. En ce qui concerne le
mouvement, nous avons déjà abordé la question de l'
indépendance de la fréquence d'images et expliqué pourquoi nous
en avons besoin, afin de pouvoir l'intégrer dès le départ. Si nous cliquons avec le bouton droit de la souris et recherchons secondes
Get Wild Delta nous pouvons les utiliser dans nos prochains
calculs. Pour le mouvement, nous allons
vouloir prendre notre vitesse de déplacement. Et si nous appuyons sur Compiler et que nous nous
assurons simplement qu'il y
a une variable, nous la définirons à
quelque chose comme 250. Ce serait parfaitement
bien pour les tests. Et comme je l'ai mentionné,
nous allons avoir
besoin de deux calculs distincts. Nous allons en vouloir un
pour les mouvements latéraux et
un pour le mouvement vers l'avant vers
le bas de l'écran Pour le mouvement vers l'avant, nous
pouvons prendre notre vitesse de déplacement. Nous pouvons le multiplier par
une valeur pour l'inverser. Nous allons
donc prendre cela comme négatif car, comme je
l'ai mentionné, le bas de l'écran est une valeur négative, et si vous vouliez vous
déplacer vers le haut de l'écran, ce serait une valeur positive Le mouvement vers l'avant de
l'ennemi est donc en fait
relativement simple. Et, bien entendu, nous voulons
multiplier ce résultat par le
delta des secondes pour que les choses restent indépendantes de la
fréquence d'images par seconde. Ce serait donc essentiellement
notre mouvement vers l'avant
prêt à être testé. Pour le mouvement latéral,
nous allons vouloir
faire quelque chose avec
notre valeur booléenne Je vais donc saisir la vitesse de déplacement
et la dupliquer. Nous allons vouloir faire
quelque chose de très similaire ici où nous allons prendre
un nœud de multiplication, mais nous n'
allons évidemment pas vouloir multiplier un seul
ou moins un. Nous devons en faire une sorte d'opération
conditionnelle. La façon dont nous allons utiliser le booléen est un vrai
ou un faux stick Nous dirions que nous nous déplaçons vers la gauche ou que nous ne nous déplaçons pas vers la gauche,
donc nous nous déplaçons vers la droite. Maintenant, si vous avez essayé
cela, nr convertira
un booléen en une multiplication à virgule
flottante Malheureusement, les booléens
ne se lisent que comme zéro ou un, zéro quand c'est faux,
un quand c' Cela
signifierait évidemment que cela ne
fonctionnera pas dans notre cas d'utilisation actuel, car si nous multiplions par
zéro plutôt que de nous déplacer vers la gauche, cela prendrait simplement la vitesse de déplacement,
la multiplierait par
zéro, ce qui
annulerait tout
mouvement quel qu' il soit Ce que nous pourrions faire, c'est que si nous appuyons sur Alt et que nous cliquons avec le bouton
gauche de la souris ici, nous pouvons utiliser ce que l'
on appelle un nœud de sélection. Nous allons donc
partir de là, rechercher Select. Et nous voulons cette option en bas
de page. Cela
nous donne quelques options. Si nous travaillons
avec des éléments tels que des
entiers comme caractères génériques, vous pouvez voir que nous ajoutons n'importe quel
nombre d' Quel que soit le nombre entier que vous placez ici, donc
n'importe quel nombre entier, si vous placez un
entier égal à un, par
exemple, nous pourrions lui donner
une valeur négative ici. Ce que nous voulons faire à la place, c'est prendre notre booléen Nous allons l'insérer
dans l'index ici,
le joker, et Unreal le
transformera en booléen pour Et nous pouvons voir que
cela est maintenant défini comme vrai ou faux. Donc, la façon dont nous
pouvons lire ceci pour le rendre plus intuitif
et plus facile à comprendre, c'est que nous pouvons dire que si nous voulons aller
vers la gauche,
allons-nous vers la gauche ? Si c'est vrai,
la valeur doit être négative un car nous
voulons introduire une valeur négative. Si le déplacement vers la gauche est
égal à faux, donc nous ne nous déplaçons pas vers la gauche, nous voulons que la valeur soit un. Donc, en gros, cela
va dans le bon sens. Cela se déplace vers la gauche, et
cela
va être positif et négatif. C'est donc un
moyen simple et agréable
d'utiliser une valeur booléenne pour activer ou
non
le déplacement vers la gauche Et puis, lorsque vous
recommencerez la même chose, nous prendrons nos secondes Delta. Nous allons effectuer notre calcul ici, multiplier par les secondes
delta pour nous assurer que les deux directions sont indépendantes de la
fréquence d'images, et nous pourrions essentiellement
commencer à l'intégrer Donc, juste pour garder les choses en ordre, je vais utiliser
l'épingle vectorielle ici et rechercher make vector Nous les avons donc déjà vus.
Cela nous donnera simplement les trois valeurs à virgule
flottante exposées. L'avant dans Unreil
se trouve sur l'axe X. Sideways est sur l'axe Y,
et c'est à peu près tout. Nous pouvons le connecter.
Nous pourrions le tester, et nous aurions
un ennemi en mouvement. Donc, si nous appuyons sur compiler, enregistrer, nous retournerons au niveau principal, nous pouvons
simplement laisser tomber notre ennemi. Peu importe où cela va
se trouver tant que c' juste en haut de l'
écran par rapport au joueur. Je vais lui donner
une
rotation de 180 degrés sur l'axe Z, afin qu'il soit orienté
vers le joueur. Ensuite, nous pouvons appuyer sur Play, et nous devrions voir cela se déplacer vers le
bas de l'écran. Cela se déplace
en diagonale, ce qui est la première
partie du problème. C'est donc l'une de
ces étapes résolue. Je pense avoir remarqué un
petit problème ici. On dirait que
nous allons
traverser le mur invisible. Donc oui, l'
ennemi a certainement franchi le mur invisible. Je pense que c'est juste
dans les limites. Comme je l'ai dit, il
est très facile d'oublier, et je viens de le refaire,
c'est que nous
voulons nous assurer d'
appuyer sur le bouton de balayage,
donc nous assurer que
nous sommes en train de balayer, et que nous ne devrions pas avoir les mêmes
fonctionnalités que le joueur, mais nous allons simplement appuyer sur le mur
invisible et arrêter Parfait. C'est donc la partie
suivante du problème. C'est la prochaine étape
que nous devons résoudre. Lorsque l'ennemi heurte le mur, nous voulons prendre cette information et changer le sens du
mouvement Et nous avons déjà
en quelque sorte déjà cette configuration. Il ne nous reste donc plus qu'à nous déplacer.
Nous allons changer cela en vrai et les faire se déplacer vers la gauche par rapport à la direction de l'
ennemi. Juste avant de
passer en revue cela, je voulais passer en
revue quelques
informations sur la propreté générale du
code, les
points que nous pourrions
améliorer ici, avant même de procéder à une refonte majeure Je l'ai volontairement présenté pour
le
rendre plus lisible
et compréhensible Mais il s'agit en fait d'un code
assez mauvais
avant même que nous n'abordions ce que
nous devrons refactoriser plus tard Maintenant, la première chose
est que je veux juste initier les gens
aux commentaires, ce que je
n'ai pas encore mentionné. Si nous saisissons un nœud, par
exemple, et que nous appuyons sur C,
nous pouvons faire un commentaire. Une sorte d'
auto-documentation destinée à nous rappeler
ce qu'était une chose, pourquoi le calcul est
effectué, comment c'était. Et cela rend également les choses un
peu plus lisibles
à distance. Vous n'avez pas besoin
de tout commenter. Vous avez peut-être vu
certains développeurs partager une partie de leur base de code, et il se peut qu'il y ait eu des
commentaires éparpillés un peu partout. Vous avez peut-être vu des choses
comme celle-ci où ils ont une variable ou quelque chose de
très simple comme celui-ci appelé vitesse de déplacement, et ils commenté simplement en disant vitesse de
déplacement. C'est totalement arbitraire. Cela ne fait rien.
Ce n'est pas utile. Et tant que vous
nommez vos variables correctement ou avec
une bonne intention, nous savons déjà qu'il
s'agit de la vitesse de déplacement car c'est le
nom de la variable. Nous n'avons donc pas besoin de
commenter comme ça. Cependant, si nous le saisissons et l'
étendons pour couvrir
tous ces nœuds, nous pourrions le modifier pour
dire quelque chose comme déplacer
la direction, avancer. Et nous pourrions même
rendre cela plus utile car si nous appuyons sur F deux pour
le renommer à nouveau, nous pourrions également expliquer
pourquoi nous utilisons moins un
comme multiplicateur parce que cela n'a pas
de valeur Cela n'a pas vraiment
l'utilité d'avoir une variable. C'est donc une bonne idée d'
avoir un chiffre magique
ici, mais en un coup d'œil, nous pourrions oublier pourquoi
un chiffre négatif est appliqué Nous pourrions
donc laisser un commentaire décrivant simplement
ce qui se passe. Nous pouvons donc dire ici que nous le
multiplions par un pour déplacer les ennemis spécifiquement vers le bas de l'écran Ensuite, faites quelque chose de très similaire.
Nous pourrions récupérer ces nœuds, appuyer sur C, et nous donnerons à
celui-ci un commentaire similaire. Celui-ci n'a pas vraiment
besoin d'explication. Je pense que c'est très clair. Si nous nous déplaçons vers la gauche,
prenez la valeur correspondant à la direction dans laquelle
nous voulons nous déplacer. Le principal avantage que nous en
tirons est que si nous commençons à dézoomer sur le graphique, nous pouvons maintenant voir cette section sans vraiment
regarder le code Cette section est destinée à
avancer. C'est pour les mouvements latéraux. Si vous avez besoin d'affiner
rapidement et de trouver un morceau de code spécifique pour corriger quelque chose ou de le
vérifier,
nous savons exactement
où il s'agit simplement de l'utilisation de commentaires.
Elles peuvent être utiles. Vous n'êtes pas obligé de les
utiliser partout, mais certainement dans des endroits où vous pensez que
vous pourriez oublier ce que vous faites si vous revenez
dans un mois ou deux. Maintenant, le principal problème que
nous voulons résoudre maintenant,
je vais
les supprimer, c'est que nous sommes train de faire un
tas de doublons. les secondes de G World Delta Ici, les secondes de G World Delta
sont multipliées deux fois individuellement. donc une chose que nous pourrions
faire, et cela n'
était peut-être pas tout à fait
évident au départ, mais plutôt que de multiplier les valeurs individuelles à virgule
flottante ici, nous pouvons
les multiplier par le résultat Donc, si nous prenons les résultats de ce vecteur make
que nous avons créé, extrayons-le à partir d'ici et
cherchons multiplier. Nous pouvons saisir l'une de nos secondes Get
world to Delta, appuyer sur Ctrl X pour le couper et contrôle B pour le coller
, puis le brancher ici. Et RL le convertit en un
vecteur multiplié par un flottant. Nous pouvons intégrer ce
calcul ici. Ensuite, nous pouvons nous
débarrasser de ce nœud ici, afin de ne
plus avoir besoin de ce multiple et de le brancher. Et nous pouvons nous débarrasser
de ces deux nœuds. Nous n'en avons pas du tout besoin,
puis rebranchez-les sur le Y. Nous avons
donc maintenant quelque chose
d'un peu plus ordonné. Nous n'avons pas autant de
multiplications en cours. Nous prenons maintenant le vecteur
entier,
qui effectuera la
multiplication du X et
du Y en même temps par
rapport à nos secondes Delta, afin de garantir que tout
est
indépendant du cadrage pendant l'
ensemble du calcul C'était donc juste un code très
rapide. Donc, si nous appuyons sur compiler et enregistrer, nous devrions obtenir exactement la même réponse, donc
rien ne change. Son apparence et ses mouvements sont les
mêmes qu'avant. Enfin, avant de passer
à autre chose avant de passer à
la
nuit avant de passer au facteur Ru,
tous les ennemis vont commencer à se déplacer dans la même direction
et à la même vitesse, ce qui sera un
peu ennuyeux. Si nous l'ajoutons à
quelques ennemis, nous pouvons simplement maintenir la touche Alt enfoncée et faire glisser le widget ici pour le
dupliquer immédiatement. Il me suffit donc de maintenir la touche LT enfoncée, saisir la
direction du widget et faire glisser dans une direction qui dupliquera
ce que nous avons Si nous appuyons sur Play, cela
ressemblera à une sorte de nage
synchronisée Ils vont tous exactement dans la même direction, à la même vitesse. Ça va être un
peu ennuyeux. Donc, si nous revenons
au début du jeu, je vais d'abord vous montrer
comment randomiser un booléen pour au moins changer la direction dans laquelle les ennemis
peuvent
se déplacer . C'est
en fait très simple. Nous allons maintenir la touche Alt enfoncée et faire glisser la flèche vers la gauche
à côté de l'événement pour commencer à jouer. Ou vous pouvez simplement le mettre sur
l'épingle d'exécution juste ici. Ensuite, à partir de la variable, nous voulons faire glisser le pointeur depuis l'épingle située ici. Je vais chercher quelque
chose qui s'appelle Random Ball. Nous allons donc
obtenir un booléen aléatoire et le définir
sur le BigNPlay C'est tellement simple. Nous avons 50
% de chances de nous
déplacer à gauche ou à droite. Donc, si nous appuyons sur Play,
ils ont tous choisi d' aller dans la même direction et
ils ont recommencé. Nous pouvons voir qu'il y a une certaine
randomisation, donc c'est une bonne chose. Ils n'iront pas toujours exactement
dans la même direction. C'est donc un petit
exercice d'apprentissage pour vous. L'approche utilisée pour faire un flottement aléatoire est
légèrement différente, mais prenez quelques minutes, mettez
la vidéo en pause et voyez si vous pouvez implémenter quelque chose de similaire
avec la vitesse de déplacement. Tenez donc compte de la
vitesse de déplacement et voyez si vous pouvez trouver des fonctionnalités
intégrées que l'UNR pourrait avoir
pour nous permettre extraire une valeur aléatoire dans
la virgule flottante Vous pouvez le répartir aléatoirement
entre 250, qui est actuellement notre
valeur par défaut, et peut-être 500, afin que chaque ennemi se déplace à une vitesse légèrement
différente Mettez la vidéo en pause,
essayez-la et commencez à tester dans quelle mesure
vous vous sentez à l'aise avec le système Blueprint OK, donc je vais
vous expliquer comment je l'
aurais fait. Si nous le branchons et j'espère que
vous l'avez essayé, car encore une fois, seront vraiment utiles
pour apprendre à utiliser des plans plutôt que de
simplement suivre mes étapes Mais pour que nous ayons
le même code, à tout
le moins, ou
quelque chose à partir duquel nous pouvons nous baser. Ce que je ferais, c'est de saisir
ma variable de vol ici. Nous allons choisir
un appartement au hasard. C'est la seule chose qui
vous a peut-être dérangé, et vous avez peut-être
voulu essayer différentes options. Mais plutôt que d'
utiliser simplement un nombre à virgule flottante aléatoire, qui vous
donnerait n'importe quel nombre, cela peut être très
rapide ou
vraiment très lent. Donc pas trop utilisable. Vous auriez également pu essayer des choses comme random float from stream. Mais celui que j'
utiliserais serait ce flotteur aléatoire dans la plage. Donc, si nous sélectionnons
celui-ci, cela nous donne juste deux points à choisir
parmi notre minimum, qui serait, je
dirais, 250, et nous doublerons ce chiffre pour le
porter à 500 comme maximum. Certains avions peuvent donc
obtenir ce minimum de 250, autres 500 ou une valeur intermédiaire. Et nous y voilà. Nous pouvons voir qu'ils
démarrent tous à des vitesses complètement différentes, ce qui, encore une fois, ne
fera
que rendre les choses un peu plus intéressantes lorsque nous les ajouterons et qu'ils fonctionnent correctement dans le niveau, rebondissent sur les murs
et d'autres choses de ce genre Mais avec cela, les ennemis se
déplacent et entrent en
collision avec les murs Ils ne rebondissent pas encore et ils n'
interagiront pas non plus avec le joueur Avant d'aborder le grand facteur Ruf, nous allons maintenant nous intéresser à la détection des collisions, qui fait en sorte que des choses se produisent réellement lorsque des objets se touchent
12. 11 - EnemyCollision: Vous avez des ennemis qui bougent, mais
ils ne réagissent à rien. Idéalement, lorsqu'un ennemi touche quelque chose, nous devons
vérifier de quoi il s'agit. S'agit-il d'un mur, et si oui,
changez de direction. Si c'est le joueur,
comme le montre à nouveau l'
exemple de projet, à nouveau l'
exemple de projet,
il s'est infligé des dégâts et a été détruit. Donc, ce que nous allons faire, c'est
détruire automatiquement l'ennemi
s'il touche le joueur. projectiles vont
se débrouiller tout seuls, nous y penserons un peu plus tard Ce ne sera pas un
problème à prendre en compte ici. Une chose à mentionner est que
le système de collision Unreal est flexible et puissant, ce qui le
rend malheureusement un peu complexe Au moins, lorsque vous commencez à
travailler avec ce système après avoir essayé différentes itérations de différents types de choses que
vous voulez en faire, je pense qu'il clique assez rapidement et que c'est un
système assez confortable à utiliser Revenons donc
à l'ennemi. Nous pouvons l'utiliser pour les
tests. Si nous saisissons le maillage statique et ouvrons la section de collision
sur le côté droit, faites
simplement défiler la page vers le bas
pour trouver notre catégorie de collision. Si nous le laissons tomber, nous pouvons voir le préréglage de collision ici.
Nous allons supprimer celui-ci. Nous pouvons le voir défini sur
bloc ou dynamique. Voici donc notre configuration de
collision actuelle. Le type d'objet est également
défini sur World Dynamic ici Il s'agit donc du canal de
collision auquel cet objet s'identifie. C'est pourquoi lorsque nous appuyons sur Play, l'ennemi s'arrête sur les murs. Il s'agit d'une
collision physique ou physique au cours de laquelle ils se
bloquent mutuellement et essaient de ne pas habiter le même espace physique Maintenant, si nous supprimons
celui-ci et que nous le changeons en
superposition ou en dynamique, donc l'équivalent,
sauf pour les chevauchements, nous allons appuyer sur compiler
et jouer rapidement Ce que nous allons voir, c'est qu'ils
repassent maintenant à travers les murs. Maintenant, sous le capot,
quelque chose est en train de se déclencher. Un message est envoyé
disant que ces trois ennemis
viennent de chevaucher le mur Mais comme il ne s'agit pas d'une interaction
physique, il s'agit simplement d'une notification et essentiellement
d'une observation indiquant qu'ils traversaient
le même espace. Vous pouvez en quelque sorte
penser au blocage par opposition au chevauchement comme
dans un jeu de course. Nous voulons que les murs et
les environs bloquent les véhicules. Vous les percutez,
vous vous faites arrêter. Nous voulons que les points de contrôle
se chevauchent. Nous voulons évidemment
savoir si un véhicule a franchi un point de contrôle
et à quelle heure cela s'est produit, mais nous ne voudrions pas que ces
points de contrôle bloquent
physiquement les
voitures Ce serait juste un
peu embêtant. Donc, si nous
revenons à l'ennemi pion, c'était juste pour montrer en
quoi il fonctionne différemment Nous avons également la troisième
option. Nous avons l'option d'ignorer. Maintenant, celui-ci est
probablement assez évident. Cela fera en sorte qu'il ignore
tous les types de collision. Vous pourriez le faire, par exemple, en accédant à l'option sans
collision, et même s'il
semble que
cela indique qu'
elle est configurée pour bloquer, cela se trouve en fait dans le code, lisant l'option Ignore. Maintenant,
aucun message ne sera envoyé. Rien ne sait vraiment si l'
avion est en train de le traverser. Et c'est utile pour les objets qui n'ont pas besoin d'être ajoutés à la pile d'appels et à la pile de
vérification des collisions . C'est tellement
bon pour les performances. Mais en général, nous allons travailler avec
des chevauchements ou blocages en fonction de ce dont
nous avons besoin. Dans ce cas, nous pouvons
rétablir sa valeur par défaut, qui
est la dynamique des blocs. Je l'ai fait en appuyant
simplement ici. Vous pouvez voir la petite flèche. Si vous souhaitez rétablir les
propriétés par défaut, suffit d'appuyer dessus,
et cela revient
à ce qu'il était avant que nous ne
modifiions les choses. Le maillage statique
étant toujours sélectionné, nous voulons faire
défiler vers le bas
dans
le panneau des détails. Et nous avons ces options
ici, les événements. Maintenant, nous n'allons pas tous les
passer en revue. Encore une fois, les choses qui nous
intéresseront le
plus souvent seront
le succès sur le composant. Cela se produit lorsque deux
éléments se
bloquent physiquement et qu'
un composant commence à se chevaucher, et parfois à l'extrémité d'
un composant, un chevauchement. Ils sont appelés lorsque
deux objets qui se chevauchent entrent
ou sortent de chacun Nous pouvons donc obtenir le chevauchement final
car, comme nous l'avons vu, les collisions
qui se chevauchent
permettent aux objets d' habiter le même espace physique Nous voulons lier
notre vérification murale à la fonction « on component begin
hit » ici. Cela crée un nouvel
événement client pour nous, donc function, qui a appelé chaque fois une collision est détectée
sur notre maillage statique. Donc, si vous vous souvenez,
chaque fois que nous avons créé notre classe et
que nous avions cette fonction par défaut,
nous n'avions pas vraiment besoin la fonction Actor Hit,
que nous avons toujours supprimée. C'était essentiellement
la même chose, mais comme je l'ai mentionné,
pour toute la classe. Alors que maintenant, nous pouvons affiner
et
vérifier spécifiquement si seul le
maillage statique a été atteint, puis nous pouvons faire
quelque chose par la suite. Ces nœuds fournissent en
fait un grand nombre d'informations. Par exemple, si
nous cliquons avec le bouton droit de
la souris sur l'épingle de la structure et que nous
sélectionnons
l'option permettant de diviser la structure, nous pouvons voir toutes les informations
que nous pouvons récupérer chaque fois que quelque chose nous
touche ou que nous
touchons quelque chose. Nous pouvons
trouver l'heure. Nous pouvons savoir si le
blocage a réussi. Nous pouvons voir le
lieu réel de l'impact et le point d'impact. Nous pouvons obtenir des éléments tels que
la rotation à partir de cela, le type de
matériau physique, etc. Nous n'avons pas besoin de tout cela pour
le moment, mais c'est utile.
Encore une fois, au fur et à mesure que vous serez de plus en plus avancé et à l'aise
avec Unreal, si vous voulez faire des choses
sophistiquées comme la pénétration de
balles ou le type de résultats qui se produisent
lorsque deux objets entrent en collision, vous pouvez certainement vous plonger
ici et voir ce qui est disponible Cliquez simplement sur l'une
de ces épingles, mais recombinez l'épingle de structure
juste pour remettre ce nœud en ordre La principale chose sur laquelle nous avons tendance
à travailler lorsque
nous travaillons sur des collisions est de vouloir
connaître un peu d' informations sur
l'autre acteur, car pour le moment, nous
ne savons pas ce qui nous frappe. Nous savons juste que nous avons été
touchés lorsque cela a été annoncé. Cela peut être le
mur, cela peut être un joueur, cela peut
être un autre ennemi. Il sera donc
utile de le lire plus tard Nous pouvons
donc aussi bien le promouvoir
en tant que variable maintenant, et nous
l'appellerons acteur à succès. C'est pourquoi je voulais juste
prendre un petit moment pour passer en revue les différentes
manières dont vous pourriez même envisager de résoudre
ce problème, de
découvrir ce qui nous a frappé. Dans de nombreux projets d'étudiants
que je révise et sur lesquels je travaille, je vois beaucoup de casting, car de nombreux
didacticiels très basiques que vous pouvez trouver en ligne ont tendance à simplement montrer comment convertir d'autres objets, car c'est un moyen rapide et simple d'
obtenir des informations. Dans notre projet, ce que nous faisons est relativement petit et
simple, donc cela n'aurait pas
l'air trop mal. Mais si vous deviez
suivre cette voie, vous pourriez avoir quelque chose qui
finira par ressembler à ceci. Je vais juste faire une
découpe rapide. Découpe rapide. Comme je l'ai dit, c'est essentiellement
ce que vous obtiendrez. La façon dont fonctionne un casting, et je voudrais quand même vous
présenter le casting, la façon dont
fonctionne le casting, c'est que lorsque nous travaillons avec
notre autre acteur, si nous le surlignons
au-dessus de l'épingle ici, nous pouvons réellement voir
ce qui est retourné. Je vais donc appuyer sur compiler. Et je passe curseur sur les informations relatives aux autres
acteurs Cela nous montre
que cela fournit
une référence d'acteur. La raison en est que, si
nous nous souvenons de hiérarchie
de
l'héritage d'UnrelEngin, tout ce avec quoi nous
pouvons interagir dans le monde, qui a
une présence physique ou une transformation, doit
être acteur ou supérieur Donc, en fournissant une épingle ici, qui est l'objet le plus élémentaire que nous puissions trouver dans
le monde, un acteur, nous pouvons nous assurer
de pouvoir comparer tout et ensuite affiner spécifiquement
le type d'acteur, fonctionnalités supplémentaires
et les fonctionnalités qu'il contient. Maintenant, la façon dont vous pourriez le
faire, ou je l'ai souvent vu dans de nombreux
tutoriels, c'est qu' ils vous montreront comment
prendre quelque chose comme l'acteur que vous avez touché
et que nous avons choisi de rejeter. Et de quoi il s'agit, c'est
essentiellement une question. C'est dire que cet acteur générique existe, je peux voir que l'
acteur générique existe. Est-ce spécifiquement le
type de base de pions, qui pour nous est le joueur Si c'est
le cas, donc c'est vrai, oui, c'est une base de poêle, alors
faites ce truc ici. Nous appellerions donc cette fonction
spécifique à la classe de joueur
qui, comme je l'ai mentionné, consiste à infliger des dégâts au joueur
puis à se distraire Si ce n'est pas le cas, donc si
nous avons fait cette vérification
et que le joueur que nous avons touché n'est pas
le joueur que nous avons touché, alors nous avons touché autre chose.
Donc, ce serait au casting f. Et ensuite vous verrez
des gens faire un deuxième casting. Nous nous retrouvons donc comme une
cascade de casting, qui est désordonnée Et si nous nous lançons dans des projets
beaucoup plus importants, vous pouvez constater que nous n'avons que
trois éléments à prendre en compte. Mais si nous avons différentes
choses, comme des camionnettes
et des obstacles, et bien d'autres choses à prendre en compte, nous aurons une cascade en cascade beaucoup
plus grande Mais la prochaine chose que vous pourriez
faire à nouveau, c'est que nous allons revenir ici et
dire que cet objet générique,
cet acteur générique, s'agit-il
spécifiquement d'un ennemi ? Si c'est le cas, nous nous
occuperons des ennemis, mais pour le moment, je n'ai pas encore décidé comment
nous allons gérer les ennemis. Je pense qu'ils vont simplement se succéder
progressivement, mais nous devons remplir cette fonction. Si ce n'est pas le cas, nous vérifierons à nouveau. Ensuite, nous pouvons
passer à quelque chose comme le
volume bloquant Si c'est vrai, alors oui, nous avons heurté un mur et
nous allons changer de direction. C'est donc une façon dont
vous pouvez le voir se faire. C'est peut-être ainsi
que vous envisagez de le
faire si vous savez
ce que fait le casting. Et je voulais juste donner
un aperçu général des raisons lesquelles nous ne le
ferons pas et pourquoi
nous devrions essayer de l'éviter
dans la mesure du possible C'est une autre chose qui
se répète très facilement comme la
déclaration générale selon laquelle il ne faut jamais utiliser de tiques. Vous entendrez des gens dire de
ne jamais utiliser le casting. Encore une fois, c'est
vraiment simplifié. Il y a un tas de raisons pour
lesquelles nous voudrions utiliser casting là où cela peut être totalement sûr et
très bon marché. C'est un peu en dehors
du contexte de ce sujet. Donc, pour le moment, nous allons simplement dire que
je vais les supprimer. Nous ne le ferons pas
uniquement parce que nous ne voulons pas cet effet de
cascade en cascade Où nous vérifions par objet. Donc, pour simplifier les choses, je vais
diviser cela en deux éléments différents pour ce projet que nous voulons à
peu près vérifier. Nous voulons vérifier s'il y a un mur, et nous voulons vérifier s'il
y a un joueur humain. Je pense que, juste pour la conception du jeu
et pour me rassurer, je pense que je vais
laisser les ennemis croiser les uns les autres
afin que le joueur n'ait qu'à réfléchir
à la direction qu' il prend entre l'
impact et les murs. Cela devient donc vraiment très simple pour
eux. Nous pouvons faire une
vérification très simple pour commencer. Nous pouvons cliquer avec
le bouton droit sur le graphique des événements et
rechercher Get player pawn Il s'agit donc d'une fonction intégrée. Le moteur Unreal
suit toujours ce qui est considéré
comme le pion du joueur, c'est-à-dire
ce que le joueur
humain contrôle Donc, lorsque nous appuyons sur
Play, ce serait le vaisseau bleu. Alors,
que pouvons-nous faire ici ? Cela permet d'éviter le casting, ce qui
est une chose utile. Nous n'avons pas besoin de récupérer toutes
les informations
de cette autre classe. Cela signifie également
que si nous avions plus fonctionnalités, comme le fait de laisser le joueur choisir entre cinq
classes de plans différentes avec des navires totalement
uniques, nous n'aurions pas besoin de
comparer chaque navire unique Nous avons juste besoin
de savoir que nous avons touché un vaisseau joueur, et nous le saurons grâce
à cette vérification ici. Nous pouvons donc extraire de cette corbeille, et rechercher deux signes égaux, donc juste deux signes égaux. Et je vais juste
le décrocher pour le rendre un
peu plus lisible Branchez cette sauvegarde.
Nous pouvons simplement dire : est-ce l'acteur à succès ? Donc, la chose avec laquelle nous
venons d'entrer en collision, est-ce que c'est aussi spécifiquement ce que le joueur
contrôle ? Nous pouvons ensuite tirer parti de
notre booléen ici. Nous pouvons rechercher une succursale.
Nous pouvons le connecter notre code d'exécution
et simplifier ainsi le code que
nous devons vérifier. Donc, si c'est le joueur que
nous avons touché, si c'est vrai, alors nous
allons infliger des dégâts. Il se peut donc que nous voulions simplement une chaîne d'impression ici pour nous
rappeler de revenir. Je vais donc ajouter une
chaîne d'impression parce que nous n'avons pas encore de fonctions d'
endommagement ou d'
autres choses de ce genre, mais je vais faire sorte que chaque
fois que cela se produira, cela nous rappelle de
revenir et de modifier le code. C'est donc là que nous
infligons des dégâts au joueur. Et puis la destruction de nous-mêmes est en fait
très simple Il suffit d'appeler la
fonction destroy actor. Nous pouvons le
mettre ici. Et cela fait en fait partie de l'ensemble des
fonctionnalités, déjà fait. Maintenant, si je laissais les avions
ennemis s'envoler, ils seraient prêts
à infliger des dégâts, même si nous n'avons pas encore de santé
et tout le reste de toute façon, puis ils se
détruiront eux-mêmes. Maintenant, en passant à la fausse branche,
encore une fois,
très simple,
qui nous dit maintenant que
si nous voulons
laisser les ennemis se en passant à la fausse branche,
encore une fois,
très simple, qui nous dit maintenant que
si nous voulons croiser les uns les autres, cela ne nous
inquiète pas, ce qui signifie si nous touchons autre chose, que
si nous touchons autre chose, ce sera forcément un mur. C'est la seule
autre chose avec laquelle nous pouvons entrer en collision
dans ce projet Nous pouvons donc le faire à partir de
la fausse branche ici. Et ce que nous voulons
faire, c'est
régler le problème. Je vais donc le brancher sur la broche d'exécution. Déplace ça ici. Et encore une fois, juste pour réfléchir à la façon dont
vous pourriez vous y prendre. Lorsque vous vous habituerez
au flux de code, vous serez peut-être tenté de
lancer un banchon alors je ne fais que saisir
l'épingle d'exécution Cela les
connectera automatiquement, et vous pourriez faire
quelque chose comme ça. Vérifiez donc la valeur de move left. Est-ce que nous nous
déplaçons actuellement vers la gauche ? Si c'est le cas. Donc, si left est vrai, alors
nous voulons que ce soit faux, et si left n'est pas vrai, alors nous voulons que cela soit
inversé et transformé en vrai C'est donc certainement une
façon de le faire. Mais encore une fois, je veux simplement vous comment nous pouvons le faire de
manière agréable et propre. Donc, si nous le rebranchons ici, nous pouvons les déplacer. En fait, je vais
les supprimer
de notre booléen ici,
je vais les extraire,
et je vais rechercher ce que l'on appelle
une boule à nœuds ou un booléen non La façon dont cela
fonctionne est essentiellement la suivante si c'est vrai,
cela renvoie faux. Si c'est faux,
cela renvoie vrai. Nous pouvons donc prendre cette valeur, et elle
inversera essentiellement toujours le
booléen actuel Donc, si nous nous déplaçons vers la gauche, cela nous
fera bouger vers la droite, et si nous nous déplaçons vers la droite,
cela nous fera bouger vers la gauche. donc d'une
version simple et agréable de ce qui aurait
pu être une
structure de branche supplémentaire dont nous n'avions pas besoin. Et
c'est à peu près tout. C'est notre santé qui est prise
en compte lorsque nous abordons ce
sujet un peu plus tard, la destruction au
contact du joueur, puis le changement de
direction lorsque nous heurtons un mur Donc, si nous y retournons, appuyons sur Play, nous pouvons voir qu'ils
rebondissent actuellement les uns sur les autres,
ce qui, je suppose, serait une
parfaite implémentation, à vous de décider Ensuite, s'ils
touchent le lecteur, nous pouvons voir en haut à
gauche la chaîne d'impression
a été appelée et qu'ils sont supprimés. Tout va donc se
résumer à nouveau au design. Si vous voulez qu'ils
rebondissent les uns sur les autres, nous pouvons laisser cette
fonctionnalité Si vous voulez qu'ils se
succèdent progressivement, je vous le montrerai lorsque
nous aborderons les sujets des collisions
un peu plus tard. Mais c'est tout. Nous avons maintenant
une implémentation fonctionnelle. Et comme je l'ai mentionné, la raison pour laquelle
cela fonctionne est chaque fois qu'une collision est détectée dans
cette classe, elle est automatiquement
déclenchée. Il s'agit
de suivre toutes ces informations
sur ce qui a été touché
et ce qui s'est passé, puis nous
extrapolons à partir de ces informations ce
qui est
pertinent uniquement pour notre projet Nous allons faire
quelque chose de très intelligent avec les projectiles, sorte que nous n'aurons pas non plus besoin de tenir compte des projectiles lorsqu'ils
touchent Cela sera traité
dans le code du projectile. Donc, tout ce que l'ennemi doit
connaître , c'est le joueur
et les murs, ce qui est en fait un autre principe de
programmation, très
important,
en particulier dans des langages comme C plus plus, et le plan directeur, car il repose
essentiellement sur le flux de travail du véritable engem Le concept général est
que nous essayons de rendre une classe aussi spécifique
et petite que possible. Il est donc censé faire une
chose et une chose bien. Un exemple de mauvais code
dans une classe ennemie
serait de suivre les pickups que
le joueur a pu détenir, vérifier des éléments tels que le
projectile qui vient de le toucher,
les dégâts que ce projectile devrait infliger, etc., car c' est la logique inverse Toutes les informations relatives
aux dégâts causés par un
projectile doivent être stockées dans le projectile et ces informations doivent
être transmises L'ennemi ne doit prendre en compte et
être responsable que des choses liées à
l'ennemi. Et dans ce cas, il s'agit d'une entité
très simple qui se déplace et heurte des murs. Donc, un autre petit aperçu
de ce qui serait considéré comme codage
propre est
cette
encapsulation qui consiste à s'assurer que votre classe, en général, la règle est, comme je l'ai dit, de faire une
chose et de bien faire une chose que cette configuration
est prête, nous avons maintenant une classe complète
prête à être restructurée Ensuite, nous allons aborder le sujet
de l'héritage. Ce sera une meilleure
façon de gérer une grande partie du code
partagé et des
fonctionnalités que nous observons actuellement chez l'
ennemi et le joueur. Nous avons dupliqué
beaucoup de travail, il est
donc
temps de corriger ce
13. 12 - Héritage BaseClass: Il est temps de réparer le gâchis
que nous avons créé. Nous avons dupliqué la configuration du maillage. Nous gérons
le mouvement différemment, mais nous suivons
deux fois la
même logique structurelle . Cela semble
minime pour le moment. Mais lorsque nous ajouterons de
la santé, de la destruction des effets, tout cela
commencera à s'aggraver. Chaque fonctionnalité partagée représente
deux fois plus de travail pour nous, mais aussi potentiellement
deux fois plus de bogues. Dans la
classe des pions également, nous utilisons actuellement l'
ensemble du maillage comme collider, ce qui n'est vraiment pas idéal
pour ce type de jeu La plupart des
jeux d'action ICD comme celui-ci utilisent en fait une astuce pour que
le joueur se sente un peu plus intelligent
qu'il ne l'est réellement Lorsque vous pensez avoir
esquivé quelque chose habilement,
mais que vous vous êtes
contenté de vous en sortir, cela fait du bien, mais c'est parce que votre
collisionneur est probablement un peu plus
petit Nous allons vouloir
implémenter quelque chose
comme ça pour que notre jeu commence à être vraiment intéressant
à interagir avec lui. n'est qu'une forme mineure de manipulation
psychologique, mais cela donne l'impression que le jeu est juste, même si les calculs
indiquent le contraire. Nous allons résoudre
ce problème en utilisant un
collisionneur de sphères comme nouvelle route
au lieu du maillage Le maillage agira simplement comme décoration
totalement
exempte de collision. Les deux classes en auront besoin.
Nous pouvons donc tout aussi bien le créer
une seule fois et partager des composants et des fonctionnalités de ce
type entre
toutes les classes. ce faire, nous utilisons ce l'
on appelle l'héritage. Je l'ai déjà mentionné,
l'UnrelEngine est un logiciel très fortement
basé sur l'héritage, nous allons
donc suivre le
même type de conventions Cela signifie essentiellement que nous
pouvons coder quelque chose une fois dans ce que l'on appelle une classe
parent ou une classe de base. Nous pouvons ensuite en faire des
classes enfants,
qui hériteront
de tous les composants, fonctionnalités et des
systèmes que nous saisissons Par exemple, nous avons vu les
acteurs fournir une transformation, une
échelle de rotation des emplacements dans le monde, puis des pions prendre ces informations
et
les exploiter en leur
donnant les mécanismes nécessaires pour
les
posséder et bien d'autres choses encore.
Ça suffit de parler. Voyons cela en action.
Passons donc à la création notre nouvelle classe de base qui nous
aidera à voir le
système en pratique. Si nous revenons aux
plans et au dossier principal, nous allons créer
quelque chose de complètement nouveau Un clic droit dans la
fenêtre, nous retournerons au cours
Blueprint et
créerons un tout nouveau pion Je vais passer du nom de Pawn Underscore à BP Underscore Plane Base au lieu Ce seront tous
des avions, alors
autant clarifier notre convention de
dénomination ici. Dans notre nouvelle classe, nous allons
passer aux composants, et nous allons ajouter le composant de
sphère que j'ai mentionné. Nous ne cherchons pas
celui-ci ici. Il s'agit d'une solide sphère visuelle en trois D. Nous voulons juste un lien conflictuel. Si nous recherchons
le mot collision, nous pouvons voir ici que nous avons
plusieurs options différentes. Nous voulons notre collisionneur de sphères, qui s'appliquera ici, et nous pouvons faire la même
chose que nous avons fait auparavant Nous pouvons le faire glisser sur
la racine de scène par défaut pour en faire notre
nouveau composant racine. Nous pouvons ensuite revenir
au bouton Ajouter. Nous voulons toujours notre maillage statique. Cela ne permettra tout simplement
plus
de gérer les collisions . Nous allons refaire la
même chose. Nous allons passer à notre
maillage statique ici et nous allons sélectionner notre héros de l'avion SM
Underscore Le maillage statique
étant toujours sélectionné, nous pouvons accéder à la section de
collision ici, et nous pouvons simplement
utiliser cette liste déroulante et lui demander de ne pas
détecter de collision. Nous pouvons également désactiver la génération d'événements qui
se chevauchent. Cela garantit simplement que
rien n'est vérifié par rapport au
maillage statique à aucun moment. Parfait parce que nous voulons que
cela soit visuel. Cela signifie qu'il n'est pas nécessaire de ajouter à la pile de collision. C'est juste un peu assis
là à être rendu. Si nous sélectionnons également notre collisionneur
de
sphères , nous pouvons apporter
quelques modifications ici Si nous le déposons
à nouveau sur le côté droit dans la section des collisions, nous voulons le remplacer
par superposition ou dynamique, et nous pouvons réellement le rendre
plus distinct que cela, et nous dirons que cela doit être considéré
comme une collision de pions Nous verrons donc que
cela change le préréglage de
collision en pion. Le type d'objet est désormais
suivi comme un pion, et
certaines choses sont effectuées ici n'allons pas en rester là si nous voulions une flexibilité totale. Nous allons
le prendre comme préréglage par défaut, mais nous pouvons le personnaliser
en le déroulant à nouveau et
en sélectionnant Personnaliser. Nous avons donc toujours
cet ensemble comme pion. Nous avons toujours les paramètres
activés pour les collisions comme nous le souhaitons, et tout
cela est défini par défaut. Nous trouverons peut-être que nous voulons y revenir
et faire en sorte que cela ne chevauche pas d'autres pions
ou ne bloque pas d'autres pions, faire quelque chose de différent
avec World Static, et nous avons maintenant la
possibilité de
les modifier si nous le voulions. Nous
ne le ferons pas pour le moment. Nous le ferons en nous basant
sur des tests et observant le déroulement du projet Cela fait, cela
nous place cependant dans une très bonne
position. Chaque classe enfant héritera
désormais de cet ensemble. Cela signifie donc que nous l'avons
configuré une fois et que nous n'avons jamais vraiment besoin d'y penser
à nouveau. Nous pouvons donc maintenant commencer à examiner nos fonctionnalités partagées
également dans la capture d'événements, le genre de choses
que nous voulons partager entre les deux classes. Comme toujours, nous allons saisir l'événement pour commencer à se chevaucher
et supprimer celui-ci. Et en ce qui concerne le mouvement, il
y a quelques points à prendre en compte. Encore une fois, en nous basant uniquement sur la recréation de
l'exemple de projet que
nous essayons d'atteindre un certain niveau de parité, il y a
une petite fonctionnalité si vous
regardez vraiment ce qui se passe lorsque les avions et
le joueur ne bougent pas ou n'alignent pas leurs mouvements au
début de leur apparition Ils jouent une petite
animation. Ils animent l'écran pendant
une ou deux secondes, puis ils laissent le
mouvement se déplacer latéralement Nous allons donc faire
quelque chose de très similaire. Nous allons geler ou suspendre toute saisie de mouvement jusqu'à ce que cette
animation soit déployée. Nous passerons aux animations
dans la section consacrée à la mise en forme,
mais encore une fois, nous devons réfléchir à ce que
nous allons devoir prendre en
compte et nous pouvons les
programmer dès maintenant. Commençons donc par
cela. Nous allons vouloir faire des vérifications très simples et
logiques. Donc, si nous tirons
notre épingle d'exécution, nous allons
rechercher une branche. Et à la succursale, nous pouvons
prendre la maladie ici. Nous allons tout de suite en faire une
variable. Appelez celui-ci B,
mouvement activé. Nous allons appuyer sur Compiler et nous
assurer que la
valeur par défaut est true Donc, si le mouvement est activé, ce
que nous allons
vouloir faire pendant le débogage avant de configurer l'animation, si le mouvement est activé, nous
autoriserons ennemi à voler côte à côte
et à se déplacer vers le bas de l'écran, et nous autoriserons
le joueur à voler
côte à côte en fonction des informations saisies Si ce n'est pas le cas, cela signifie que nous sommes
probablement dans l'animation, et nous appellerons la fausse
fonction ici pour empêcher tout mouvement de se produire.
Donc, cela ne fait que nous préparer. Plus tard, lorsque nous aborderons ces fonctionnalités,
en pensant
à l'avenir,
nous n'aurons pas besoin de
refactoriser complètement
le code à nouveau. Ensuite, les deux classes auront besoin d'un certain type de mouvement. Mais comme je l'ai mentionné,
nous
programmons le mouvement légèrement
différemment. Nous ne pouvons
donc pas partager le code de mouvement
réel, Nous ne pouvons
donc pas partager le code de mouvement
réel car ce n'est pas le même
type de mouvement utilisé. Mais ce que nous pouvons faire, c'est partager
le flux logique et les concepts des
fonctionnalités dont nous aurons besoin. Nous pouvons le faire en
examinant les fonctions dès maintenant. Donc, sur le côté gauche, nous
avons cette
catégorie de fonctions juste ici. Un peu comme les événements,
nous pouvons créer nos propres fonctions personnalisées, puis la logique sera appelée lorsque cette fonction est
appelée de la même manière que nous l'avons fait
avec les événements dans le passé. Donc, si nous appuyons sur Plus ici,
et je vais appeler cette nouvelle fonction, nous avons
créé le mouvement de la poignée. Et vous pouvez voir l'une des
différences ici En fait, l'un des
principaux avantages de l'utilisation de fonctions par rapport aux événements est qu'elles font à
peu près la même chose. Ils répondent à un appel, mais nous obtenons ici notre
propre graphe de fonctions. C'est donc un peu
caché, et encore une fois, garder les choses bien rangées Maintenant, nous n'allons vraiment
gérer aucune des
fonctions de mouvement ici. La façon dont cela sera
utilisé est que nous allons
remplacer cette fonction dans
nos classes pour enfants plus tard, mais nous avons besoin qu'elle existe
pour avoir quelque chose à appeler Ce que nous voulons faire, c'est revenir au graphique
des événements. Nous voulons prendre notre fonction de mouvement du
manche. Et nous allons juste le
mettre sur la vraie épingle. Donc, si un mouvement est activé, nous allons appeler la fonction de mouvement de la
poignée. Encore une fois, cela devient
agréable et lisible. Et lorsque nous arriverons à
réellement le mettre en œuvre, nous pourrons avoir une idée précise de ce qui va se
passer. C'est donc assez
simple pour le moment. Vous verrez cela se dérouler
et prendre beaucoup plus de sens lorsque nous commencerons réellement à
mettre en œuvre les choses C'est l'une de ces choses pour
lesquelles je pourrais essayer de passer cinq à dix minutes à décrire
ce que nous ferons plus tard, mais je pense qu'il serait beaucoup plus logique simplement l'implémenter au fur et à mesure. plus, les
deux classes
ordinaires auront besoin de l'ennemi,
du joueur et des boss
ou quoi que vous
vouliez hériter
de cette classe,
elles devront toutes être
détruites ou tuées
à un moment ou à un autre auront besoin de l'ennemi du joueur et des boss
ou quoi que vous vouliez hériter
de cette classe, elles devront toutes être
détruites ou tuées
à un moment ou à un Donc, pendant que
nous sommes ici, autant
ajouter une autre fonction, et j'appellerai
celle-ci handle death. Encore une fois, nous n'allons
rien ajouter ici pour le moment, mais une chose que nous pouvons
faire avec cette fonction, les éléments génériques, comme est que les éléments génériques, comme
tout,
devront produire
un effet sonore ou un effet de particules
lorsqu'ils mourront. Nous pouvons le faire dans
cette classe ici parce que c'est une fonction
universelle. Quel que soit le type
d'avion, ils doivent tous faire part de leurs commentaires
lorsque cela se produit. Nous pouvons donc utiliser la
fonctionnalité universelle ici. Et puis, s'il y a
quelque chose d'unique à chaque avion, nous pouvons à nouveau annuler les
fonctionnalités présentes ici et faire quelque chose
en plus Donc, juste une
idée approximative du
fonctionnement de l'héritage et de la manière dont nous pouvons
utiliser ce code réutilisable, ce qui nous
permet d'économiser du temps et des
efforts au fur et à mesure. Maintenant, la dernière chose dont
je peux imaginer que les deux classes d' avions auront besoin, c'est la vitesse de déplacement. Et nous le savons déjà en
quelque sorte. Si nous examinons notre propre code, l'une des rares choses
qu'ils
ont tous les deux est d' ouvrir
leurs deux graphes d'événements, de manière
panoramique, ce qui signifie que le joueur dispose de beaucoup plus de fonctionnalités. Il y a beaucoup plus de
variables ici, mais il y a une vitesse de déplacement. Et puis le moule est légèrement
différent, simplifié. Bien que nous n'
effectuons pas la
vérification du déplacement vers la gauche dans la version joueur, nous utilisons toujours la vitesse de
déplacement. est donc ce
que nous
recherchons dans nos classes de base. Les choses que nous avons dû
implémenter plus d'une fois sont quelque chose que nous
pourrions simplement transférer directement dans la classe de base. Donc, ici,
je vais créer une nouvelle variable appelée
vitesse de déplacement unique. Et nous avons changé
celui-ci en un float, it and stack, save. Et chaque fois que nous aurons besoin de les utiliser
entre les cours, ils sont disponibles
et prêts à être utilisés. Encore une fois, nous n'avons pas encore
besoin de l'utiliser,
mais cela ne fait que jeter
les bases d' une transition plus fluide et plus
agréable Et en fait, c'
est notre classe de base étoffée
autant que nous en avons besoin pour le moment Nous pouvons revenir et
ajouter des éléments plus tard, mais nous avons les
éléments communs dont nous avons besoin : une collision unifiée, mouvement prêt à être mis en œuvre dans les différentes classes d'enfants. Idem pour le décès,
puis pour la
variable de vitesse prête à être utilisée également. Donc, pour avoir un
aperçu
rapide façon dont nous pouvons utiliser cette classe
de base, nous ajouterons toutes les fonctionnalités
un peu plus tard, mais ce sera une démonstration très rapide. Si nous revenons à
notre tirage au sort du contenu, nous pouvons cliquer avec le bouton droit de la souris
sur la base simple. Et ici, nous
avons la possibilité de
créer une classe Blueprint pour enfants Si nous cliquons sur celui-ci, cela créera un nouveau
plan pour nous Cela héritera de
tout de Plain Base. Je l'appellerai BP
Underscore Plane Player. Et puis si nous
double-cliquons pour ouvrir celui-ci, nous pouvons voir qu'il est
désormais préconstruit avec notre sphère et
notre maillage statique. Nous avons également quelques autres
choses ici. Si nous cliquons sur l'option override, nous pouvons voir
les fonctions que nous avons créées manuellement, gèrent la mort et
gèrent le mouvement, particulier à partir de
notre classe de base Si nous cliquons dessus,
cela nous donnera une
fonction que nous pourrons ensuite commencer à utiliser la
version parent de la fonction , comme je l'ai mentionné, faire
notre propre travail en
plus de cela. Nous appuyons sur les commandes pour nous en
débarrasser pour neuf. Nous ne voulons pas
remplacer quoi que ce soit pour l'instant, et nous n'avons pas besoin de
changer quoi que ce soit pour l'instant, mais je voulais également
vous montrer une autre façon ajouter des classes en
fonction de celles que nous avons Si vous revenez au
tirage au sort une fois de plus, cliquez avec
le bouton droit de la souris ici, et cette fois, nous allons assister
à un cours de dessin, ce qui n'est peut-être
pas très évident Mais beaucoup de gens pensent
que cela se limite aux classes de moteurs
irréelles et à celles créées par des développeurs
implacables Mais en fait, dès que
nous avons créé une classe, nous pouvons les trouver ici. Donc, si je cherche une base simple, nous pouvons voir ici que la
base est l'enfant d' un pion et qu'un pion, comme je l'ai
dit, est l'enfant d'un acteur Et notre joueur ordinaire joue
sur un enfant à base simple. Nous pouvons donc maintenant sélectionner nos propres classes dans notre
liste de classes ici dans l'éditeur. Nous allons donc sélectionner à
nouveau une base simple. Sélectionnez celui-ci. Et, bien sûr, nous
allons appeler cet avion
BP Underscore un ennemi Les deux sont donc maintenant prêts
à être utilisés alors que nous commençons à
étoffer les choses Je voulais juste
mentionner également qu'il existe plusieurs
façons d'
utiliser vos classes de base une
fois qu' utiliser vos classes de base elles sont
prêtes et configurées. Une fois cela fait, la
classe de base est prête. Comme je l'ai dit, nous avons
les composants partagés, les fonctionnalités partagées et la configuration de collision unifiée. Ensuite, nous allons d'abord
refactoriser le joueur. Nous allons prendre le gros
code, passer revue le gros code que nous
allons parcourir, et nous nous concentrerons ensuite sur
l'ennemi
14. 13 - RefactoringPlayer: Le cours est maintenant prêt.
Nous allons donc devoir convertir notre lecteur
pour pouvoir l'utiliser. C'est ce que l'on appelle le refactoring, qui
consiste essentiellement
à restructurer le code
existant sans changer ce qu'il fait Nous visons
le même comportement mais une meilleure organisation et réduction des frais généraux ou la réutilisation des
variables, des composants et d'autres choses de ce genre dans la mesure du
possible me suis rendu compte que dans le sujet précédent que
nous venons de parcourir, je vous ai donné des instructions pour
créer deux nouvelles classes d'avions. Il y a une autre chose dont je me suis rendu compte entre les deux
qu'il pourrait être
utile
de connaître et qui nous
permettrait en fait de gagner un
peu plus de temps. Donc, ce que je vais
recommander, c'est que nous
supprimions Plain Enemy
et Plain Player. Nous pouvons donc récupérer ces Shift
Select et appuyer sur Supprimer. De toute façon, nous n'avons
rien fait dans ce
domaine, donc nous ne perdons
rien, et au moins vous savez que ces
options sont disponibles. Ce que je suggère plutôt, c'est si nous allons sur notre base aérienne, et je vais simplement les fermer
pour ne pas confondre les choses, nous voulons double-cliquer et ouvrir la classe de base plane sur
laquelle nous avons travaillé pour nous
assurer que vous n'avez pas supprimée la classe de base plane. la base aérienne est toujours là, nous ne voulions pas nous
débarrasser de celle-ci. Ce que nous voulons faire, c'est
utiliser les classes existantes et nous allons simplement
déplacer les choses là où nous en avons besoin. La première chose à faire est donc
de nous concentrer sur notre dénomination. Si nous nous concentrons d'abord sur le
joueur, je vais renommer
celui-ci en BP, en soulignant ordinaire C'est pourquoi nous avons
dû supprimer ces autres classes afin d'
éviter les conflits de noms. Le nom de la classe était correct, mais nous pouvons simplement faire
quelque chose d'
intelligent ici pour utiliser ce que nous
avons déjà dans cette classe. Et nous ferons de
même pour notre ennemi. Nous allons donc prendre celui-ci et l'appeler BP Underscore
Plain Enemy Ensuite, si nous
double-cliquons pour ouvrir le lecteur BP Underscore Plane, nous pouvons commencer à apporter
nos modifications ici Donc, ce que j'ai pensé qu'il
serait utile de
savoir , c'est qu'
il existe en fait
un moyen vraiment cool changer ce que cette classe
considère comme son parent Donc, pour le moment, nous pouvons voir
la classe mère comme un pion. Si nous revenons ici
aux paramètres de la classe ,
puis que nous revenons dans
le panneau des détails, nous pouvons voir que nous avons la classe
parent ici. La liste déroulante est configurée pour mettre en gage. Si nous recherchons un avion,
nous pouvons le modifier pour qu'il hérite
désormais de la base plane de
soulignement de BP Et c'est en fait une
bonne façon de refactoriser les choses. L'une des raisons est que cela nous
donnera des erreurs
et des avertissements concernant le code
susceptible d'être dupliqué. Et on le voit
déjà, en quelque sorte. Donc, si nous regardons
sur le côté gauche, nous pouvons voir que nous avons
deux maillages statiques. dans un projet C plus, tout ce qui indique Modifier dans
Blueprint ou Modifier Si vous travaillez dans un projet C plus, tout ce qui indique Modifier
dans
Blueprint ou Modifier dans
C plus indique que cela est hérité
d'une classe de base Donc, quand vous voyez cela,
nous ne pouvons pas entrer. Nous ne pouvons pas récupérer ceux hérités
et les supprimer,
ils sont donc bloqués ici. Donc, ce que nous voulons
faire, c'est
saisir le zéro de notre
maillage statique Nous n'avons pas besoin de deux
maillages différents pour notre avion, et nous pouvons supprimer celui-ci Nous allons
donc simplement le supprimer ici L'autre chose que nous pouvons voir ici, c'est que nous avons ce que l'on appelle la vitesse de
déplacement qui souligne
zéro dans les variables Si nous écrivons, cliquez dessus, nous pouvons accéder à la recherche de références, et nous pouvons trouver tous les membres
actuels de la classe. Si nous double-cliquons sur
celui-ci, cela nous
amènera directement
à l'endroit où il se trouve. Donc, comme je l'ai mentionné,
c'est un moyen rapide efficace de mettre de l'ordre dans
les choses, car nous pouvons simplement utiliser ces raccourcis
pour nous déplacer et trouver les éléments restants dont nous pourrions avoir besoin
pour nous débarrasser Encore une fois, la raison pour laquelle
un trait de soulignement zéro est
que nous savons que la classe de base contient
ce un trait de soulignement zéro est
que nous savons que on appelle
la vitesse de
déplacement qu'on appelle
la vitesse de
déplacement et que nous ne pouvons pas
avoir la même variable, même si elle se trouve dans une
version enfant de cette classe Nous allons donc
refaire la même chose. Nous allons supprimer celui-ci. Nous allons simplement supprimer la vitesse de
déplacement. Cela nous indique simplement que
nous l'utilisons actuellement, mais c'est parfaitement bien
parce que nous savons où il se trouve. Ensuite, ce que nous voulons
faire ici, c'est partir de là et
rechercher la vitesse de déplacement. Et nous pouvons voir ici que
nous voulons obtenir la variable de vitesse de déplacement, et c'est celle de notre classe de
base, la classe d'appariement Et nous y voilà.
C'est donc à peu près tout. C'est un cours en quelque sorte
réparé et prêt à être suivi. Nous pouvons donc certainement
en rester là, mais il y a quelques autres
éléments que nous pouvons
utiliser dans la classe parent. Donc, la première chose que
nous voulons toujours prendre compte, c'est
au début de la
partie, et nous devons essentiellement nous concentrer sur toutes
nos fonctions. Mais pour commencer à jouer, nous allons
cliquer avec le bouton droit sur le nœud, et nous voulons trouver
cette option ici pour ajouter un appel à la fonction parent. Et nous voulons
faire le lien entre notre exécution actuelle et les fonctionnalités que
nous appelons déjà. Cela garantit simplement que
les parents commencent à jouer. La logique est également appelée
lorsque nous commençons à jouer, ce qui signifie que si
nous avions à nouveau une logique
universelle à appliquer à
la classe parent, sera également appelée. Sinon, cela ne
sera appelé que par lui-même, et nous ignorerons la version
parent. Nous voulons faire de même
pour l'événement. Nous allons écrire, cliquer
dessus, ajouter un appel à la fonction
parent, puis
simplement tout connecter. En incluant les secondes Delta, nous devrons peut-être déplacer
certaines choses ici. Ensuite, nous pouvons simplement le
brancher ici. Et encore une fois,
rangez les choses si vous le souhaitez. Essayez de vous aider à visualiser
cela, la fonctionnalité parent
sera appelée en premier. Ainsi, par exemple, lorsque notre
joueur sera créé pour la première fois, son événement de
début de partie sera automatiquement appelé une fois, puis nous
enverrons immédiatement un message pour
examiner la version parent et voir si quelque chose se passe
lors de ce début de partie. Naviguez ici. Nous pouvons ouvrir le plan parent
avec ce raccourci ici, et nous pouvons passer au
début du jeu ici, et nous pouvons voir qu'il n'y a pas de code
réel pour le moment si nous devions faire
quelque chose comme retirer Mais si nous devions faire
quelque chose comme retirer
un fil d'impression
d'ici, nous dirions simplement aux parents commencer et de le garder à
l'écran pendant un moment. Ce qui se passerait maintenant,
c'est lorsque nous appuyons sur Play. Nous allons voir que le nom
du parent est imprimé en haut. Nous pouvons donc confirmer que
notre logique mère, la logique universelle, est
en fait appelée. Maintenant, le problème, bien
sûr, c'est si nous l'ajoutons aux ennemis, donc si nous passons à la classe des ennemis
ordinaires, nous entrons dans la partie de début de partie. Nous allons vouloir
faire la même chose. Nous allons cliquer avec le bouton droit de la souris, ajouter un appel parental, et
nous le connecterons ici. Maintenant que nous avons trois
ennemis et un joueur, nous allons voir ce
message quatre fois parce qu'ils appellent
tous la même fonction. Bien entendu, nous devons
apporter la même modification paramètres
de
classe des classes ennemies. Passez d'un
pion à une base simple. OK. Nous faisons donc la
même chose. Nous ne faisons que retranscrire ce dont cette
classe hérite Appuyez sur compiler. Ils suivent donc tous les quatre
le même processus. Maintenant, c'est bien, dans ce cas, mais c'est là que vous devez être prudent et commencer
à assurer que vous
réfléchissez à ce que
vous mettez en œuvre. Cela n'aurait donc aucun sens si ce message
disait quelque chose comme si c'était spécifique à ce que
le joueur doit faire, comme crier, je suis le joueur Si nous appuyons sur compiler, cela
signifie le joueur d'avion, nous l'appellerons, ce qui
est parfaitement bien. Mais il en va de même pour tous les ennemis. Les trois ennemis disent donc également : « Je suis le joueur », ce qui est
un peu confus. C'est donc là que vous devez
faire attention à l'héritage. C'est pourquoi je n'arrête
pas de dire que nous voulons appliquer notre
logique universelle ici. Tout ce qui est
simplement lié au fait d'être un avion général
est parfaitement acceptable. Donc, si c'était le cas, chaque avion
devait simplement
s'annoncer et simplement dire « je suis un avion », ce
serait parfaitement bien car ce sont tous
les quatre en effet des avions. Comme nous pouvons le constater, nous ne
voudrions pas de code spécifique
au joueur dans classe
de base la classe
de base. J'espère donc que cela a du sens et que nous pourrons
commencer à voir comment utiliser l'héritage et comment partager nos fonctionnalités, composants et notre logique
entre plusieurs classes. Et c'est ainsi que nous allons gérer des choses
comme la destruction. Nous pouvons faire en sorte que les effets de
particules les effets sonores soient tous joués dans la classe mère,
car cela n'est pas spécifique à un plan en particulier. Ils ont tous besoin d'être
détruits d'une manière ou d'une autre. Mais pour ce qui est des choses comme le mouvement
, nous allons plutôt le gérer dans
les classes pour enfants. Revenez au jeu normal. Nous allons d'abord terminer
celui-ci. Un moyen très rapide
de récupérer le code, dont nous savons qu'il fonctionne
déjà. Comme je l'ai mentionné, tout ce que
nous voulons vraiment faire c'est nous assurer que cela ne
se répand pas
et que nous pouvons utiliser cette fonction que
nous avons créée il y a peu de temps Donc, si nous saisissons tout ce qui
concerne le mouvement, donc ce seront ces
nœuds ici, le calcul ici, me suffit de maintenir la touche Shift enfoncée et faire glisser le pointeur, puis la position de l'
acteur ici Ceci n'est lié qu'
à la rotation, nous allons
donc laisser
celui-ci pour le moment. Ce que nous voulons faire, c'est
appuyer sur
Ctrl et X pour couper, et nous allons cliquer ici pour annuler la fonction de
mouvement de la poignée Nous voulons donc la fonction que nous avons créée plus tôt, cet espace vide. Ensuite, nous allons
appuyer sur la commande V ici et nous allons tout
rebrancher. Nous pouvons donc nous assurer que notre fonction de
mouvement sera toujours appelée parce que
nous appelons notre Eventic Et si le mouvement est
activé, le
mouvement de la poignée sera également
appelé à partir de cet événement. Encore une fois, nous n'avons besoin d'
appeler cette fonction qu'une seule fois ici, et nous pouvons utiliser cet
appel
de fonction dans nos classes enfants. Nous l'avons déplacé, et je
vais juste revenir sur
le graphique des événements. Nous allons déplacer cela pour le moment, la rotation, et nous allons le
raccorder. Et il suffit de tester
au fur et à mesure, comme je l'ai mentionné, pour
vous montrer comment vous pouvez refactoriser le code
vous-même si nécessaire Et il s'agit d'un processus très
courant. Nous voulons simplement tester ces
petites étapes au fur et à mesure, et
le mouvement devrait toujours être activé. Donc, si quelque chose est cassé,
laissez-moi vérifier
ce que cela pourrait être. Si le mouvement est activé, si c'est vrai, nous appelons notre événement. Nous avons
ici le mouvement de notre poignée, la vitesse de déplacement. Je viens donc de me rendre compte que nous avons notre nouvelle
variable de vitesse de déplacement dans la classe de base, mais nous ne
lui avons pas donné de valeur. Donc, si nous récupérons nos
paramètres de classe juste ici, cela nous donnera accès aux
paramètres de classe lorsque nous
sélectionnerons cet élément le plus haut
ici ou la classe par défaut Nous pouvons voir que les valeurs par défaut
des classes contiennent les variables ici, et nous pouvons voir notre vitesse de
déplacement, et je crois que je
fixais cette valeur à
1 000 pour le joueur.
Nous allons donc remettre cela en arrière. Ensuite, nous
devrions pouvoir
appuyer sur Play et nous déplacer. Nous obtenons donc le même mouvement,
la même rotation. Tout se sent pareil. Nous n'avons pas modifié
les fonctionnalités. Nous venons de mettre de l'ordre dans
notre graphique et de redéfinir la façon dont
les choses sont gérées Nous veillons donc à ce que cela
soit appelé si et quand nous le
voulons et un autre avantage
vraiment intéressant de ce moment est que nous pouvons entrer. Nous pourrions désactiver les
mouvements activés, sorte que les mouvements ne soient
plus activés. Nous pouvons appuyer sur Play, et maintenant
nous ne pouvons plus déplacer l'avion. Mais bien sûr, cela interrompt
la rotation parce que nous multiplions
maintenant par une valeur qui ne fait rien vraiment Mais vous pouvez voir que la
logique est que nous
gérons les choses comme
nous voulons que cela fonctionne. Et tout cela est désormais
géré dans
la classe de base en ce qui concerne les états d'activation
et de désactivation des mouvements, et nous en tirons simplement parti
dans la version joueur
de cette classe. Assurez-vous donc que nous cliquons dessus. Nous allons nous assurer que le mouvement est activé
pour le moment. Nous passerons cela
dans le code un peu plus tard lorsque nous
arriverons à l'animation N'oubliez pas que j'ai dit que nous n'ajouterons pas d'éléments tels la rotation, la fausse
physique ou d'autres éléments
relatifs à la classe ennemie C'est
pourquoi nous ne
réutiliserons pas exactement le code de mouvement Une autre chose que les
ennemis n'auront pas, c'est la véritable logique de rotation que nous
avons ici pour cette raison. Quelque chose que nous pourrions
faire, cependant, pour conserver les mêmes conventions de dénomination et
le style général. Il y a un autre conseil
que je voulais vous montrer. Nous pouvons récupérer tous
ces nœuds en appuyant sur Shift Select
pour récupérer ces nœuds. Ensuite, si nous cliquons avec le bouton droit sur l'un
des nœuds que
nous avons sélectionnés ici, nous pouvons choisir de le réduire
à une fonction à part entière. Et nous allons juste
appeler celui-ci. Vous pouvez probablement le deviner. Nous allons appeler cela la rotation
d'une poignée. Sympa et évident. Si nous devions étudier cette question
et commencer à lire notre code, nous viendrons du
festival des bases aériennes, et nous pouvons constater que si
l'événement se déroule, si le mouvement est activé, si le mouvement est activé, si nous gérons le mouvement,
cela sortira de la classe de base. Donc, une fois cela fait,
nous retournerons dans notre classe pour enfants. Cela est donc maintenant
réglé. Le code d'exécution sera appelé, puis
nous commencerons à l'appeler. Nous gérons donc le mouvement
si le mouvement est activé, puis nous
gérons la rotation, encore une fois, si le mouvement est activé. Exactement les mêmes résultats si nous appuyons sur Play,
rien ne change. Nous le rendons juste beaucoup plus lisible et maintenable Nous sommes en train de nous débarrasser de
ce code spaghetti ou même
de la possibilité que cela se produise ici parce que nous avons le contrôle total de
notre base de code et de la façon dont
nous voulions qu'il fonctionne Nous utilisons l'héritage,
ce qui nous permet de gagner beaucoup de temps lors de l'
ajout de nouvelles fonctionnalités. Pour le moment, cela peut
sembler être un travail chargé, mais cela vous permettrait
certainement de gagner
beaucoup de temps à long terme, comprenant ce que cela
fait et comment l'utiliser. Une fois que nous serons là, si vous êtes
à l'intérieur de la base aérienne, si vous
suivez exactement, nous pourrons nous débarrasser de ce message décrivant
la classe Nous allons juste nous débarrasser de
celui-ci. Il se compile en. L'ennemi partira pour le moment
et vérifiera simplement que tout est enregistré
dans la classe de joueur, et que le
joueur a été refactorisé Vous pouvez donc voir que ce n'était pas
vraiment douloureux. J'ai pris un peu plus de temps
simplement parce que je
voulais expliquer ces concepts et les
clarifier au fur et à mesure. Si je l'avais
fait moi-même, cela aurait
probablement pris une minute. Donc, même refactoriser et reconsidérer
complètement
la façon dont la structure des classes gérée ne prend pas
beaucoup de temps, surtout si vous réfléchissez
au début du développement C'est
pourquoi j'essaie de le
souligner au fur et à Essayez de faire ces
choix dès le départ, et cela fait la
différence entre un refactoring d' une minute et un
refactoriseur d'une heure Si vous testez votre code et quelque chose ne fonctionne pas
ou que quelque chose ne fonctionne pas, vérifiez
simplement que tous les appels de vos parents sont connectés. Donc, ces parents appellent ici, les nœuds oranges sont
connectés et sont appelés au début du jeu,
au tic-tac de l'événement, etc. De même, assurez-vous que
le mouvement activé est coché à
la fois dans la classe de base ici
et, plus important encore, grâce à cette valeur ici,
comme je viens de le montrer, juste quelques
pièges, dans lesquels je
peux imaginer que certaines personnes
pourraient tomber Il suffit donc de vérifier les éléments que nous
avons modifiés. Pour le sujet suivant, bien sûr, nous allons
aborder le même sujet, mais pour l'ennemi
, cela devrait prendre un peu moins de temps.
Nous avons maintenant vu comment procéder ici.
15. 14 - Refactoriser l'ennemi: Refactoriser l'ennemi. Nous l'avons
déjà fait une fois. Ça devrait aller un peu plus vite. Évidemment, si vous ne l'avez pas
déjà ouverte, nous allons nous assurer d'
ouvrir la classe ennemie ordinaire. Vérifiez ici, si vous n'avez pas
déjà apporté la modification, que cela réinitialise la classe parent ici
pour que BP souligne la base plane N'oubliez pas
que nous pouvons le faire via les
paramètres de classe et le
menu déroulant juste ici. Encore une fois, les mêmes choses
qu'avec le joueur. Nous allons supprimer
le maillage statique, ce qui nous posera un
petit problème ici. Nous allons simplement dire « C'est
bon », alors nous allons cliquer sur « Oui ». Cela m'a amené directement au problème,
à que nous avons lié la fonction de
frappe du composant précédente,
cette vérification de collision, au maillage statique d'origine. Ce n'est en fait pas un problème car nous voulions
régler ce problème de toute façon. Nous ne voulons pas utiliser le
maillage comme collisionneur mais nous allons prendre
le composant sphérique ici, donc nous allons prendre celui-ci, et nous voulons refaire la
même chose Donc, dans le côté
droit du panneau des détails, il
suffit de le supprimer. Nous allons trouver la fonction
on component hip et créer une liaison avec celle-ci. Et c'est tout ce que cela fait. C'est juste contraignant
chaque fois qu'une action se produit, cela lie cette fonction
pour qu'elle soit ensuite appelée. Nous pouvons donc supprimer celui-ci,
connecter les mêmes éléments, donc épingle d'exécution et épingle acteur, et c'est la première partie
de ce problème résolue. Ensuite, je vais simplement passer rapidement
dans la fenêtre d'affichage. Nous allons récupérer
le maillage statique, et nous voulons nous assurer que nous mettons à jour le matériel. Encore une fois, dans l'élément zéro ici, c'est celui qui contrôle
le corps de l'avion. Nous allons le supprimer,
et nous pouvons maintenant trouver l'autre matériel que vous avez
peut-être créé pour votre ennemi,
qui pour moi n'est qu'un ennemi de l'avion MI
Underscore Choisissez celui-ci, et nous serons pratiquement revenus là où nous étions. Il en va de même pour la vitesse de
déplacement. Nous voulons
cliquer dessus avec le bouton droit de la souris, trouver les références
du membre de la classe juste pour nous assurer de nous
débarrasser de toutes ces références. Nous pouvons double-cliquer sur l'un d' entre eux et voir où
ils sont utilisés. Nous pouvons constater que nous en avons
quelques-uns pour nous assurer de n' en manquer aucun lorsque nous essayons de reconnecter
les choses. Je vais simplement
cliquer avec le bouton droit sur le
graphique des événements ici,
rechercher la vitesse de déplacement, et nous allons obtenir la variable de vitesse de
déplacement ici, celle qui a été créée
dans notre classe mère. Accrochez-le ici,
dupliquez-le, accrochez-le ici, supprimez-les juste pour ranger un peu les
choses, et double-cliquez sur le
dernier, qui se trouve ici Et encore une fois, nous
allons simplement cliquer avec le bouton droit de la souris et rechercher la vitesse de déplacement. Nous allons régler
la vitesse de déplacement ici, puis
nous allons l'intégrer. Débarrasse-toi de ça, et
nous serons de retour là où nous sommes. Maintenant, il y a une option, que je ne
voulais pas mentionner parce que je la
trouvais un
peu compliquée. En fait, dans la version actuelle, cela ne semble tout simplement pas fonctionner. Mais ce qui
pourrait être utile s'ils corrigent ce problème à l'avenir, c'est que dans le passé,
nous avons pu cliquer avec le bouton droit sur la variable. Nous pouvons sélectionner cette option pour
remplacer les références. Ce qui me manque pour le
moment, c'est
que je ne sais pas où sont passées ces fonctionnalités. Vous pouvez normalement le supprimer, et nous aurions pu trouver la variable de vitesse de
déplacement créée dans la classe parent. Pour une raison ou une autre,
je ne peux accéder aux variables qu'à partir de l'acteur
et du pion directement, non à la base de réclamations BP
Underscore, même si je devrais être en mesure Mais juste pour dire que
pour ces raisons, peut que
nous ayons juste besoin de
passer en revue et de
le faire d'une manière légèrement plus manuelle que nous les avons
supprimées N'oubliez pas de vous débarrasser du point de
soulignement zéro de la vitesse de déplacement Nous ne devrions plus
l'utiliser du tout, puis appuyer sur compiler pour assurer que
tout est terminé. Pareil pour le joueur. Maintenant
que nous les avons mises en place dans la classe ennemie, nous voulions
simplement vérifier. J'ai déjà emprunté
cette voie pendant que nous
travaillions sur le contenu pour les joueurs. Si vous décidiez de ne pas passer
dans la classe ennemie je me concentre uniquement sur la classe des joueurs
ordinaires. Ensuite, il suffit de vérifier que
vous avez également le début du jeu, appel
parent et l'
eventI override de l'appel parent Nous allons donc cliquer sur
R ici. Nous allons faire l'
appel d'ajout à la fonction parent, et encore une fois, nous
assurer que nous les
connectons au fur et à mesure Pour ce qui est de la logique du mouvement, nous allons refaire la
même chose. Nous voulons donc que la même logique de
mouvement se produise. Nous pouvons récupérer tout cela. Rien ne
va vraiment changer. Nous pouvons les récupérer, il suffit donc de sélectionner
Shift pour les récupérer. Nous voulons appuyer sur la touche Ctrl en X pour couper tous les
nœuds d'ici. Nous allons passer
à la dérogation, et
nous allons annuler la fonction de
mouvement de la poignée Après avoir fait tout ce
qui pourrait
être nécessaire dans la fonction parent, nous allons
les coller ici, puis assurer que notre
mouvement est appelé. Cela fait, cela m'a
simplement rappelé que nous pourrions également améliorer
autre chose ici. Nous voulons donc nous assurer qu' en raison du chevauchement
que nous
faisions, nous appelions simplement destroy actor et
laissions un message ici. Nous pouvons introduire notre fonction
handle death, déposer ici et la remplacer par la fonction de destruction. Nous allons donc nous débarrasser de Destroy.
Nous avons tout ce qu'il faut. Ce que nous voudrions peut-être faire,
c'est venir ici. Nous nous laisserons un
commentaire. C'est donc pris. Si nous double-cliquons dessus, nous
arriverons à la base
de l'avion. Nous sommes donc maintenant dans
la classe des parents. Nous pouvons tirer parti de là, et ce que nous voudrons
toujours
faire à la fin s'appelle
l'acteur destructeur. Une chose que nous voudrions peut-être
faire , une autre utilisation des commentaires, je peux
faciliter le suivi des choses. Donc, si nous appuyons sur C pour
placer un commentaire ici, j'aime
me laisser le temps de
faire des notes postiques, presque Nous pouvons dire quelque chose comme
implémenter l'effet avant le décès. Alors, que se passera-t-il
avant que nous ne
détruisions notre acteur ? C'est ce que nous allons
faire juste ici. Cela
facilite vraiment les choses, car vous pouvez appuyer sur la touche Ctrl en F dans n'importe quelle classe et vous pouvez
rechercher Do. Double-cliquez dessus. Et où que vous soyez
dans votre classe, s'il vous reste un tas de commentaires
à faire, vous pouvez rapidement
y accéder et voir sur quoi
vous pouvez travailler. Nous pouvons également venir
sur le côté droit. Nous pouvons lui donner
une couleur différente juste pour le faire
ressortir un peu. C'est à vous de décider comment
vous vouliez gérer cela. Mais comme je l'ai mentionné, c'est
une bonne façon pour moi de trouver rapidement les fonctionnalités qui ne sont peut-être pas encore complètement
prêtes à être mises en œuvre car nous ne touchons pas à
ces parties du système, mais je sais que je
devrai
revenir ici et le faire
à un moment donné. Donc, lorsque nous reviendrons pour le
mettre à jour plus tard, et encore une fois, c'est ainsi que vous devriez vraiment concentrer sur votre flux de travail. Cela n'a vraiment
rien fait pour nous en ce moment. Cela signifie que
lorsque nous reviendrons pour ajouter des effets ou d'
autres choses de ce genre plus tard, nous n'avons pas besoin de revenir
et de modifier notre code ennemi. C'est maintenant prêt à être utilisé. Nous pouvons continuer à développer tout
au long du projet, et cela sera
automatiquement pris en compte lorsque nous aurons
mis à jour les fonctionnalités ici. Le reste de la collision
est toujours le même. C'est toujours à peu près ce que nous
devons faire ici. Vous pouvez le remplacer par
un commentaire, autre pour faire un commentaire si
vous le souhaitez, mais encore une fois, nous n'avons pas encore abordé
le système de santé Nous avons
donc besoin de quelque chose
pour nous rappeler revenir ici, et cette chaîne
d'impression est bonne. Nous voulons juste vérifier
que tout cela fonctionne Nous allons
donc revenir en mode
jeu, pour nous assurer que les ennemis et le joueur
sont toujours en mouvement. C'est prévu, et
tout cela est très bien. Ils
rebondissent toujours sur les murs. Ils continuent à prendre
leur direction et leur vitesse
aléatoires, vitesse
aléatoires rebondir les uns sur les autres, et nous pouvons à nouveau
revenir et changer cela en fonction de la façon dont nous pensons que
le jeu devrait se dérouler Mais je pense
qu'une fois cela fait, nous
avons maintenant atteint la parité de comportement. Tout fonctionne
comme avant, mais en utilisant
un héritage approprié. Ce n'est qu'un bref résumé maintenant que nous avons terminé notre refactorisation, passant à
l'utilisation de l'héritage, découvrez ce que cela nous
a apporté L'essentiel sera que nous ayons une configuration de collision partagée. Nous ne pouvons configurer
cette sphère qu'une seule fois, et elle fonctionnera dans les
deux classes
qui l'utilisent. Nous avons la gestion partagée des
décès. Encore une fois, lorsque nous
ajouterons des éléments tels que des explosifs ou des
sons, les deux classes
pourront les utiliser. Nous pouvons annuler l'
effet si nécessaire, mais nous n'avons pas besoin
de modifier notre code de base
pour le moment Nous avons une logique de
mouvement partagée.
Ainsi, lorsque nous
ajouterons des animations, les mouvements activés
seront valables
pour les cinématiques, tant pour
le joueur
que pour l'ennemi Nous avons des variables communes
comme la vitesse de déplacement. Il existe une fois que nous
n'en avons pas de doublons ou
de versions multiples d'une classe à l'autre. Je vais peut-être exagérer pour le
moment pour ces deux classes
différentes,
mais nous sommes sur le point d'ajouter des
éléments tels que des points de vie, des
projectiles, des
effets de spornos Nous disposerons désormais d'un
pool de fonctionnalités partagé à partir duquel les éléments sont pertinents
pour utiliser le même élément
plutôt que de le dupliquer Une chose qui
vient à l'esprit, c'est que nous pourrions effectuer ces mises à jour de
Sphere dès maintenant. Comme je l'ai mentionné, l'approche
générale que les gens adoptent avec ce type
de jeu concerne le joueur. Nous voulons que la sphère soit peut-être un peu plus petite que
ce à quoi vous vous attendiez. Donc c'est
peut-être bien. Nous pourrions potentiellement augmenter légèrement le rayon de la
sphère. Nous pouvons voir pour le moment qu'il se trouve
réellement à l'intérieur du corps. Il est si petit que nous ne
pourrions pas le voir. projectile va donc
voler complètement sur toute l'
envergure des ailes
et sur la majeure partie du corps Comme je l'ai mentionné,
c'est juste pour donner au joueur l'impression
d'être un peu meilleur
qu'il ne le est. S'ils pensent dans
leurs yeux qu' une balle les a presque manqués, mais qu'en fait, elle les a touchés. Ils vont avoir l'
impression de l'avoir esquivé. Et ce que nous ne voulons pas, c'est
que cela se passe dans l'autre sens, où ils pensent qu'ils auraient
dû esquiver quelque chose, même s'ils ne l'
auraient clairement pas fait, et qu'ils se sentent trompés en subissant ces dégâts supplémentaires dans leur esprit Cependant, une fois la sphère
sélectionnée, nous voulons trouver le rayon de la
sphère ici, et nous pouvons le régler
à quelque chose comme 50, et vous verrez où
cela entre en jeu. Maintenant, c'est dans cette zone que le joueur
subirait des dégâts. Alors peut-être
que je vais juste le réduire un peu, pour qu'il ne s'agisse que du corps
, environ 45, et je pense que c'est probablement la marge de manœuvre
que nous voulons leur donner. Si nous appuyons sur Compiler puis que nous
revenons à la
classe ennemie, pareil. Nous allons entrer dans le
belvédère, saisir la sphère, mais je pense que cette fois, je pourrais faire en sorte
que ce soit
64 ou le double Et en fait, c'est peut-être même un
peu trop petit,
alors faisons-en quelque chose comme 70. Encore une fois, vous
aurez juste
l'impression
que le joueur aura l'impression de
tirer bien
mieux qu'à chaque fois
qu'il vous
aurez juste
l'impression
que le joueur aura tirer bien tire, touche l'ennemi exactement comme il l'avait prévu, où, en fait, le corps lui manquera, mais nous allons le
récupérer pour lui et lui donner impression de le faire Ils sont meilleurs au jeu
qu'ils ne le sont peut-être. De toute évidence, nous voulons
trouver un équilibre entre les deux. Nous ne voulons pas
rendre les choses trop faciles, mais vous pouvez voir qu'il est agréable et facile de modifier ces
choses de toute façon C'est ainsi que l'héritage est configuré. Les deux classes fonctionnent, héritent
toutes deux de
la base plane Ensuite, nous pouvons passer à l'
ajout de la santé et des dégâts. Et c'est là que
vous commencerez vraiment à constater les avantages de prendre ce temps avant
la mise en œuvre pour
configurer l'héritage.
16. 15 - HealthSystem: Il est temps d'ajouter de la santé et des dégâts. Notre classe de base est déjà configurée pour partager les données
importantes Passons
donc directement à la base plane de
BP Underscore Ici, nous allons avoir besoin de
deux variables différentes. Nous voulons suivre
notre état de santé actuel, notre état de santé
actuel et notre état de santé maximal. Nous pouvons le faire à
l'aide de flotteurs Je vais
donc prendre la
vitesse de déplacement, appuyer sur la touche Ctrl, en fait, la dupliquer une fois et l'appeler santé
actuelle Dupliquez-le une deuxième fois, et nous l'appellerons Max Health. Si nous appuyons sur Compiler, je vais
obtenir le maximum de points de vie, et je le réglerai sur
une valeur par défaut de 100. Nous pouvons laisser l'état
de santé actuel vide. Et ce que nous faisons, au début de la partie,
c'
est placer notre santé actuelle sur
l'épingle d'exécution juste ici, et nous voulons prendre notre santé
actuelle et la
définir comme notre
santé maximale. Aucune erreur humaine. Chaque fois que nous commençons à
jouer, nous veillons toujours à ce que nous
commencions en pleine santé. C'est donc un moyen
simple et agréable de s'assurer ne rien faire de mal
à notre système de santé. Encore une fois, juste un rappel. C'est pourquoi c'est
vraiment important. Lorsque nous appuyons sur compiler et enregistrer, revenez dans le joueur normal et
vérifiez simplement que vous avez
le code de remplacement pour
commencer à jouer, et il en va de
même pour l'ennemi C'est donc là que cela
devient important, car nous voulons nous assurer
que ces deux classes initialisent leur santé
au niveau de leur
santé maximale Une fois cela confirmé,
nous pouvons également implémenter notre système de gestion des dommages.
C'est vraiment simple. RL Engine dispose d'un
système de messagerie
intégré spécialement conçu
pour gérer les dommages. Si nous cliquons sur
le graphique des événements, nous devons rechercher un
événement appelé dommage quelconque. C'est donc celui-ci,
l'événement, les dégâts éventuels. Et cela sera appelé
chaque fois que nous enverrons un message d'un autre acteur, qu'
il s'agisse d'un projectile, d'un explosif impactant l'
avion ou la classe ennemie, nous pouvons envoyer un message disant : «
Hé, tu as été Lorsque ce message est envoyé
et qu'il est reçu ici, cet événement ou cet
appel de fonction sera effectué. Et lorsque cela se produit,
tout ce que nous voulons
faire , c'est définir
notre état de santé actuel, donc nous allons le faire
glisser vers le pentagone d'exécution. Nous allons en faire
notre enfer actuel Nous allons
donc prendre la
santé actuelle une deuxième fois, faisant glisser avec le
contrôle sur le
graphique pour lire la valeur, et cela aura un
effet négatif sur nos dégâts. Donc, l'enfer actuel
moins une valeur ici, qui correspondra aux dégâts
que nous infligons, donc ce sera quelque chose que nous placerons dans l'appel
de l'autre classe. Le résultat de ce calcul
sera notre valeur sanitaire. Une chose qui est normalement recommandée pour ce
type de calcul est d'éviter que les choses ne deviennent un peu compliquées ou bizarres Nous ne voulons pas autoriser les dégâts ou, si nous avons également mis en œuvre des
soins, nous ne voulons pas permettre à
ces valeurs dépasser notre seuil maximum ou
minimum. Nous pouvons donc utiliser ce
qu'on appelle une pince. Nous allons tirer de cette épingle ici
et chercher une pince. Nous voulons l'option Clip Float, qui se trouve juste un
peu plus haut. Alors, fixez le flotteur. Et nous allons insérer
le résultat de ce serrage dans notre goupille juste ici Nous pouvons donc voir ce que
cela nous permet de faire. Nous pouvons prendre notre valeur minimale. Donc, le minimum de
santé que nous devrions atteindre devrait être nul. Et le maximum de
santé que nous pouvons avoir
sera notre valeur de santé maximale.
C'est si beau et si simple. Cela signifie simplement que si nous ajoutons
quelque chose comme des kits de
santé, lorsque vous en prenez un, vous ne pouvez pas
dépasser le maximum de santé avec
lequel vous avez commencé. Il
gardera donc toujours les résultats de ce calcul
dans cette fourchette. Une fois que nous aurons confirmé que le
réglage de l'état de santé est correctement effectué et que
nous n'aurons aucune erreur, nous vérifierons si les dégâts que nous venons de subir
sont suffisants pour nous détruire. Nous allons donc utiliser notre épingle
d'exécution juste ici. Nous allons
chercher une succursale. Notre véritable faux contrôle de
flux ici. Et tout ce que nous voulons
faire, c'est retrouver notre valeur de
santé actuelle, alors faites glisser le contrôle dessus.
Voyez si c'est inférieur à. Nous allons donc chercher
l'opérateur « less than » ici. Et ce que je vais faire, c'
est vérifier si c' est inférieur ou égal
à un certain nombre. Branchez ceci dans la branche
juste ici, le booléen, et nous avons maintenant une
vérification indiquant que si notre santé actuelle est
inférieure ou égale à zéro, nous pouvons gérer
notre appel de la fonction de mort ou de la fonction de
gestion de la mort Demandez-vous pourquoi nous en utilisons
moins à un niveau égal à, d'
autant plus que
nous venons de le réduire pour
nous assurer qu'il
ne descende autant plus que
nous venons de le réduire pour jamais en dessous de zéro Et c'est juste une sorte
d'habitude de sécurité. Si quelque chose
inflige plus de dégâts que le reste de l'enfer, ou si nous devenons bizarres en virgule
flottante, ou même si nous
refactorisons le code plus tard et décidons de
ne pas le bloquer, je veux m'assurer
que cette vérification sera toujours pertinente pour
garantir que nous sommes morts Donc, par exemple, si
nous prenons cette pince, si nous avons cinq points de vie et nous subissons dix
dégâts supplémentaires,
nous serons évidemment à
moins cinq, ce qui signifie que si nous ne
cochons que zéro, alors un objet qui a subi
plus de dégâts qu'il ne le
devrait évitera d'être tué. Mais une fois cela fait,
depuis notre succursale d'ici, nous pouvons prendre le contrôle de la mort. Et si c'est vrai,
nous pouvons simplement le brancher C'
est ce qui va maintenant commencer à gérer toutes les fonctionnalités de
mort pour tous les avions que
vous pourriez être tenté de fabriquer,
et, bien sûr, pour les deux avions
que nous avons déjà. Handle Death contient déjà
la fonction
de destruction , et comme je l'ai mentionné, nous y
reviendrons plus tard pour ajouter des éléments tels que des explosions, des
effets
sonores et tous les éléments amusants et juteux que nous
voulons intégrer à notre jeu. Donc, pour commencer à
utiliser le système de dégâts, nous avons déjà mis
en place quelque chose pour tester au moins une partie du
fonctionnement de cette structure à
l'intérieur de notre ennemi. Donc, si nous revenons à la classe
ennemie, cette partie, qui ne fait que
notre chaîne d'impression depuis longtemps, nous pouvons
enfin la supprimer. Ce que nous voulons plutôt, c'est prendre notre acteur à succès, donc nous allons le
faire glisser vers le graphique en contrôlant. Nous allons nous inspirer de l'autre acteur, et nous cherchons le message global
que j'ai mentionné un peu
plus tôt, à savoir l'application damage. Nous pouvons donc voir ici que nous
avons appliqué des dégâts. Cela appelle simplement n'importe quel acteur avec lequel il peut
communiquer. Dans ce cas, ce
sera
celui dans lequel nous venons de rebondir Nous allons le connecter
juste ici, donc nous allons prendre nos épingles
d'exécution, assurer qu'elles sont toutes connectées
, le déplacer et nous voulons infliger
un certain nombre de dégâts au joueur Je pense que pour les ennemis,
je vais donner de santé à
cette moitié des joueurs. Je sais que le joueur
va avoir 100 soins. Nous allons le fixer à 50, ce qui
signifie que le joueur peut être touché deux fois par un ennemi pour ne pas avoir envie de rebondir trop souvent
sur lui. Ce ne sera pas un moyen
rapide et propre de gagner points
supplémentaires en percutant simplement tous les ennemis. Maintenant,
ça me le rappelle. Une autre chose que nous pouvons faire
avec nos variables héritées est que si nous sélectionnons
l'ennemi, par exemple, et que nous obtenons les détails de la classe juste ici, sur le côté
droit, nous voulons nous assurer
que la santé
de l'ennemi sera probablement différente
de celle du joueur. Nous pourrions donc régler la santé de
l'ennemi à 50, et dans le joueur, nous allons
simplement vérifier qu' il devrait y avoir une
valeur par défaut à 100 Assurez-vous que la
santé du joueur est réglée sur 100. Encore une fois, c'est un moyen
simple et agréable de définir la valeur de santé
une seule fois et de la gérer dans la classe parent à la
fois pour les dégâts subis
et pour les points de vie donnés ici, car ils sont
basés sur des variables qui existeront dans
toutes les classes. Ensuite, dans les classes pour enfants, il suffit de
modifier ces variables dans l'éditeur si nous voulons changer le type général
de balisage de notre Et comme je l'ai mentionné
, comme nous l'avons déjà configuré d'une certaine manière, cela signifie maintenant que nous
avons le surnom de Death. Nous n'avons pas besoin de
revenir et d'y toucher. Nous devions apporter un
petit changement. Il
n'était pas nécessaire de prendre en
compte la classe ennemie et tout
continuera de fonctionner comme avant. Une chose que je voudrais
vous montrer très rapidement, simplement parce que c'
est un autre de ces endroits très clairs où vous auriez
pu être tenté d'adopter une approche différente
pour gérer la mort l'ennemi, c'est que nous pourrions le
débrancher pour le moment Une autre chose que vous
pourriez faire est dupliquer notre fonction d'application
des dommages. Nous pourrions le brancher ici parce que l'essentiel est que lorsque
nous percutons l'avion du joueur, nous savons que la classe ennemie doit essentiellement s'infliger des dégâts
elle-même. Ce que nous pourrions faire, c'est
prendre notre valeur de santé maximale. Nous pouvons donc rechercher MaxEL
et le brancher ici. Et puis, l'
acteur endommagé,
nous pourrions simplement nous
infliger des dégâts. Donc, si nous tirons parti de
l'acteur
endommagé et que nous recherchons une cellule, nous obtenons cette option intégrée à fonctionnalité que je
voulais présenter, obtenir une référence à soi. Donc, en gros,
c'est un peu bizarre. Cela
trouvera essentiellement une référence à lui-même, qui se trouve ici. Il appellera le message d'application des
dégâts sur lui-même, qui
sera évidemment capté dans la classe de base, car c'est là
que nous
avons le cas où des
dégâts seraient infligés. Et parce que nous atteignons
une santé maximale, et ce n'est qu'une question de sécurité. Plus tard, j'ai décidé
qu'en fait,
le point de vie de l'ennemi
à 50 était trop faible, et je suis arrivé et je l'ai
changé à 75. De toute évidence, ce que nous ne
voulons pas faire, c'est avoir ce 50 codé en
dur, car
toute modification que nous apporterions sur une base plus large que celle de ce nœud
serait en quelque sorte oubliée et oubliée. Encore une autre façon,
encore une fois, d'essayer de
réfléchir à la façon dont vous
structurez votre code, l'utilisation de variables,
principalement à une sorte de pérennisation afin de ne pas avoir à
faire plus de travail à l'avenir. L'essentiel avec les programmeurs,
c'est que nous sommes plutôt paresseux. Le moins de travail que
nous ayons à faire, c'est mieux, en évitant de revenir à notre code et de changer
les variables partout. Si nous pouvons
configurer quelque chose comme ça, je peux changer la
santé maximale en n'importe quoi. Je pourrais le baisser, je
pourrais l'augmenter. Cette fonction le sera
toujours. Comme je l'ai mentionné, cependant, il ne se
lit tout simplement pas très proprement. Il faut un peu
plus de temps pour comprendre pourquoi un dommage a été
infligé, un
autre ici, et quels sont
ces différents acteurs. Je pense que c'est plus logique
si nous voulons simplement créer une sorte d'ennemi de style
kamikaze, nous pouvons simplement les intégrer,
et cela rend les choses beaucoup plus claires Nous allons donc infliger des
dommages à ce que nous avons fait, juste une fois que nous l'avons fait, nous allons nous infliger
des dommages à nous-mêmes. Et n'oubliez pas que c'est vraiment sûr parce que nous
regardons ici, nous vérifions si
l'acteur à succès est ce que le joueur humain contrôle actuellement,
et ce n'
est que si c'est vrai que nous
allons le faire. Cela n'infligera donc pas de
dégâts aux murs,
aux projectiles ou aux autres ennemis Tout cela sera
pris en compte ici. Il s'agit donc d'un
moyen agréable, simple et sûr de structurer les dommages causés par les chocs. Quelque chose que je n'ai pas
vraiment mentionné, mais gardez également à l'esprit que l'ordre des opérations
est vraiment important. Dès que vous y pensez,
si vous n'y avez pas
pensé auparavant, cela devient vraiment évident. C'est quelque chose
qui manque aux gens. Si nous nous contentons d'abord de gérer
la mort, nous pourrions également changer les choses. Si on le branche ici, on le
décroche, on le déplace. Juste un exemple très rapide,
rebranchez-le. Et c'est juste parce que j'ai déjà
vu cela se produire. Les étudiants ne savaient pas exactement pourquoi certaines fonctions n'étaient pas appelées quand ils
s'y attendaient. Cela peut également parfois être
introduit dans le système. certains systèmes, cela peut fonctionner, autres, cela peut
ne pas fonctionner, selon la
rapidité avec laquelle l'itération du ticket
et d' autres choses de ce genre se
produiront Mais en gros, si vous
pensez à ce qui se passe ici,
si nous appuyons d'abord sur le joueur et que nous
appelons le handle death en premier, cela revient à passer à
la fonction parent , à
appeler destroy, et
potentiellement si elle immédiatement ajoutée à la est
immédiatement ajoutée à la collecte des
déchets et effacée de la mémoire, cette classe n'existe plus. Cela signifie qu'il ne s'agira de revenir en arrière, de revenir dans cette fonction et d'infliger des dégâts au joueur. Vous pourriez donc vous retrouver avec une partie où le
joueur ne subit tout simplement jamais dégâts d'impact. Soyez donc prudent avec
ce genre de choses. Encore une fois, il est très
courant que les utilisateurs aient déjà maîtrisé le
côté mort des fonctionnalités, puis ils
reviennent et ajoutent
les effets de particules et le
son par la suite, sans savoir immédiatement pourquoi les particules et les effets
sonores ne se produisent pas. C'est parce que votre
classe est probablement en train d'être vidée de sa
mémoire et qu'elle n'existe pas. Cette fonction est
appelée. L'ordre des opérations est donc également important. Le contrôle du flux est
un autre mot pour cela. C'était un exemple très
simple, mais c'est un piège dans lequel il est facile de
tomber si vous n'y
prêtez pas suffisamment attention. Même si vous
comprenez le concept, c'est une simple erreur. Donc, si nous appuyons simplement
sur compiler et enregistrer, nous pouvons y retourner et
tester ou appuyer sur Play. Ce que nous
cherchons ici, c'est de nous assurer qu' ils continuent à se détruire eux-mêmes
lorsqu'ils touchent le joueur. Et surtout, après
deux coups comme ceux que nous avons vus là-bas, ils
détruisent également le joueur. Donc, ni le joueur ni l'
ennemi n'ont de système de santé, en
gardant à l'esprit que
nous n'implémenterons pas ce système de santé
dans chaque classe. Nous ne le faisons qu'
une seule fois dans la classe de base, et toutes ces fonctionnalités
permettant de calculer l'état de santé, vérifier si leur classe est morte, puis d'appeler la fonction
y sont toutes gérées. En y regardant, je viens de me rendre compte que j'ai
probablement créé un faux code. Cela
va en fait nous poser
un petit problème
parce que nous appelons
gérer la mort alors nous avons calculé
que la mort
serait appropriée, et c'est ce que
nous appelons ici. Il y a de fortes chances
que
deux ensembles de particules se mettent
en jeu. Nous allons en recevoir un pour un
appel pour dysfonctionnement, puis un pour un appel pour
dysfonctionnement, qui se produit en
fonction de l'état de santé. Maintenant que je
repense à mon propre code, je pense que nous devrions
faire de la même manière que j'essayais de l'utiliser
comme exemple d'apprentissage. Mais si nous reproduisons cela à nouveau, je pense que nous devrons
procéder dans l'autre sens. Nous allons donc nous infliger
des dégâts. Encore une fois, nous allons nous inspirer
de l'acteur des dégâts. Nous allons dire vendre, et
nous allons le brancher ici. Cela garantit simplement qu'il
est très facile d'oublier de telles
choses. Heureusement que nous y sommes retournés et que nous
avons jeté un coup d'œil rapide au code. Cela garantit simplement que les dommages
sont infligés à nous-mêmes. Nous allons utiliser la
même astuce que j'ai mentionnée il y a
un instant, donc Maxel Et encore une fois, je me rends compte que je pourrais
le supprimer de la vidéo. Mais comme j'ai créé tout
ce projet dans le but d'essayer d'enseigner
comment penser au codage, je pense que c'est un très
bon exemple
d'apprentissage du genre de choses que
vous pouvez oublier et de la façon dont vous pouvez facilement vous
retrouver dans une situation que vous devrez corriger plus tard. Cela garantira donc que nous nous
suiciderons définitivement. Nous transmettons toujours
le
maximum de santé que nous
pouvons avoir. Cela déclenchera son appel, ce
qui garantit que notre handle
Death ne sera qui garantit que notre handle appelé qu'une seule fois, ce qui signifie que lorsque nous arriverons
aux effets de particules, aux effets sonores, il
sera appelé une fois ici, puis
joué une fois ici. C'est donc la principale
chose que nous voulons éviter, afin que je puisse supprimer celle-ci. Il
ne se lit pas très bien. C'est ici que vous voudrez
peut-être ajouter
un commentaire juste pour que les choses soient
claires. C'est pour le joueur. C'est à vous de vous
assurer que nous nous
retirons toujours du jeu
après avoir touché le joueur. Une chose très simple,
vraiment petite. en ai fait un sujet plus vaste
simplement parce que c'est plutôt un moment d'apprentissage qui y
est apparu accidentellement Dernière petite chose que
nous pouvons faire alors que nous sommes encore dans la classe ennemie. Nous pouvons supprimer l'utilisation
de nombres magiques. Donc, pour le moment, nous n'appliquons que 50
dégâts au joueur. Nous pouvons le transformer
en variable, et nous
l'appellerons dommage par impact. Vérifiez simplement y en a d'autres que nous aurions
pu manquer. Je pense que c'était juste celui-ci.
Nous les avons, en fait, si vous vouliez
créer une
vitesse de déplacement minimale et maximale, car l'ennemi a la possibilité
de cette randomisation Il compile, sauvegarde,
retourne au lecteur
, vérifie ici. Je ne pense pas que nous
ayons
créé autant de variables que celles que nous avons créées récemment, donc cela convient aussi bien dans
la classe
joueur que dans la classe de
base. Autre chose que vous voudrez
peut-être faire si vous essayez vraiment de
garder toutes ces variables en ordre. Au fur et à mesure
que vous en obtenez beaucoup
plus, il peut devenir un
peu plus difficile trouver
à quoi elles sont liées Vous pouvez donc attribuer des
catégories aux variables, ce qui peut vous aider. Ainsi, par exemple, nous
avons ici la vitesse actuelle, la vitesse
cible, la vitesse d'interp Ces trois éléments sont donc tous
liés au mouvement, puis ces deux sont
liés à la rotation. Donc, ce que nous pouvons faire,
c'est que si nous sélectionnons l'
une d'entre elles dans le panneau des détails, nous obtenons cette option
ici pour une catégorie,
et nous pouvons la définir sur quelque chose comme un mouvement. Ensuite, nous pouvons
simplement
glisser-déposer les autres mouvements
dans la catégorie des mouvements. Nous pouvons saisir la rotation,
et nous pourrions peut-être lui attribuer une catégorie
de rotation. Pareil,
ajoutez-les , puis nous pourrons
les réduire. Cela facilite un peu les choses,
en particulier lorsque vous avez une longue liste de variables qui commencent à apparaître
dans des classes plus importantes Cela signifie que vous pouvez
simplement naviguer très rapidement pour trouver tous les
éléments liés au mouvement si vous recherchez
une valeur très spécifique à modifier et la
même pour la rotation Tu peux te battre. Vous pouvez
avoir une catégorie de booléens, vecteurs, tout ce que vous
voulez configurer ici. savoir comment votre processus de travail Il s'agit de savoir comment votre processus de travail s'adaptera le mieux à votre
projet, mais ce n'est qu'une idée rapide. Si vous voulez faire
quelque chose entre deux
sujets, n'hésitez pas à faire une pause,
à faire une petite pause
dans sujets, n'hésitez pas à faire une pause, le suivi et peut-être
à parcourir les autres classes voir comment vous pourriez
vouloir classer les choses dans la classe de base et peut-être
même dans la classe ennemie Je ne le ferai pas à l'écran,
mais c'est juste une idée pour concrétiser ces concepts et
vous faire savoir que ces
fonctionnalités existent. fois cela fait, notre
système de santé est complet. Nous l'avons implémenté une fois,
et cela fonctionne partout. Cela signifie que nous pouvons passer
aux projectiles. Et encore une fois, nous pouvons
maintenant simplement nous appuyer sur les bases que
nous avons déjà créées. C'est à ce moment-là que
le combat deviendra plus intéressant et que nous
pourrons réellement riposter.
17. 16 - Amélioration du mouvement: Souvenez-vous de ce bogue
de fréquence d'images que nous avons reconnu et
que nous venons de corriger. Il est temps d'y
revenir et d'y remédier. Nous remplacerons le code de mouvement
problématique par
un code prêt pour la production. Indépendance adéquate en termes de fréquence , structure
plus propre
et meilleur remplissage. Je me rends compte
qu'avant de commencer à ajouter des éléments
sophistiqués tels que des générateurs d'
acteurs, des
projectiles ou le renforcement du système de dégâts, tout en améliorant le code
de base, nous devrions probablement revenir en arrière
et nous assurer de ne pas oublier le mouvement et
le bogue dont nous sommes déjà conscients Le code incriminé
que nous devons corriger se trouve dans notre classe de joueurs Donc, si vous ne l'
avez pas déjà ouvert, allez-y et ouvrez le lecteur ordinaire BP
Underscore Dans mon cas, je vais juste
appuyer sur le bouton central de la souris, fermer les onglets que
nous n'utiliserons pas. Donc, la classe de base et
la classe ennemie et naviguez dans la fonction de
mouvement de la poignée juste ici. C'est donc le code que nous
voulons remplacer et améliorer. Maintenant, la première chose à faire est qu'après
le mouvement du handle parent, nous voulons cliquer sur ce code et le
déconnecter Certaines personnes ont des opinions
différentes sur ce genre de choses. Encore une fois, je veux continuer à me
concentrer sur la structure du code ,
les
bonnes pratiques, etc. Ce que vous pouvez constater,
en particulier dans le code C plus plus, c'est certains développeurs peuvent conserver l'ancien code que nous
essayons de remplacer. Mettez-le peut-être dans un commentaire
au cas où vous voudriez le
voir plus tard au cas où vous penseriez
devoir vous y rabattre. Cela se traduit par un espace de
travail encombré. Vous avez peut-être beaucoup plus de code dans votre C
plus que ce dont vous avez besoin. Dans Blueprints, nous pouvons
évidemment avoir beaucoup plus de choses dans
le graphique que ce dont nous avons besoin Et idéalement, nous
utiliserions quelque chose comme Github pour le
contrôle des sources de toute façon Donc, si jamais nous avions besoin de
consulter un ancien code, idéalement, nous devrions simplement restaurer
notre dépôt et le consulter via Git
ou Perforce ou quelque chose comme ça Maintenant, dans ce cas,
je vais m'en tenir à ceci juste un moment
car je pense qu'il y
a certaines choses que nous pouvons simplement
copier-coller pour plus de rapidité, mais nous allons nous débarrasser complètement
de ce code Nous allons donc
recommencer à zéro. La première chose
que nous voulons faire est sortir de notre
épingle d'exécution ici et de
créer ce que l'
on appelle une séquence. Nous voulons cette option juste ici. Et si vous ne les avez
jamais vues auparavant, les
séquences sont largement
sous-utilisées Ils font en sorte que notre plan se
lise comme un code traditionnel, c'est-à-dire de haut
en bas, de gauche à droite Chacune des épingles gère
une tâche spécifique, ou du moins c'est ainsi que nous devrions
penser à les utiliser. C'est beaucoup plus clair que la logique qui s'étend sur
les trois moniteurs, simplement parce que vous avez
cette longue logique. Juste pour te dire que
je ne veux pas me vanter. C'était exagéré. En fait, je n'
ai pas trois moniteurs. Il y a d'autres
avantages et raisons lesquels vous pourriez vouloir l'utiliser, mais l'essentiel, pour en
revenir aux séquences,
c' est qu'elles constituent un très bon
moyen de structurer notre code et de nous aider à penser manière logique en décomposant les choses
essentiellement en étapes Vous dites : faites ceci,
puis faites ceci, puis faites ceci, et vous essayez de faire en sorte que tout soit quelque peu unique pour une tâche donnée. Donc, la première chose que
nous
voulons réellement dans le cadre de notre tâche est calculer la vitesse de déplacement de notre
cible. Nous le faisons
déjà ici, donc c'est l'une des choses
que nous pouvons simplement saisir. Si nous saisissons le code jusqu'au nœud de vitesse de déplacement
cible, appuyez sur Ctrl en X,
puis repassez le code
et collez-le. Ce sera donc la
toute première tâche que nous nous donnerons
sur notre séquence. Une autre chose qui peut
nous aider à garder le code un
peu lisible est que si nous
double-cliquons sur un fil, cela nous donnera un nœud de réinitialisation Nous pouvons le déplacer
ici parce que nous
voulons nous assurer d'
avoir suffisamment d'espace, essentiellement pour le chemin différent
que nous suivons. Maintenant, une chose que nous
allons changer, c'est que nous allons créer
notre propre interpolation. Nous n'utiliserons pas F interp 2. Pour cette raison,
nous allons modifier légèrement les secondes Get
World Delta. L'homme, débarrasse-toi de ce
nœud, le multiplicateur. Associez-le
directement à la vitesse cible définie, et nous allons
rendre cette fréquence d'images indépendante un peu
plus tard. Nous allons garder ça à portée de main. Nous en aurons besoin
dans un instant. Ils obtiennent des secondes Delta dans le monde. Mais c'est à peu près tout.
C'est notre première étape. La première chose à faire
est d'avoir un objectif à atteindre. Cela nous allie alors. Nous
pouvons aller jusqu'à ce point. Et ce que nous allons
faire ici, c'est calculer notre propre Alpha d'
interpellation personnalisée Cela va donc devenir un
peu mathématique, mais ce sera la clé d'
une véritable indépendance du famérate Nous allons passer en revue,
nous allons l'ajouter, puis je vais prendre du recul
et essayer d'
expliquer pourquoi nous nous retrouvons avec
un calcul que nous avons. Donc, la toute première
chose que nous voulons, c'est notre vitesse d'interaction des mouvements Nous allons
donc
contrôler le glisser-déplacer et obtenir la vitesse d'interaction des
mouvements. Nous allons le multiplier
par nos secondes Delta, c' est
pourquoi il est disponible il y a un
instant Nous allons
donc
avoir nos secondes Get world Delta pour recommencer à rendre notre indépendance en termes de
fréquence d'images de calcul. Nous voulons ensuite annuler ou inverser le calcul que nous créons, nous allons
donc multiplier ici Nous allons pouvoir multiplier le nœud et le
multiplier par moins un. D'après nos calculs,
nous allons tirer à nouveau. Je vais chercher
quelque chose appelé EXP. s'agit de la
valeur exponentielle, donc il est dit ici que cela ramènera l'
exponentielle E à la puissance de la valeur.
Nous allons donc l'utiliser. Enfin, après
notre nœud exponentiel, nous allons tirer d'ici,
et nous allons soustraire. Il suffit
donc d'appuyer sur la touche moins, Il suffit
donc d'appuyer sur la touche moins trouver soustraire et d'en soustraire
un du calcul un du L'important,
avant d'oublier nous ne voulons évidemment
pas de chiffres magiques, nous allons les
tirer de la dernière épingle. Nous allons en
faire une variable, et nous l'
appellerons MV Alpha Si vous avez
créé des catégories, vous souhaiterez peut-être les déplacer
dans la catégorie des mouvements. Car, bien sûr, cela va
être spécifique au mouvement. Nous allons le connecter
à notre code d'exécution, puis à un, et nous avons maintenant
notre code Alpha prêt à être utilisé. Voici donc notre
interpolation fluide que nous utiliserons de
manière plus manuelle et
intentionnelle dans notre code Donc, juste pour nous concentrer
sur ce que cela fait, cela nous donne un moins E à la
vitesse négative multipliée par Delta. Essentiellement, cela fournit
une courbe de décroissance lisse. C'est la principale raison pour laquelle
nous devons utiliser la méthode de soustraction à la fin, car nous voulons qu'
elle diminue avec le temps Et la raison pour laquelle nous
devons utiliser une
telle formule est de revenir à la principale source du
problème que nous rencontrons entre les
différentes fréquences d'images et le fait de garder
les choses indépendantes de la fréquence d'images. La fonction F interp fournit
en fait une approximation
linéaire, et c'est ce qui se produit lorsque les fréquences
d'images sont faibles En comparaison, si nous
créons une fonction comme celle-ci que nous pouvons utiliser avec
une fonction Larp standard, cette
approche exponentielle nous donne interpolation
mathématiquement correcte C'était donc l'
objectif principal ici, c'est
que nous voulons simplement arrêter
complètement de l'utiliser. Enfin, en gardant à l'esprit
que nous voulons essayer de faire des
choses spécifiques très uniques par ligne. Nous allons ajouter une autre épingle, et nous voulons que les
deux épingles de l'époque soient là. Nous allons partir de là, et nous voulons faire
la dernière chose, qui consiste à utiliser
la vitesse actuelle pour
l'interpoler Nous voulons toujours
utiliser l'interpolation, mais uniquement la version de base la plus
rudimentaire avec notre propre Nous pouvons donc tirer parti de
l'épingle d'exécution. Nous pouvons trouver la vitesse actuelle
définie. Il faut donc définir la valeur que
nous avons suivie, et c'est là que nous
voulons tirer de cette épingle, et nous allons
rechercher une boucle. Et cette fois, nous voulons
simplement utiliser la boucle flottante standard. Vous pouvez donc voir que c'est
un peu plus simplifié. Au lieu d'avoir le
courant vers la cible à l'heure Delta et
une vitesse d'interp, si nous voulions modifier
la vitesse d'interp, nous devons ajouter une
sorte de décalage ici Tout ce que nous faisons, c'est fournir
cette courbe exponentielle, qui sera notre Alpha Donc, si nous lançons le mouvement Alpha, nous pouvons le déposer ici. Mais en plus de cela, nous
faisons toujours
essentiellement la même chose. Nous allons
passer d'un point A à un point B. Et je l'ai mentionné
lorsque nous avons
examiné pour la première fois le F dans les deux premiers, nous avons en quelque sorte 0,1 dans 0,2 ou point A et le point B. Nous faisons donc
toujours la même chose. Nous passons de A, qui
est la vitesse actuelle, à B, qui est notre vitesse cible
sur une période donnée, et nous nous basons
maintenant sur notre propre Alpha mobile personnalisé C'est donc le principal changement
ici, c'est que la façon dont nous réglons la
vitesse actuelle est mise à jour. Donc, si nous le suivons, nous pouvons
réellement le supprimer maintenant. Nous pouvons donc voir que nous
avons presque terminé la mise à jour de notre base de code. Je vais
double-cliquer à nouveau ici pour créer un autre nœud de réinitialisation, juste pour le
garder un peu en ordre, déplacer les choses, pour nous
donner suffisamment nous
donner La dernière chose est donc que nous
voulons redéfinir notre position. Nous allons également faire quelque chose de
légèrement différent ici. fois que nous avons défini
la vitesse actuelle, une fois que nous
l'avons suivie, nous voulons utiliser
notre épingle d'exécution et
rechercher ce que on appelle Add Actor World Offset. Nous pouvons donc voir l'
option juste ici en haut, sur Actor world offset. Donc, pour notre cas d'utilisation, c'est
en fait la meilleure solution par rapport à la
position définie de l'acteur pour un mouvement
sensible à la physique. La seule chose que
nous devons vraiment changer, c'est de cliquer avec le bouton
droit de la souris sur le vecteur de
localisation Delta, diviser l'épingle de la structure pour les mêmes résultats qu'auparavant. Nous voulons prendre
notre vitesse actuelle, afin de pouvoir la connecter si vous le souhaitez, mais dans ce cas,
je vais juste
contrôler la vitesse actuelle de déplacement. Nous allons le multiplier par
le delta des secondes. Nous allons donc avoir encore quelques secondes dans
G World Delta, et nous allons les intégrer
à notre résultat ici. Et puis, bien sûr,
nous allons en faire le Y parce que nous nous
déplaçons d'un côté à l'autre. Nous voulons donc cela sur l'
axe Y. C'est à peu près ça. Nous avons donc maintenant mis à jour. Nous pouvons également nous en
débarrasser. Nous avons maintenant mis à jour
notre code de mouvement. Nous suivons la
vitesse cible un peu différemment. Nous avons créé un alpha de mouvement entièrement
personnalisé basé sur une courbe de décroissance, et nous avons
légèrement modifié la façon
dont nous gérons vitesse actuelle et
la façon dont nous l'
associons à la position dans
le monde Maintenant, une chose que nous
pourrions faire ici, juste pour améliorer un peu les choses, c'est de recommencer à
commenter les choses. Encore une fois, c'est une bonne utilisation des commentaires lorsque nous avons
ces grandes divisions de logique spécifique dans notre Ce que nous pourrions faire, c'est de
récupérer ces nœuds ici, appuyer sur C. Et si je voulais
faire un commentaire, je dirais peut-être quelque chose comme définir vitesse que l'avion doit atteindre ne pas avoir besoin de me
plonger dans le code plus tard, je pourrais simplement préciser
qu'il s'agit précisément de la
vitesse cible que nous examinons. Encore une fois, je pourrais donner ce genre de
couleurs plus uniques juste pour que les commentaires se démarquent
d'autres choses comme celles que nous avons
créées plus tôt. Nous n'avons pas besoin de le faire pour que tout
soit vraiment joli. Vous pouvez certainement vous
laisser emporter par cela. Mais lorsque je change
la couleur des choses, c'est d'autant plus qu'en
un coup d'œil, je sais que j'utilise un
gris spécifique pour les commentaires. J'utilise un rouge spécifique pour code
potentiellement cassé ou quelque chose qui doit
être déplacé en même temps. D'habitude, j'utilise
un vert pour faire. Encore une fois, en
un coup d'œil, je peux voir en
parcourant mon code. Ce ne sont que des commentaires pour
lesquels j'ai besoin d'un rafraîchissement c'est quelque chose dont je
dois vraiment me débarrasser plus tard, et des choses comme ça
peuvent devenir utiles. Je leur donne donc
une couleur très bleue et grisâtre juste
pour me le rappeler Il suffit d'appuyer sur
Ctrl C et Control V pour obtenir un autre
commentaire ici, de dupliquer celui-ci, et nous le déplacerons approximativement que je
n'aie pas besoin de redéfinir la couleur.
Et c'
est l'une de ces choses. Une fois que vous vous êtes habitué aux raccourcis
et à d'autres choses de ce genre, le tout petit peu de
temps supplémentaire qu'il faut pour vous
donner une
couleur personnalisée et un
peu de thème n'
ajoute pas trop de temps à
votre temps de développement. Donc, si je devais
me laisser un commentaire pour plus tard,
cela nous aide à suivre Alpha pour l'utiliser dans notre fonction d'
interpolation. Encore une fois,
je me rappelle simplement qu'il s'
agit spécifiquement de mettre à jour la fonction
Move Alpha Ensuite, nous voulons peut-être
un autre commentaire. Je l'ai dit, je ne le
ferai pas pour chaque ligne de code, et je ne le ferai pas pour le
reste du projet et des vidéos, car les vidéos
deviendraient trop longues. Mais juste pour montrer le
concept, alors que nous sommes confrontés à certains de ces
refacteurs et changements plus importants, qui peuvent être un
peu plus confus, je pense que c'est vraiment
intéressant à voir Nous allons donc simplement les
mettre en place. Et je pourrais appeler
celui-ci, c'est que nous mettons à jour notre vitesse actuelle
, puis nous définissons la
position de notre avion. Et en disant
cela, c'est en fait une autre chose très utile, c'est que je remets en question mon propre code parce que nous
faisons deux choses par ligne. Et si vous vous souvenez, j'ai dit que la règle générale est qu'
avec une séquence, nous les traitons
un peu comme des fonctions où les
fonctions devraient faire une chose en particulier
et une chose vraiment bien. Donc, pour le moment, nous suivons
principalement cela. Il s'agit de définir spécifiquement
la vitesse cible. Il s'agit de calculer et de définir spécifiquement le mouvement Alpha, mais cela fait maintenant en
quelque sorte deux choses. Il règle la vitesse actuelle, puis il déplace l'avion. Donc, ce que je pourrais être
tentée de faire, c'est ajouter un autre puis de l'épingler ici, le contrôle des
seins en X, le
contrôle en V. Branchez ça. Et encore une fois, plus que tout,
j'aurais pu le laisser, mais juste pour montrer à quel point il est
facile de garder votre code propre et de
suivre des règles
et des structures spécifiques. C'est donc maintenant que nous nous en tenons aux
règles que nous nous sommes données,
et j'ai juste besoin de changer un
peu les choses et peut-être d'
ajouter un autre nœud de réinitialisation ici Rangez un peu les choses. Encore une fois, nous n'
essayons pas de créer cette œuvre d'art, mais plus elle
sera facile à utiliser, notre futur nous en
sera reconnaissant. Ce que nous faisons maintenant, c'est si nous
pensons au code. Nous pouvons venir vous
faire part de notre dernier commentaire. Il s'agit donc de régler la vitesse
actuelle sur la base d'une simple interpolation,
donc d'une simple alerte C'est donc la seule chose que cette ligne fait spécifiquement. Et puis, encore une fois, nous avons
besoin d'un dernier commentaire C'est pourquoi Control C control
V a mis cela en place. Je veux dire, j'ai une très
belle brique logique, donc il s'agit simplement de
mettre à jour la position de l'avion. Donc, si nous
devions lire ceci, nous
pourrions voir précisément
ce qui se passe. Nous sommes en train de définir la vitesse cible. Nous mettons à jour le move Alpha, qui sera utilisé ultérieurement pour la fonction d'
interprétation. Nous utilisons cette fonction d'
interprétation et définissons la
vitesse actuelle en fonction de cela. Ensuite, nous prenons
ces variables et nous mettons à jour la position finale de l'
avion. C'est donc probablement mieux que ce que j'avais il y a un
instant. Ce n'est qu'un petit
changement, mais encore une fois, en tenons à ces règles, nous nous en tenons à ces règles, nous les considérons
comme de petites fonctions, essentiellement, et ils
font tous ce travail manière
très spécifique, et
ils le font bien. Gardez les choses bien rangées, faciles à lire. Et si jamais nous avions besoin de
revenir et supprimer quelque chose, d'y ajouter quelque chose, il
sera beaucoup plus facile de
mettre à jour et de corriger notre
code à l'avenir. C'est donc comme une tangente latérale. Je ne m'attendais pas
à approfondir la question de la propreté du code, mais j'ai encore une fois
saisi l'opportunité, car je quelque sorte allée à l'encontre de ce que j'ai mentionné au
début du sujet. C'est fait. C'est le
mouvement qui est maintenant prêt à démarrer. Ce que nous devons examiner ensuite,
c'est le système de rotation. Ce sera le même
problème parce que nous utilisons le
même type de matériel. Si nous devons gérer la rotation. Nous avons une
fonction très simple, qui est, encore une fois,
ce qu'Unreal fait vraiment bien pour nous Il fournit un grand nombre de
ces fonctions d'assistance, celle-ci intégrée à R interp deux, agréable et simple,
un nœud, quelques nœuds à côté
pour le calcul, puis définit la rotation
active, et nous sommes prêts à faire Mais ce que
les gens doivent
savoir , c'est qu'en général, ce n'est
bon que pour les tests. Nous voulons probablement commencer
à élaborer
notre propre code lorsque nous serons
plus sérieux et que nous prendrons les choses
en main. Avant de passer à la
fixation de la rotation, il suffit de vérifier quelques éléments pour
vérifier le mouvement de la poignée. Comme nous allons régler
la vitesse actuelle un peu plus
manuellement de cette façon, nous voulons probablement nous assurer que je
viens de remarquer, lorsque j'ai cliqué dessus plus tôt, vitesse
actuelle a
une valeur par défaut La valeur par défaut ici était
essentiellement la date à laquelle il s'agissait à l'origine de notre vitesse de
déplacement générale. Nous allons donc vouloir
le réinitialiser et assurer que la vitesse actuelle, la vitesse
cible, le mouvement, la vitesse d'interp auront une valeur, mais que la vitesse de la cible du monstre et vitesse
actuelle sont toutes
définies sur zéro par défaut, et elles ne seront
calculées qu'au moment de l'exécution L'autre point, le même problème,
très facile à résoudre, c'est que j'ai presque oublié de
cocher la fonction de balayage a
donc la même fonction que la
fonction de localisation réelle que nous avons utilisée précédemment Nous devons
donc nous assurer
que le balayage est activé Ça devrait être
une bonne idée. Cela ne fonctionnera pas
complètement pour le moment. Et je viens de me rendre compte que nous l'avons
fait de la mauvaise façon. Je pense que je vous disais soustraire la
bonne chose tout
à l'heure, mais lors de la mise en œuvre
, je l'ai mal connectée. Donc, si nous cliquons à la touche Alt
après l'exponentielle, ce qui est très important
ici, nous voulons soustraire notre
calcul de Nous repartons donc de l'
un d'entre eux. Nous établissons cette courbe de décroissance à partir d'une
courbe basée sur
cette mise à jour au fil du temps. Donc oui, il s'agit simplement de tester rapidement pour s'
assurer que cela fonctionne toujours. Comme je l'ai mentionné, la rotation va
être un peu travaillée, mais nous avons toujours
le même mouvement. Nous avons
donc un mouvement
fluide, avons
donc un mouvement
fluide, la rotation parce qu'elle est
basée sur la vitesse que nous
avons, c' basée sur la vitesse que nous
avons est complètement cassé,
mais c'est quelque chose avec lequel
nous pouvons travailler, et nous l'
améliorons en quelque sorte au fur
et à mesure que nous et
refactorisons la rotation Donc, juste quelques
derniers récapitulatifs. Assurez-vous que nous
calculons notre valeur exponentielle, puis nous la
retirons de 1. C'est donc un moins notre calcul
exponentiel ici, et c'est le résultat que
nous voulons pour notre mouvement Alpha Vitesse actuelle, vitesse cible,
idéalement, vous
devriez être réglée sur zéro. Nous calculons cela ici, les
multipliant à nouveau,
et nous obtenons ici un bon mouvement
indépendant de la fréquence d'images C'est donc toujours
un sentiment et fonctionnement très similaires à
ce que nous avions auparavant. Vous devrez peut-être
ajuster un
peu la vitesse maintenant, mais nous sommes
très proches de ce que nous avions Les rotations sont interrompues,
ce qui, comme je l'ai mentionné, est prévisible parce que nous ici
un calcul très simple basé sur la vitesse cible et que
nous
multiplions simplement cette valeur par le facteur d'inclinaison. Maintenant, la
vitesse cible ou la vitesse actuelle, désolée, est gérée d'une
manière très différente Cela fait, cependant, nous
avons amélioré le mouvement. C'est vraiment une bonne
base pour commencer, puis nous pouvons passer
directement à la rotation J'apprécie ces sujets
assez lourds au
fur et à mesure, mais j'espère prendre le temps
entre les sujets, faire une pause chaque fois que
vous aurez besoin et essayer vraiment comprendre ce que
nous avons fait et pourquoi ces changements
vont fonctionner. J'ai essayé d'expliquer les calculs
et tout ce qui les sous-tend. Certaines choses sont
vraiment difficiles à comprendre
sans avoir une expérience pratique
du code source. Donc, autre chose
, vous pouvez accéder au code source d'Unreal Engine, trouver la fonction Ler
dans C plus plus Et encore une fois, même si
vous ne
comprenez pas bien C plus
plus, c'est très bien. La plupart sont
très lisibles par l'homme. Les commentaires sont tous là. Il explique étape par étape ce qui se passe sur la
fonction F interp Et parfois, il suffit de plonger dans
le code source de cette façon, car tout est
facilement disponible. Soyez vraiment utile et vous
commencerez à comprendre certaines des limites liées à
la simple
utilisation des fonctionnalités reconstruites et
prédéfinies
fournies par le moteur Unreal ne veut pas dire que c'est mauvais, comme je l'ai mentionné, il
a ses cas d'utilisation, mais nous trouvons cas marginaux où
cela ne fonctionne tout simplement pas, et nous devons créer
notre propre code
18. 17 - Rotation améliorée: Configuration du mouvement. Nous devons maintenant faire la même chose
pour notre rotation. Nous voulons toujours être à l'intérieur
du joueur d'avion. Nous allons passer à la fonction de rotation de la
poignée. Je vais faire une mise à jour très
similaire ici. C'est une autre
bonne chose que nous puissions commencer à uniformiser un
peu le code , car la logique sous-jacente
sera très similaire. Donc, en fait, nous pouvons faire
nos premiers pas ici. Nous allons le déplacer vers le bas. Nous allons le décrocher,
et nous garderons tout ce quoi nous
reviendrons un peu plus tard, mais comme vous l'avez
dit, nous nous débarrasserons complètement
d'ici la fin Maintenant, la première chose à faire est
que nous voulons obtenir notre séquence. Nous pouvons refaire la même chose. Nous allons donc prendre un nœud de séquence, et nous allons commencer à le garder
bien rangé, car nous allons avoir besoin de
beaucoup de
calculs pour cela Nous veillerons donc à ce que notre code soit
bien aligné. Maintenant, nous devons faire un petit peu
plus pour la rotation car,
comme je l'ai dit précédemment, il s'agissait d'une valeur quelque peu
arbitraire simplement multipliée par la vitesse actuelle
sans rien
d'
autre ne soit vraiment pris en compte. Nous allons donc faire un
peu de serrage et rangement pour le rendre également un
peu plus raffiné Ce que nous voulons, c'est
prendre notre vitesse actuelle. Nous allons revenir à la
vitesse actuelle,
donc nous allons toujours la
baser à peu près sur la même chose, mais avec quelques modifications. La façon dont nous allons
procéder est basée sur la vitesse actuelle. Nous voulons utiliser ce que
l'on appelle une plage cartographique bloquée Cela va mapper une
plage de valeurs à une autre, parfait pour
convertir la vitesse en un angle d'inclinaison spécifique. Dans la plage A,
notre vitesse de déplacement sera annulée. Nous allons donc cliquer avec le bouton droit de la souris,
rechercher la vitesse de déplacement ,
car elle est accessible
depuis notre classe parent, la vitesse cible réelle, la vitesse maximale que nous pouvons déplacer, donc nous allons obtenir
la vitesse de déplacement. Nous allons le multiplier
par moins un. N'hésitez pas à vous donner de
l'espace au fur et à mesure. Ce
sera donc notre gamme A.
Dans la plage B, ce sera simplement la vitesse de déplacement,
donc inchangée. Et encore une fois, je me donne juste
un peu plus d'espace, car nous allons avoir
besoin de plus de choses ici. Ensuite, nous aurons
besoin d'une nouvelle valeur pour inclinaison maximale et minimale que nous voulons atteindre. C'est donc là que nous
n'avons en fait aucun contrôle. Nous pouvons donc dire que nous voulons soit qu'il puisse
s'incliner d'un maximum de 15 degrés
à la fois, soit de
25 degrés ou ce que vous vouliez
dans la catégorie de rotation. Et encore une fois, si vous avez des
catégories, c'est très bien. Si ce n'est pas le cas, prenez simplement n'importe quel
char que vous avez. Je vais prendre
mon facteur d'inclinaison, dupliquer, et je l'
appellerai Max Tilt. Appuyez sur compiler, et je
pense que par défaut, je vais lui donner une valeur
maximale de 15, donc cela bloquera une
rotation de 15 degrés dans les deux sens Vous pouvez créer une inclinaison minimale, qui serait de moins 15, mais comme nous l'avons
fait ici, nous allons simplement
prendre notre inclinaison maximale et nous allons la multiplier
par moins un. Et ce sera
notre fourchette A, et vous allez commencer à voir
comment tout cela fonctionne. J'espère qu'au fur et à mesure que vous
les verrez se réunir. Et je vais
prendre notre inclinaison maximale ,
puis ce
sera notre plage de sortie B. Nous allons
donc prendre
notre vitesse actuelle, quelle que soit notre vitesse actuelle, telle qu'elle a été calculée, si elle se situe
entre zéro et vitesse de
déplacement maximale
négative. Je crois que c'était 1 000. Ensuite, notre inclinaison
maximale sera comprise entre zéro et moins 15
sur la base d'une sorte de pourcentage, une valeur uniforme qui
correspondrait approximativement à
cette vitesse Et vice versa,
si nous nous déplaçons vers la droite, nous allons prendre
notre vitesse de déplacement maximale, zéro à plus de 1 000, et je vais choisir une valeur d'
inclinaison de 0 à 15 degrés C'est ainsi que nous pouvons réellement
serrer plutôt que d' avoir une
rotation complètement arbitraire dans les deux cas. En fait, nous basons cela
spécifiquement sur
notre vitesse actuelle, puis nous le mappons entre les
vitesses réelles que nous pouvons Cela le rend très
facile à mettre à jour. Si jamais nous voulons dire qu'
il faut avoir plus d'inclinaison tout en gardant la même vitesse, nous pouvons simplement l'augmenter. Je pourrais dire que vous
pouvez maintenant l'incliner jusqu'à 25 degrés au lieu de 15. Pour les tests,
je pense que je vais le maintenir à 15, mais nous pouvons très facilement contourner
cela. Nous ne voulons pas en
faire une variable. Donc, quel que
soit le résultat, nous allons passer à une autre variable C'est ce que j'appellerai une inclinaison de la cible. Cela ressemble beaucoup à
la façon dont la première chose que nous avons faite en mouvement a été de calculer
notre vitesse cible. Et branchez-le sur
zéro, déplacez-le vers le haut. Et nous allons probablement
devoir faire pas mal
de recherches ici pour que cela reste plus lisible, simplement parce qu'il y a beaucoup plus de calculs mathématiques
à effectuer dans cette fonction La rotation est
toujours un peu plus complexe et fastidieuse que calcul du mouvement, du type de position général
ou même
des décalages d' Maintenant, l'
Alpha cible est en fait tellement similaire que je vais
être un peu paresseux. Je vais revenir
au mouvement des poignées. Je vais récupérer tout
le code ici, appuyer sur la touche C, donc je vais obtenir tous ces nœuds ici. La seule chose que nous ne
voulons pas, c'est le déplacement Alpha. allons revenir
ici dans la rotation, et nous allons l'associer à une valeur dans un instant. La seule chose que nous pouvons
vouloir faire est de
placer l'inclinaison de notre cible dans
la catégorie de rotation. Je vais en fait le renommer
parce que nous avons des conventions de
dénomination légèrement différentes Je vais donc prendre la vitesse d'interp de
rotation et la remplacer inclinaison, car nous avons décidé
que tout le
reste était en quelque sorte classé comme inclinable plutôt que Je vais contrôler la vitesse d'interaction entre
l'inclinaison et le glissement. Et branchez-le là. Nous pouvons donc nous débarrasser de la vitesse d'interaction des
mouvements
au début Mais à part ça, nous
faisons exactement la même chose. Nous
multiplions notre vitesse d'interp d'
inclinaison par les secondes delta
du monde G, multipliée par moins un, obtenir le rendement exponentiel, puis nous le
créons à nouveau, notre courbe décroissante au fil du temps Nous retirons donc toutes
ces valeurs d'une seule. Le résultat en sera
donc une autre nouvelle variable, nous allons
donc la
promouvoir en une autre variable, et nous
l'appellerons Tilt Alpha. Parce que nous allons
vouloir refaire la même chose. Nous allons le connecter à notre propre nœud d'interpolation ou nœud de boucle dont nous aurons
le contrôle total Nous allons donc simplement le déplacer à nouveau en essayant de garder les choses
un peu en ordre Je pense que juste pour la propreté et l'espace, je vais juste le
supprimer maintenant. Nous n'avons pas besoin de procéder
étape par étape comme
nous l'avons fait plus tôt. Nous n'utiliserons tout simplement rien
de l'ancien code ici. Nous allons donc créer
une autre épingle de séquence. Nous voulons passer à l'étape
suivante de la logique. Celui-ci est très
simple. Donc, encore une fois, très similaire à la troisième étape
de notre code précédent. Nous allons définir
notre inclinaison actuelle. Et je pense qu'en y
regardant maintenant, nous allons probablement
commencer à mélanger les valeurs ici. Donc Max til we want
et nous
utilisons actuellement Tilt Factor, je pense que
nous allons rater. Je vais donc
renommer ce
facteur d'inclinaison en inclinaison actuelle Et ce mot
perd peu à peu tout son sens. Je l'ai dit un
peu trop souvent. Nous allons le faire glisser
et insérer le code d'exécution. Et encore une fois, la valeur que
nous voulons renseigner ici, en assurant que si nous appuyons sur compiler
, elle n'
a plus de valeur par défaut, nous la mettrons
donc à zéro. Cette valeur sera calculée en
fonction d'une autre boucle. Encore une fois, c'est la même chose,
une boucle flottante. Et encore une fois la même chose.
Nous allons donc prendre notre inclinaison actuelle, notre inclinaison cible et notre
alpha. C'est si beau et si simple. Comme je l'ai mentionné, j'
aime à peu près le mouvement, mais maintenant tout est lié à la rotation
ou à l'inclinaison. Vous pouvez donc voir le
schéma. En fait, nous avons pu utiliser
essentiellement le même code. N'avez-vous donc pas
compris cela une fois ? Il est très facile de
le réutiliser et de le refaire. Nous avions besoin de nous concentrer un
peu plus sur la partie initiale de
la rotation ici,
mais sinon, de manière très similaire Nous pouvons donc refaire la
même chose. Nous voulons une épingle de plus,
et cela va en fait utiliser ces valeurs
et régler la rotation. Encore une fois, c'est pareil.
Cette fois, nous voulons utiliser l'appel de la fonction set actor
rotation. Nous allons donc le brancher ici, et nous reviendrons faire
un peu de ménage avec
quelques reracines un peu plus Nous allons scinder l'
épingle de la structure comme nous l'avons fait précédemment. Nous allons prendre notre valeur d'inclinaison
actuelle, et nous
l'intégrerons à
ce que nous faisons sur le rouleau. Et c'est à peu près tout, mais nous avons encore une fois les
mêmes étapes. Définissez donc la cible, définissez l'Alpha, définissez le courant, puis utilisez le
courant comme valeur. Maintenant, je vais juste
entrer, comme je l'ai dit, nous allons faire un peu de
rangement parce que cela
devient un peu étroit
et difficile à lire Je pense que c'est bien si
je ne dois pas passer trop de temps
à imprimer les nœuds, mais cela suffit juste pour
séparer les choses Et comme je l'ai mentionné,
je ne veux pas passer beaucoup de temps à
commenter mon code Ce n'est pas la chose la plus utile à
voir en streaming ou en vidéo. Mais si vous vouliez
faire la même chose, juste une petite chose
à emporter entre les sujets, peut-être encore une fois, suspendez le contenu et dites
simplement qu'il ne s'agit d'une tâche pour vous assurer de
bien comprendre ce qui se passe. Lisez le code et la rotation
et voyez si vous pouvez
vous faire de bons commentaires pour décrire exactement
ce qui se passe ici, pourquoi nous
utilisons le télémètre, etc. Et l'essentiel est que si
vous deviez revenir et examiner le code dans un mois
ou deux, en un coup d'œil, il est beaucoup plus facile de voir
ce qui se passe
actuellement, car il faudrait que j'y revienne et que je le lise en profondeur. Mais allons-y et
vérifions-nous que tout fonctionne bien. Je pense que l'essentiel notre inclinaison maximale est réglé sur 15, donc nous ne devrions voir qu'une inclinaison de 15
degrés dans les deux cas. Et évidemment, nous
annulons simplement cela en fonction de
la vitesse de déplacement La vitesse de déplacement est toujours de 1 000,
ce qui, à mon avis, est parfaitement correct. Si cela semble un
peu plus lent, nous pourrons revenir et
augmenter ce La vitesse d'interp, je pense que nous voulons la ralentir
un peu. Je pense que nous allons le réduire à trois plutôt qu'à dix parce que notre
courbe de décroissance fonctionnera un peu différemment de ce
que nous
faisons avec F interp deux, puis le courant
cible et Alpha devraient tous être
définis au moment de l'exécution, donc ils devraient commencer à
zéro, ce qui est parfait Ensuite, nous l'utilisons
simplement ici. Cela devrait donc, je pense, fonctionner maintenant. Donc, si nous revenons, appuyez sur
Play. Oui, allons-y. Je pense que cela
semble différent, mais nous pouvons voir que c'est à
peu près pareil. Je crois que je préfère
son apparence. C'est beaucoup plus original, c'est juste un peu plus raffiné.
Donc c'est plutôt bien. Et comme je l'ai mentionné, c'est maintenant là que la
flexibilité entre en jeu. Si vous vouliez modifier
la vitesse, c'était peut-être parce que l'entrelacement était trop lent. Nous pouvons augmenter
ce chiffre. Nous allons donc revenir en mode jeu ici. Nous allons donc recommencer à
vous
remettre sur pied un peu
plus rapidement. Donc c'est bon. Et puis si vous vouliez,
comme je l'ai déjà mentionné, si vous n'êtes pas sûr de
ce que
fait quelque chose ou de la direction que doit prendre
une valeur, si vous la rendez vraiment drastique, apporter un changement vraiment important. Et vous pouvez voir
que c'est presque comme riposter
lorsque nous lâchons prise La dégradation se produit donc beaucoup plus rapidement et nous sommes en
train de riposter. Cela pourrait donc sembler un
peu plus agréable, en fait. Alors peut-être que je me suis trompé, peut-être qu'il aurait été
préférable de passer à une
valeur plus élevée plutôt qu'à une valeur
inférieure pour
ce test agréable et facile à tester, mais c'est l'essentiel. Essayez d'intégrer votre façon
de
penser à votre propre base de code. En façon
de
penser à votre propre base de code vous
facilitant les mises
à jour et les modifications
ultérieures, vous aurez
plus de chances d' affiner le jeu
et de l'améliorer S'il est vraiment
difficile de travailler sur votre projet, il beaucoup moins probable que
vous
souhaitiez le peaufiner. Consacrez ce temps à
améliorer le jeu. Il s'agit donc plutôt d'une question de design , à laquelle il est toujours
amusant d'
y penser. La dernière chose est l'inclinaison maximale. Donc, si nous prenons l'inclinaison maximale, si je fais quelque chose de beaucoup plus grand, comme 45 degrés juste pour montrer la différence que nous pouvons
obtenir, si nous ne flottons pas, vous pouvez voir que lorsque nous commençons à atteindre la vitesse maximale, nous atteignons cet angle d'inclinaison
maximal plus élevé. C'est donc ainsi que cela
entre en jeu. Je ne veux probablement pas qu'il
pivote autant, mais vous voudrez peut-être
augmenter d'environ 25 pour le rendre
plus visible visuellement. Mais l'essentiel que
nous avons obtenu par rapport à la
mise en œuvre précédente est, comme vous l'avez vu. Il ne s'agissait pas vraiment d'effectuer un calcul
spécifique pour atteindre un certain angle de rotation basé sur la
vitesse ou quoi que ce soit d'autre. Il s'agissait simplement d'aller le plus loin
possible dans un laps de temps
donné. Alors que maintenant, nous
avons un peu de contrôle. En fonction de notre vitesse actuelle, nous pouvons contrôler
exactement la vitesse de rotation. Ensuite, la chose la
plus importante à vérifier, c'est que je vais ajouter quelques commandes de console
pour me débarrasser des ennemis. Nous n'en avons pas besoin.
Continuez simplement à voler vers nous. Je vais passer en
mode jeu. Je vais me donner la commande stat FPS de la
console, afin que nous puissions voir que je
tourne à 120 images par seconde. Je me suis
directement réduit à 30. Encore une fois, nous devrions
voir que nous obtenons un
cadre beaucoup moins agréable à regarder, mais que nous
n'obtenons toujours qu'une rotation de 25 degrés, et nous l'atteignons
à ce que nous devrions espérons-le, voir dans un instant, à
peu près à la même vitesse. Donc, si je porte maintenant ce chiffre à 60, nous n'atteignons que
la même rotation, le même type d'inclinaison ou d'
inclinaison par roulis, désolé. Je le fais à peu près dans
le même laps de temps. Et ensuite, si nous passons à 120 ou même, nous allons
simplement le déplafonner Je dirais 600, donc je peux
obtenir environ 300 images par seconde. Cela semble plus fluide, mais les mouvements se produisent
à la même vitesse et la rotation
prend le même nombre d'images ou de secondes
pour y parvenir. Nous avons donc complètement résolu le
problème d'indépendance de la fréquence d'images que nous avions auparavant. Le mouvement, souvenez-vous,
n'était donc pas vraiment un problème, mais la rotation a
posé
un problème :
même si nous avons multiplié par quelques secondes à cause de cela, juste le type de logique utilisé par les fonctions F
inter, souvenez-vous que nous avons pu essentiellement
faire pivoter l'aile dans le sol
parce que la rotation
n'était pas bloquée Les différentes fréquences d'images l'
affectaient différemment. Nous avons donc complètement
résolu ce problème. Nous avons dû approfondir un
peu
plus certaines mathématiques, en utilisant la fonction
de
masquage
simplifiée, plus rudimentaire simplifiée Mais en prenant un
peu le temps avec notre propre code, nous avons maintenant résolu tout
un tas de problèmes. Vous trouverez probablement beaucoup de jeux,
car de nombreux
jeux sont publiés sur la
base d' exemples de
contenu, d'exemple, de code
de
produit, etc. C'est le test terminé.
Même vitesse de déplacement. Nous avons les mêmes limites
de rotation. Aucune aile ne perce
le sol. La formule exponentielle
est ce qui nous donne l'interprétation mathématiquement
correcte à n'importe quelle fréquence d'images J'espère qu'un
contenu plus approfondi comme celui-ci n'a pas complètement gelé votre cerveau et ne vous a pas empêché de suivre le rythme. les ai créés, l'
objectif des sujets était vraiment Lorsque je les ai créés, l'
objectif des sujets était vraiment d'essayer d'amener
les
gens à réfléchir davantage à leur base de code et ce qui se passe sous le capot
, au lieu de contenter de suivre le cours. J'espère que maintenant au
point où vous pouvez constater les avantages de ce que nous avons été. J'ai mentionné
dès le début Cela prend beaucoup
plus de temps que cela n'aurait pu le faire, et j'aurais pu simplement
supprimer une grande partie des informations triviales ou des informations qui auraient pu sembler
triviales, mais je pense que vous
auriez oublié une grande partie vous en êtes
maintenant au
point où vous pouvez constater
les avantages de ce que nous avons
été. J'ai mentionné
dès le début.
Cela prend beaucoup
plus de temps que cela n'aurait pu le faire,
et j'aurais pu simplement
supprimer une grande partie des
informations triviales ou des informations
qui auraient pu sembler
triviales,
mais je pense que vous
auriez oublié une grande partie des
potentiel d'apprentissage et compréhension
réelle de
ce que vous faites. L'objectif est d'espérer que vous pourrez regarder quelque chose comme ça, vous
éviter de
regarder deux
ou trois autres séries de didacticiels
ou de cours ou quoi que ce soit d'autre ou trois autres séries de didacticiels , car vous maîtrisez de plus
en plus les systèmes et vous corrigez plus
en des éléments qui existent même dans le
contenu pédagogique officiel d'Epic. J'espère donc que cela a de
la valeur. Donc, si vous vouliez vraiment
commencer à peaufiner votre projet dès maintenant, c'est là que vous
avez
probablement une
idée générale de ce que
nous allons faire. Nous avons organisé notre projet de manière assez rigide
et solide. Donc, si vous
voulez commencer à
expérimenter entre différents sujets, c'est là que vous devriez peut-être freiner un peu . Encore une fois, il ne
s'agit pas d'une course. Notre objectif n'est pas
de
terminer le projet le plus rapidement possible. Notre objectif est de vous faire partir, comprendre ce que
vous faites et de savoir
comment développer ce que
vous avez déjà appris. Alors, faites quelque chose de simple, même s'il s'agit simplement d'
entrer dans votre propre code, voir si vous pouvez maintenant commenter et décrire ce que votre
code vous fait pour
voir si vous pouvez maintenant commenter
et décrire ce que votre
code vous fait en utilisant de
bons commentaires ou catégoriser les variables Si vous avez remarqué que vous avez
cette longue liste de variables, et que vous pouvez trouver un moyen de l'
améliorer,
commencez par ajouter des catégories
à vos variables, choses
simples pour que
votre projet reste structuré, ordonné et facile à utiliser N'oubliez pas que l'objectif principal est que les
séquences contrôlent votre flux, en le rendant plus lisible, comme le code scripté normal ou
le code écrit Bons commentaires,
expliquez l'intention plutôt que de simplement
décrire la variable. Par exemple, vous pourriez
simplement avoir un commentaire disant interpolation alpha,
mais un bon commentaire serait calculer les valeurs d'
indépendance de la fréquence fonction de l'alpha d'interpolation, des
choses comme ça pour vous donner un descripteur, un coup d'œil sur ce que
vous faites Une fois cela fait,
le système de mouvement
est prêt pour la production. Nous avons un mouvement et une
rotation fluides et
contrôlés
indépendants de la fréquence d'images pour le joueur Il s'agit de la classe la plus lourde
et la plus complexe que nous ayons
à avoir dans le projet Ensuite, nous allons essayer de
faire apparaître des
ennemis de manière dynamique
pendant le jeu, plutôt que de simplement les
placer manuellement, ce qui
sera évidemment un
peu restrictif pour un jeu complet
19. 18 - EnemySpawner: Il est temps d'envisager d'automatiser l'apparition de
nos ennemis. Nous allons le construire de manière
flexible dès le départ. Cela fonctionnera pour les
ennemis dans un premier temps, mais nous allons le vérifier un peu
à l'avenir Cela fonctionnera
donc avec des objets
tels que des objets d'arrière-plan ou tout autre élément susceptible de
devoir apparaître au fil du temps. Plus besoin de
placer les ennemis manuellement, ce qui sera la
première étape importante. Donc, pour commencer,
nous allons accéder
à notre dossier Blueprint, et nous allons simplement le
créer dans une nouvelle structure
de dossiers Je vais donc appuyer sur
Ctrl Shift et N pour un nouveau dossier, appelé
celui-ci spawners Cliquez avec le bouton droit de la souris, nous allons passer
à la classe Blueprint, et nous voulons créer notre classe d'acteur standard pour
les bogues Comme je l'ai mentionné, il ne s'
agit que d'un conteneur. Il a une transformation, une
place dans le monde, puis nous pouvons y intégrer
notre logique. Nous allons donner à celle-ci le nom de base BP Underscore Spawner Donc, comme je l'ai mentionné,
planifiez un peu à l'avance. Nous n'allons pas préciser que ce sera réservé aux ennemis, et il se peut que d'
autres générateurs soient enfants
de cette classe
avec héritage À l'intérieur de cela, nous voulons
simplement accéder directement à notre graphique d'événements. Il n'y a rien à ajouter
visuellement pour représenter cela. Je pense que dans ce
cas, nous pouvons éviter que
l'acteur ne se chevauche, et la plupart des éléments ici
devraient être réactifs Nous ne devrions
donc pas
effectuer de vérifications et mises à jour en permanence
sur les événements, afin de pouvoir nous débarrasser de ces deux appels
de fonction Nous pouvons piloter notre logique
de base à partir d'une fonction personnalisée.
Je déplace juste ça. Nous allons créer une nouvelle
fonction ici, que j'appellerai
spawn actor. Encore une fois, tout ce que
nous faisons au fur
et à mesure de notre planification vise à
rester très générique. Nous ne disons pas faire apparaître une pièce de
fond, faire
apparaître un ramassage, faire apparaître un Tout ce que nous devons transmettre
est un argument indiquant le type d'acteur
que nous voulons créer, et nous aurons probablement besoin d'
une rotation aléatoire, d'un décalage,
d'un emplacement, etc. Nous pouvons le rendre
agréable et générique et tout rendre
très réutilisable. Donc, j'essaie toujours de planifier à l'avance. N'oubliez pas de penser paresseux, de
planifier le programme une fois et de l'utiliser autant de
fois que possible. À l'intérieur de cette fonction, nous
allons utiliser l'épingle d'exécution, et nous avons en fait une
fonction intégrée à Unreal, nommée spawn actor from class Lorsque nous utilisons cette fonction, la principale chose que nous voulons, comme je l'ai mentionné,
est une transformation, donc où nous voulons que
cela apparaisse et plus précisément dans quel type de
classe nous voulons apparaître Donc, pour le moment, cela pourrait
être notre ennemi, mais encore une fois, ce
serait trop précis. Donc, si nous surlignons et
survolons l'épingle violette ici, nous pouvons voir qu'il s'
agit simplement d'une
référence spécifique au type d'acteur Ces épingles violettes sont donc les
références de classe elles-mêmes, non une instance au monde. Lorsque nous avons ces épingles bleues, il
s'agit d'un exemple réel
qui existe dans le monde. Nous pouvons en quelque sorte considérer les épingles
violettes comme une référence à l'emplacement à l'intérieur
de notre structure de dossiers. Nous allons donc utiliser
ce typage générique. Nous allons
partir de là et nous allons réellement le promouvoir
en tant que variable. Nous allons donner à celui-ci le
nom du type d'acteur. Utilisez-le maintenant
que nous pouvons n'importe quel type d'
acteur dans notre projet, qu'
il s'agisse d'un
ennemi, d'un pick-up,
d'une pièce de fond. Lorsque nous les
ajoutons, tout ce que nous voulions, nous pouvons maintenant demander à cette fonction de le faire apparaître à un moment donné Les principaux éléments que nous
allons vouloir exposer
sont les détails de la transformation du spawn Donc, si nous écrivons,
cliquez dessus, nous
diviserons la structure pi. Nous allons laisser l'échelle de
transformation du spawn à 11 et un En général, nous essayons
de ne pas les remplacer. Si tout a été correctement
configuré, comme dans le cas de ce projet, tous
les actifs doivent être à la
bonne échelle pour commencer. Nous allons donc conserver cela
et supposer simplement que les actifs sont importés
et fonctionnent comme prévu. Vous avez la possibilité de
randomiser ou de décaler
la rotation, mais je vais rester claire et nette pour le moment, et nous pourrons toujours revenir
et retravailler cela Ce que je vais faire à la place,
c'est cliquer avec le bouton droit de la souris et rechercher Get
actor rotation. La raison en est que cela signifie que nous pouvons le brancher
directement. Et quel que soit l'endroit où nous faisons
pivoter notre
générateur, nous avons le contrôle
total de l'éditeur Il s'agit
donc plutôt d'
un outil d'édition Si je veux que cela fasse
apparaître des éléments latéralement, je dois juste me rappeler de faire pivoter le alternative serait
de l'exposer à une variable et de
brancher manuellement la rotation, mais je trouve que cela peut
être une bonne façon de travailler. C'est juste un peu
plus intuitif pour moi, tant que
ce n'est pas
trop restrictif, et je pense que dans ce
cas, tout devrait bien se passer. Pour la localisation, nous allons partir
d' ici et
ajouter une épingle positive. Celui-ci peut nécessiter un
peu de randomisation,
un peu de variance et de
décalage fournis Si nous cliquons avec le bouton droit de la souris, nous pouvons
rechercher l'emplacement de l'acteur G. Encore une fois,
nous allons utiliser propriétés générales de
l'
endroit où se trouve le générateur, ce sera
donc notre
point de départ de base Maintenant, pour ce type de jeu,
comme nous savons que nous ne partons que du
haut vers le bas, nous n'avons pas besoin de
randomisation sur le Z, et nous voulons probablement faire tout notre
apparition hors écran, ce qui signifie que nous n'aurons pas non
plus besoin randomisation sur l'axe X. Donc, ce que nous pourrions faire, c'est
cliquer avec le bouton droit sur cette deuxième épingle vectorielle
et diviser la structure. Nous allons utiliser notre épingle
Y juste ici, et nous voulons utiliser le
nœud sélectionné que nous avons vu précédemment. Nous ne voulons pas sélectionner float. Nous voulons que celui-ci soit ici
avec une icône unique. Cela nous donne le joker
que nous avons utilisé précédemment. Nous allons changer cela en booléen, donc nous allons soit le
rendre aléatoire, soit non, et je vais promouvoir l'index
ici en une nouvelle variable, et nous appellerons
celle-ci add Encore une fois, n'oubliez pas de mettre
un B en minuscule. Si nous décidons
d'ajouter un décalage aléatoire, nous voulons fournir une sorte de valeur flottante
dans une plage Encore une fois, nous avons
vu comment procéder Nous ne faisons
donc que nous baser sur les fonctionnalités
et les approches que nous avons déjà
adoptées par le passé Donc, si cela est vrai, si nous
ajoutons un décalage aléatoire, nous allons tirer à partir d'ici
et utiliser cette fonction de
plage flottante aléatoire que
nous avons déjà vue. Et à partir de là, nous
voulons juste une distance, donc une distance latérale minimale et maximale
que nous pouvons appliquer Donc, si nous obtenons notre valeur flottante
maximale ici, nous la
transformerons simplement en variable, et nous donnerons simplement à celle-ci
le nom de distance de décalage. Le minimum, comme
nous l'avons déjà vu, avec des vitesses et d'
autres choses de ce genre, sera
simplement l'
inverse négatif Nous pouvons
donc contrôler la traînée
sur la distance de décalage, multiplier par moins un, puis inscrire le
résultat ici. Donc, si nous fixons une distance
de 100 unités, et que nous
voulons que cela se produise de chaque côté du centre
de l'écran, nous placerons cet
acteur générateur au centre
de l'écran, en insérant la valeur 100
dans la distance de décalage Cela signifie qu'il peut le générer
soit -100, soit 100
positif, soit une
valeur Si nous décidons de ne pas exposer la variable et que
le décalage aléatoire n'est pas activé, nous
allons simplement ajouter false. Nous allons donc ajouter zéro
à notre transformation globale, ce qui signifie que l'acteur apparaîtra
exactement là où nous l'avons placé est donc relativement simple, mais cela reste une sorte d'outil de développement, nous pouvons nous appuyer
si nous avons besoin d'une plus grande complexité, mais cela nous donne une certaine flexibilité et de la variation dans notre projet, ce qui rendra
généralement les choses plus intéressantes
et amusantes à jouer. Ce que je n'ai pas encore montré,
et je tiens à vous le présenter ici parce que nous sommes en quelque sorte
un développeur très rudimentaire C'est quelque chose vraiment utile dans Unreal D'autres moteurs font des choses similaires, ce qui permet aux
utilisateurs de voir les variables en dehors
de la classe. À l'heure actuelle,
par exemple, si nous saisissons l'une de nos classes de générateur et que nous
la publions simplement dans le monde, assurant que nous avons tout
compilé et enregistré, nous pouvons voir ici que
les objets sélectionnés, aucune des
variables que nous
venons de créer n'est
réellement exposée Je ne pourrais pas
entrer manuellement par instance. Donc, si nous en avions trois
ou quatre, nous ne serions pas en mesure de
choisir que celui-ci avait une certaine randomisation et
une distance unique, et que celui-ci n'avait aucune
randomisation, par exemple Nous n'avons actuellement qu'un seul
endroit où nous pouvons changer cela, et c'est juste
ici dans le graphique. Donc, soit il obtiendrait ce
booléen, soit il le désactiverait, puis il l'activerait ou le
désactiverait pour tous Et de même, pour la distance. Le moyen
le plus utile de contourner cela est d'utiliser ces icônes ici Vous ne les avez peut-être pas encore
touchés, mais si nous cliquons dessus, une petite icône
en forme d'œil apparaît. Par défaut, ils commencent à être fermés,
et nous pouvons ouvrir l'œil. Dans d'autres langues,
cela s'appelle rendre quelque chose public. Il est exposé à
d'autres classes et lisible et inscriptible
en dehors de cette seule classe À partir d'un plan irréel,
cela rend simplement la variable
modifiable essentiellement en dehors de la Donc, si nous revenons dans notre point de vue avec les mêmes
objets sélectionnés, vous pouvez voir que dans
le menu déroulant par défaut, nous avons accès au type d'acteur que nous
voulons voir apparaître C'est donc là que nous
pourrions commencer à faire des choses comme cela pourrait être
un générateur d'ennemis. Nous n'allons pas le faire, mais cela pourrait être
un générateur de joueurs. Nous avons donc déjà
une certaine flexibilité quant à ce qu'ils
vont générer. Et puis, comme les ennemis voudraient
peut-être être plus aléatoires,
nous pourrions activer cette
option pour qu'elle voudraient
peut-être être plus aléatoires, soit vraie afin d'
ajouter un décalage aléatoire
dans les deux sens, et nous pourrions régler ce décalage de manière
à ce qu'il soit, comme je
l'ai dit, peut-être 100 unités à peut-être 100 unités à gauche et à
droite du générateur. Comme vous l'avez vu, ce n'est pas une configuration très complexe, mais nous disposons déjà d'une certaine flexibilité et
d'
une certaine liberté dans la façon
dont nous l'utilisons. Donc, pour le moment, si
nous devions l'ajouter au début du jeu et le
faire appeler une
seule fois, un ennemi ne
représenterait pas un grand
défi pour notre joueur. Ce que nous voulons faire, c'est ajouter un
peu de frai continu. Nous allons éviter d'
utiliser des éléments tels que les délais et les boucles, car cela devient
compliqué et rigide. Vous avez peut-être déjà vu
quelque chose comme ça Au début du jeu, encore une fois, je veux simplement visualiser certaines
des choses que j'ai vues
dans de nombreux projets. Vous avez donc peut-être quelque chose comme nous viendrons pour la première fois et nous créerons un acteur une fois.
Nous ajouterons ensuite un délai. Un délai n'est donc qu'une
sorte de processus d'attente chronométré. Nous allons attendre,
disons, 3 secondes. Avant de passer à la prochaine étape, nous allons réapparaître l'acteur. Et vous serez peut-être
tenté de venir ici, et peut-être qu'après chaque
fois que cela sera fait, essayez de trouver un moyen de vous souvenir
de vous-même. Ça va devenir compliqué. Vous finissez par voir des
gens faire des choses comme ça, nous allons
tourner en arrière-plan, et vous vous retrouvez avec
cette boucle infinie où les gens disent qu'une
fois que nous l'avons créé, nous allons attendre
encore 3 secondes
et appeler à nouveau l'acteur du spawn Nous allons donc éviter
ce code de style débutant. Ce que nous voulons utiliser à la place,
c'est ce que l'on appelle des minuteries. Ils sont beaucoup plus propres
et nous permettent de mieux contrôler si
et quand ils sont appelés. Donc, après le début de la partie, l'épingle d'exécution, nous voulons trouver une fonction appelée I valid. Nous voulons cette option avec le point d'
interrogation en bas. agit de vérifier
si un autre objet ou acteur est actuellement
valide, c'est-à-dire s'il existe et
s'il n'est pas envoyé à collecte des
ordures pour être nettoyé s'il est détruit
ou quelque chose comme ça ? À partir de l'objet d'entrée, donc de l'objet que nous
voulons vérifier s'il existe, nous allons le retirer d'ici et utiliser cette fonction intégrée, le pion get player Ce n'est donc, encore une fois, qu'une
de ces choses à prendre en compte. Cela se produit dans
de nombreux
jeux pour nouveaux développeurs où vous avez
créé un jeu comme celui-ci et où les ennemis ont
détruit le joueur. Mais même lorsque vous regardez
le jeu à l'écran ou que
vous
attendez simplement le générique ou
quoi qu'il arrive ensuite,
vous pouvez voir l'
ennemi apparaître
ou tirer sur vous
attendez simplement le générique ou quoi qu'il arrive ensuite, vous pouvez voir l'
ennemi apparaître le joueur, sorte de chien entassé
sur un cadavre Cela a juste l'air un
peu intense, et c'est généralement parce qu'il n'
y a pas de mise en échec en milieu de partie pour voir si les joueurs
sont réellement considérés comme morts ou s'ils
ne sont plus disponibles Ce que nous allons faire, c'est que si le joueur a été
retiré du jeu, il n'est plus nécessaire que des ennemis apparaissent.
Nous allons donc arrêter Si c'est vrai, donc si le
lecteur est toujours valide, nous allons appeler
une fonction ici, qui est le chronomètre réglé
par nom de fonction. Nous voulons cette option ici, et la première chose que nous pouvons
renseigner est l'heure ici. Voici donc le temps que nous
allons attendre jusqu'à cette fonction que nous allons
créer dans un instant soit appelée. Donc, pour l'heure elle-même,
nous pouvons tirer à partir d'ici, et nous pouvons rechercher un autre flottant
aléatoire dans la plage. Et une petite astuce, qui peut être très utile lorsque
vous ne cherchez pas simplement à avoir le minimum et le maximum ou simplement à être
l'inverse l'un de l'autre. Nous pouvons utiliser ce que l'
on appelle un vecteur deux D. Donc, si nous créons
une nouvelle variable, nous la nommerons intervalles d'
apparition Et nous allons le
déposer vers le bas, et nous allons rechercher
ici plutôt qu'un vecteur, qui est une valeur
flottante à trois points, nous allons également
rechercher un vecteur. Nous voulons
ici le vecteur deux D. Et si nous appuyons sur Compiler, nous pouvons voir qu'il ne s'agit que deux
valeurs à virgule flottante, où la valeur X sera notre minimum et la
valeur Y sera un maximum. Nous pourrions donc régler ce paramètre sur
un minimum de 3 secondes avant que
quelque chose n'apparaisse et un maximum de six Et nous pourrons revenir
et peaufiner cela plus tard. Nous pouvons contrôler le
faire glisser dans le graphique, cliquer avec le bouton
droit sur l'épingle de structure, diviser l'
épingle de structure ici, et nous pouvons dire minimum, maximum. C'est donc une bonne
façon propre et ordonnée de configurer la fonction de
chronométrage Pour le nom de la fonction, nous avons
notre acteur de génération ici. Une chose que j'ai toujours
tendance à faire, encore une fois, en partie parce que je suis paresseux et que je
ne veux pas taper des choses, mais aussi pour éviter de faire des fautes d'
orthographe ou de frappe. Je vais appuyer sur F
deux pour le renommer, appuyer
sur Ctrl N pour le
copier, puis appuyer sur le contrôle NV ici pour le coller afin assurer que nous
avons la même orthographe, la même majuscule,
en évitant toute erreur dans
le nom, car il distingue
les majuscules et
minuscules et doit être
orthographié Nous n'allons pas le
mettre en boucle, mais si vous aviez
une fonction dans laquelle vous voulez qu'il
continue à fonctionner en permanence, vous pourriez le mettre en boucle,
et il
continuerait simplement à tourner en rond et à l'appeler
essentiellement Vouloir un peu
plus de contrôle manuel. Je vais m'assurer que
ce n'est pas coché. Et ce que nous pouvons faire,
c'est récupérer tout ce code, y compris
celui qui est valide, car si vous y réfléchissez, lorsque nous commençons à jouer, il n'y a aucune raison pour
que le pion du joueur ne
soit pas réellement un objet valide Il
existera toujours lorsque nous appuierons sur Play. Donc, ce que nous allons
faire à la place, c'est cliquer avec le bouton
droit sur l'un
de ces nœuds, et nous
allons le réduire en fonction. Nous allons lui donner le nom
de call spawn Aca timer. Nous sommes donc en train
de brouiller un peu la logique ici Encore une fois, les étapes sont
un peu plus claires et faciles à comprendre au fur et à mesure que
nous parcourons notre code. Et la façon dont nous voulons
réellement gérer cela est que nous
allons probablement vouloir créer
des ennemis immédiatement. Ainsi, plutôt que d'apparaître sur la
base d'un chronomètre, nous pouvons tout d'abord contourner cela Nous allons donc commencer par créer
un acteur directement. Nous allons le mettre sur
notre épingle d'exécution. Et encore une fois, il suffit de
penser à l' ordre logique de notre code. Nous pouvons donc toujours
retravailler des choses comme. Nous allons commencer à
jouer, et nous allons
créer un acteur tout Ce que ça va faire, ça
va arriver ici. Nous allons ensuite choisir notre type d'acteur si
nous n'avons qu'un set, choisir un emplacement et un décalage, s'il y a un décalage
à appliquer, sélectionner la rotation
et l'afficher en un point Et après cela,
c'est ici que nous pouvons commencer à faire une boucle presque
automatique Donc, si nous voulions que
cela continue, nous pourrions utiliser notre principal chronomètre
d'acteur d'apparition, le
déposer juste ici Et ce que cela va
faire maintenant, c'est que cela va entrer, et c'est plus important
ici parce qu'au moment de l'exécution, c'est là
que
le
joueur a peut-être été détruit après le premier ou le deuxième spawn que
le
joueur a peut-être été détruit après le premier ou le Donc, celui-ci que je
fais est un chèque valide, un chèque vraiment simple et
bon marché pour m'
assurer que le joueur
est toujours dans le jeu. Et si
c'est le cas,
nous allons l'autoriser à générer un autre acteur, donc en utilisant la
fonction spawn actor, en gros, appelant à nouveau cette
fonction après une période ou un
intervalle de temps défini Maintenant, c'est quelque chose que
j'aime bien faire, et c'est totalement facultatif. Mais comme lorsque nous utilisons la set time by function
name, nous ne pouvons pas double-cliquer trouver ce qu'elle appelle
réellement, nous devons parcourir
notre liste de fonctions et trouver le nom qui correspond. Ce que j'aime bien faire, c'est
de placer la fonction ici et de la déposer sous le chronomètre
réglé par nom de fonction. Cela signifie donc que si je
regarde mon
code dans le futur, si j'en arrive là
et que je réalise qu'il faut
corriger ou modifier quelque chose
dans cette fonction ici, je peux simplement
double-cliquer sur ce nœud, et cela m'amènera à ce
que cette fonction appelle. n'est donc qu'un tout
petit conseil, mais je trouve que cela peut
être très utile, surtout lorsque
vous revenez pour modifier des choses. Si cela ne suffisait
pas, nous devions supprimer
quelque chose, juste une bonne façon de naviguer Mais c'est à peu près
tout ce dont nous avions besoin. C'est un bon type
de générateur auto-encapsulé autocontrôlé qui offre une
certaine flexibilité quant
aux certaine flexibilité quant différents types
d'acteurs dans lesquels nous pouvons apparaître, à l'
endroit où ils vont apparaître et
à la question de savoir si et
autocontrôlé qui offre une
certaine flexibilité quant
aux différents types
d'acteurs dans lesquels nous pouvons apparaître, à l'
endroit où ils vont apparaître et
à la question de savoir si
une randomisation est appliquée. Nous pourrions également descendre et exposer les
intervalles d'apparition. Nous pourrions donc avoir chaque acteur
différent,
chaque générateur différent, avec des intervalles temporels
différents quant au
moment où les choses devraient le faire apparaître avec des intervalles temporels
différents quant au
moment où les choses devraient le moment où les choses devraient Assurez-vous donc que nous
compilons et sauvegardons. Une chose que je veux
ajouter avant de commencer à tester cela, c'est que si nous allons
dans la section des composants, nous allons ajouter quelque chose
ici, je vais
rechercher le composant flèche. Il y a donc en fait
un composant que nous pouvons utiliser qui
n'est qu'une flèche visuelle. Nous pouvons changer la
couleur si vous le
souhaitez
pour différentes raisons. Mais l'essentiel est que,
encore une fois, en un coup d'œil, cela nous permettra simplement de
savoir quelle est la voie à suivre, sorte que c'est toujours par défaut de pointer
vers l' Donc, si nous appuyons sur compiler et sauvegarder pour revenir
au niveau principal, nous pouvons voir, en fait, qu'
ici, les ennemis feront face dans le mauvais sens. Je vais donc me
débarrasser de certains d'entre eux, nous allons juste
les tester un par un. Assurez-vous que cela ne
chevauche pas le sol, sinon les ennemis
ne pourront pas bouger Ensuite, nous pouvons simplement le faire pivoter
de 180 degrés sur le Z. Et vous pouvez voir
que cela pointe maintenant vers le point de départ de notre joueur, ce
qui signifie que si nous lui attribuons notre classe ennemie, nous pourrions lui attribuer une
distance aléatoire de chaque côté, et les intervalles d'apparition sont
bons Nous pouvons appuyer sur Play, et cela en fera apparaître
un immédiatement Ensuite, dans les trois à 6 secondes, nous devrions en voir un autre
apparaître, et c'est parti Notre
acteur d'apparition aléatoire fonctionne donc correctement. En fournissant la rotation
que j'ai mentionnée, nous pouvons voir exactement où cela
va apparaître et dans quelle
direction vous allez faire face Le principal problème que nous
avons maintenant est, bien sûr, que nous pouvons les voir apparaître Nous voulons
donc reculer
légèrement pour qu'ils
apparaissent hors écran Ils feront cette animation,
puis ils apparaîtront
avec cet intervalle donné Si vous vouliez obtenir une position
légèrement différente, ou si vous en vouliez un plus grand nombre, vous pouvez l'échelonner de cette façon, afin que nous puissions avoir
plusieurs générateurs. Vous pourriez fournir différentes distances de
décalage, différents
intervalles d'apparition, et vous pourriez les échelonner un peu de
cette façon Encore une fois, pour rendre le gameplay et l'interaction
encore plus intéressants. Je pense que pour le moment, nous
pourrions probablement nous en tirer avec un seul générateur
pour nos ennemis Donc, si nous découvrons
ou décidons qu'il
n'y en a pas assez
au moment de l'exécution, nous pouvons revenir et en
ajouter d'autres ou modifier ces intervalles d'
apparition. donc vous donner encore un peu
d'expérimentation Vous
pouvez donc vous donner encore un peu
d'expérimentation
ou de devoirs. Vous pouvez faire des
choses simples ici, comme dupliquer
le générateur et essayer
différentes configurations, comme je Essayez différents intervalles d'apparition, différentes distances de décalage, activez ou désactivez
la randomisation Et idéalement, si vous avez
dépassé
le cadre du contenu jusqu'à présent et créé vos propres
types d'ennemis, vous pourriez avoir des ennemis qui se déplacent
uniquement vers l'avant, vers l'
arrière ou d'un côté à l'autre,
quel que soit le cas Essayez peut-être d'ajouter des générateurs
différents pour différents
ennemis, juste pour voir comment vous pouvez
facilement utiliser ce système quelque peu
flexible Et c'est l'essentiel ici. Nous étudions et
réfléchissons à la manière dont nous
concevons notre système. J'aurais pu créer
une classe d'acteur spécialement pour faire
apparaître uniquement des ennemis. Nous aurions pu entrer dans
la classe et
coder en dur la logique ici pour faire apparaître
spécifiquement des ennemis. Nous aurions alors dû faire
la même chose pour un type d'ennemi
ou un arrière-plan
différent pour y arriver. Essentiellement, encore une fois, beaucoup de
doublons, plus de choses à mal tourner
et plus de bogues à corriger. Avec cette
approche, nous pouvons réutiliser ultérieurement pour les
arrière-plans, différents types d'ennemis, de boss, pour
tout ce que vous vouliez en
faire.
20. 19 - ProjectileBase: Passons maintenant à
l'une des parties les plus amusantes il est temps d'
ajouter de la puissance de feu. Ce sera à nouveau une classe de
projectiles qui fonctionnera pour les
joueurs et les ennemis. Comme par le passé, nous allons réfléchir
à l'avenir plus tôt, en le rendant personnalisable en
fonction des couleurs et des dommages, concentrant sur ce
design intelligent dès le départ, évitant les doublons ultérieurement. Nous pouvons donc laisser le
soulignement BP Sponerbse
si vous êtes Nous allons accéder à
notre dossier de plans. Je vais retourner dans le dossier principal des plans ici Nous allons créer un nouveau dossier,
donc contrôlez le changement de direction dans N, et nous
l'appellerons projectiles À l'heure actuelle, il y a de fortes chances
que ce projet n'
aboutisse qu'à
un seul type de projectile Comme je l'ai mentionné,
nous allons essayer de rendre cela aussi flexible
que possible. Mais encore une fois, dans les
versions plus avancées ou à lumière clignotante de ce projet, vous aurez peut-être besoin de choses
comme des missiles domestiques, des lasers, des fusils de chasse, des
explosions d'obus, se peut donc que nous
ne soyons pas toujours en mesure de réutiliser le
projectile dont nous disposons Nous allons donc toujours partir
du principe que nous souhaiterons peut-être poursuivre sur cette
lancée plus tard, même si ce n'est pas le cas pour
ce petit projet. Nous allons donc cliquer à
nouveau avec
le bouton droit de la souris ici dans le nouveau dossier. Nous allons créer une nouvelle classe de
blueprint. Encore une fois, il s'
agira d'un acteur simple, et nous lui donnerons
le nom de projectile
BP Underscore Nous ajouterons la
base de mots à la fin au cas où
nous voudrions l'étendre un peu plus tard avec des versions pour enfants
similaires mais légèrement
uniques. Dans notre nouvelle
classe d'acteurs, nous voulons tout d'
abord créer
un nouveau maillage statique. Nous allons donc
ajouter un nouveau composant, maillage
statique, et nous pouvons le
faire glisser directement sur la racine de scène
par défaut. Encore une fois, en faire
le nouveau composant racine. Une fois le maillage statique sélectionné, nous allons passer
sur le côté droit. J'ai fourni ici le projectile SM
Underscore, nous allons
donc sélectionner celui-ci Et ce sera notre
visuel du projectile. Sur le côté gauche, nous
revenons aux composants. Nous pouvons
à nouveau supprimer cette ligne, et nous pouvons voir ici si nous cherchons le
mot « mouvement du projectile Nous avons notre composant de
mouvement des projectiles. Unreal dispose d'un système intégré pour cela afin de simplifier
une partie de la configuration Maintenant, nous n'allons pas vraiment
l'utiliser car, encore une fois, c'est bien d'avoir le
contrôle total de notre propre logique. Je vais juste
vous montrer comment cela fonctionne. Donc, si nous appuyons sur Compiler et
enregistrer avec cet ensemble activé, nous voulons passer à
droite dans le panneau Détails avec le mouvement du
projectile sélectionné Nous voulons ramener l'échelle de
gravité à zéro. Sinon, nous allons avoir une
certaine baisse au fil du temps. Et nous allons lui donner la vitesse de déplacement
initiale de 300. Si nous entrons, appuyons sur compiler, nous allons accéder
à notre fenêtre d'affichage et nous allons simplement le déposer
dans le niveau Maintenant, je ne vais pas appuyer sur Play parce que nous voulons vraiment
voir cela bouger. Mais la façon dont cela
fonctionne, c'est que nous pouvons appuyer sur simuler, et nous verrons que cela
se déclenche à environ 300 unités. Donc ça marche. C'est agréable
et simple à configurer. Mais comme je l'ai mentionné, il y a une raison pour laquelle nous
ne l'utiliserons pas. Et cela s'explique principalement par le
fait que le composant inclut la réplication réseau, des éléments dont nous n'avons
vraiment pas besoin. Encore une fois,
beaucoup de
calculs physiques ne sont pas nécessaires pour ce que
nous allons faire, à la
gestion de la gravité, que
nous avons explicitement désactivée,
mais qui existent toujours. C'est aussi un
peu rigide. Nous voulions ajouter des éléments tels que
l'accélération, le fil du temps, homing, tout cela est en quelque sorte lié à l'implémentation
d' Epix Pendant longtemps, je pense que le homing n'a pas
fonctionné correctement. Il existe des solutions que
vous pouvez imposer, et l'accélération ne fonctionne
certainement pas. C'est très difficile
si vous voulez
mettre l'accent sur la vitesse et
donner à quelque chose un aspect un peu caricatural, passer
de 100 unités de vitesse,
puis monter à 600 au fil du temps,
puis redescendre Il est très difficile de contrôler la vitesse de ces
composants lors de l'exécution. Essentiellement, si vous le faites apparaître en déplaçant 100 unités,
ce sera l'accélération, la valeur de
la vitesse
de ce projectile
jusqu'à ce que vous
le réinitialisiez ou que vous le détruisiez C'est pour cette raison que nous
allons nous débarrasser de cet acteur et pour
cette seule raison. Montrez plutôt comment
nous pouvons implémenter une logique très similaire et beaucoup
plus simpliste pour notre propre mouvement de projectile Donc, juste pour vous faire savoir
que je suis conscient que cela existe, nous allons le
supprimer. Nous allons nous débarrasser
de ce composant, et nous allons essentiellement
déployer notre propre version personnalisée spécifiquement pour faire ce dont nous avons besoin dans notre projet. Donc, si nous passons
au graphique des événements, nous allons suivre
la norme ici. Nous allons nous débarrasser de
notre Loi pour commencer à se chevaucher. Et souvenez-vous de ce que j'ai
déjà dit, nous pouvons utiliser venti, et c'est encore une fois l'un de
ces cas, où nous voulons que cela évolue
doucement au fil temps avec une logique de
mouvement simple C'est donc Eventk que
nous voulons que cela fonctionne. Intéressez-vous et
voudriez consulter le code source
du moteur Unreal C'est même ainsi
que fonctionne le composant
de
mouvement des projectiles fonctionne le composant
de
mouvement Cela fonctionne sur Venti pour
garder les choses constamment à jour, indépendant
du framework
et agréable et fluide La logique dont nous avons besoin pour
cela est très simple. Donc, si nous tirons
notre épingle d'exécution, nous allons rechercher
le décalage local d'ajout d'un acteur. Cela garantit que
l'emplacement
du projectile se déplacera vers l'avant par rapport à
sa propre rotation Donc, c'est une autre
chose vraiment intéressante, c'est que nous
devons simplement nous connecter de quelle manière faire face
lorsque nous commençons à le générer Et en utilisant cette fonctionnalité, il garantit qu'il
se déplacera toujours dans la bonne direction. Nous allons diviser la
structure ici, uniquement parce que nous savons
que nous voulons qu'elle
se déplace uniquement sur l'axe X, vers l'
avant et vers l'arrière Mais vous pourriez certainement
revenir et faire quelques mouvements latéraux
si vous vouliez en faire
un projectile autodirecteur ou
quelque chose Tout cela provient du Delta X. Nous allons en faire une
variable afin d'obtenir un flotteur, et nous appellerons cela
une vitesse de déplacement unique. Appuyez sur compiler, et nous lui
donnerons une valeur par défaut
d' environ 2000
unités, ou peut-être 2 500. Nous pouvons revenir et
changer cela plus tard si cela
s'avère trop rapide. Alors, bien sûr, il
suffit de venir ici. Nous allons prendre notre vitesse de déplacement. Nous allons le multiplier
par nos secondes Delta, faisant comme pour le mouvement de l'
avion, tout est indépendant de la
fréquence d'images, puis nous ajouterons le résultat ici. Et c'est à peu près tout. Nous avons un mouvement de
projectile indépendant de la fréquence d'images par seconde, qui se déplace dans la
direction dans laquelle il est apparu, ce qui le rend agréable et
facile à utiliser pour le joueur ou pour l'ennemi, quelle que soit la
manière dont le
plan initial fait face à une implémentation simple et
rapide, mais il est implémentation simple et
rapide, mais il est personnalisable si nous
devions l'étendre ultérieurement Ainsi, dans les rubriques précédentes
sur l'observation des ennemis, j'ai indiqué que le
projectile
gérerait son propre système de collision
et de dégâts, et c'est exactement ce que
nous allons implémenter maintenant Une fois le
maillage statique sélectionné, nous allons passer aux préréglages
de collision Et nous voulons changer le
préréglage ici, de « bloquer tout » à « superposition » ou « dynamique ».
Nous allons donc le supprimer. Nous trouverons le
chevauchement ou la dynamique, et nous verrons quel en est l'effet
sur les préréglages de collision La raison principale est
que le projectile ne doit pas
bousculer physiquement les objets Cela peut aboutir à des situations
où les choses semblent compliquées, où tout ce que nous
devons vraiment faire est savoir
qu'ils ont
touché quelque chose Et si vous commencez à
être
repoussé ou si les ennemis commencent à se déplacer avec des projectiles, cela peut sembler un peu
étrange au joueur Si nous voulons ajouter
Knock Backck en tant que fonctionnalité, c'est parfaitement bien, mais nous le
ferons par le biais du code
afin d'en avoir le contrôle total En général, lorsque deux
éléments
se chevauchent physiquement avec la fonction de
blocage, cela ne ressemble pas à un
renversement de toute façon. On dirait que deux objets
se battent pour habiter
le même espace, et ce n'est tout simplement pas
agréable à regarder Tout ce dont nous avons besoin, le projectile est de détecter et de toucher quelque chose, et lorsque cela se produit, d'
infliger des dégâts Pas de simulation physique
ou d'autres choses du genre. Nous ferons la même chose
qu'avant. Nous allons faire
défiler la page vers le bas. Nous trouverons la section des événements, et nous voulons ajouter
l'appel de
fonction on component to begin overlap ici. Ainsi, lorsque cela chevauche
autre chose , comme nous l'avons fait auparavant, nous devons obtenir
certaines informations et voir si des dommages
seront infligés. Nous allons prendre l'acteur ici,
donc l'autre acteur, encore une
fois, comme avant, nous allons le
promouvoir au rang de variable, et nous appellerons cela
un chevauchement d'acteur. Et c'est pour la même
raison que pour les ennemis. Nous allons vouloir
vérifier certaines informations par
rapport à cela. Nous ne voulons pas continuer à
tirer parti de cette épingle, nous allons
donc utiliser une variable que
nous avons stockée à titre de référence. Donc, la première chose
que je pense que nous voulons prendre en compte c'est si ce que nous avons superposé est considéré comme celui qui est sponda,
donc l'acteur propriétaire Ainsi, par exemple, si
l'ennemi tire, ce qui est considéré comme
un projectile ennemi, nous ne voulons pas qu'il inflige des
dégâts à l'avion de cet ennemi De même, si le
joueur tire un projectile,
celui-ci est considéré comme le projectile de la
couche Nous ne voulons évidemment
pas nous blesser. Donc, la première chose que
nous pouvons faire est faire en sorte que notre acteur se chevauche, et nous vérifierons à
nouveau si cela
correspond à un
type d'acteur spécifique Donc, si cela est égal à, et que nous pouvons rechercher
une autre variable de
suivi intégrée fournie et suivie par le moteur Unreal par défaut, nous pouvons
aussi bien l'
utiliser Nous allons
rechercher le propriétaire de G. Ainsi, chaque fois que quelque chose
apparaît dans le monde, on lui donne immédiatement le
concept de ce qui le possède, ce qui l'a engendré.
Nous pouvons donc l'utiliser. Nous pouvons donc dire que si
l'objet que nous avons superposé est également le propriétaire, nous allons simplement éviter d'infliger
des dégâts La principale raison en est
que nous pouvons choisir notre point d'apparition, peut-être directement au
milieu de l'avion Il va donc y avoir
un très bref moment où le projectile
généré par le joueur se
trouvera à l'intérieur de
l'avion pendant un Si tel est le cas, alors
nous allons simplement
ignorer le premier
chevauchement, nous ne ferons rien. Nous allons donc extraire une branche ici, qui est notre flux conditionnel, afin de vérifier si nous devons faire quelque chose en
fonction de ce résultat. Et si c'est vrai, alors nous pouvons simplement ignorer que nous
ne ferons rien du tout. Maintenant, la façon dont j'
aime généralement les lire,
c'est que j'aime faire les choses en dehors des troupes dans la mesure du possible Il s'agit d'une préférence personnelle. Encore une fois, les différents programmeurs
auront toujours des préférences
différentes quant à la
façon dont ils abordent les choses Mais je préférerais que
mon code finalisé, celui qui permet d'exécuter les fonctionnalités principales,
se réalise. Donc, ce que je vais
faire, c'est faire un paiement légèrement différent abord,
je voulais juste montrer la méthode la plus
lisible,
mais avec une toute petite modification, nous pouvons réellement
rechercher ce n'est pas égal à. Ainsi, un point d'exclamation
et un point d'exclamation équivalent ne
nous permettront pas de vérifier
de manière égale le facteur de chevauchement Nous allons le brancher ici, et celui-ci effectue maintenant la vérification inversée agit donc de vérifier si
la chose en est le propriétaire, et maintenant il s'agit de vérifier
que la chose ne l'est pas à l'époque. Donc, si nous le branchons à la place, nous obtiendrons ce résultat ici. Nous disons donc que si le
facteur de superposition n'est pas le propriétaire, et c'est ainsi que j'
aime exécuter mon code, c'est que si ce n'est pas
l'objet propriétaire, nous pouvons faire notre application
Damage Encore une fois, il
s'agit simplement de
montrer la manière différente
dont vous pouvez concevoir votre code et la
manière différente dont vous pouvez avoir plusieurs approches pour
résoudre le même problème,
même s'il s'agit simplement de la
façon dont le code est lu. Et c'est simple et agréable maintenant. Nous pouvons retrouver notre acteur de
superposition, faire glisser vers le haut avec la touche
Contrôle,
le retirer de cette épingle, et
nous l'avons déjà fait. Nous allons appeler
l'application damage cette fonction universelle globale. Celui qui peut être appliqué
à n'importe quel type d'acteur. Nous pouvons donc le mettre
dans la vraie épingle. Si l'objet que nous avons
touché n'est pas notre propriétaire, nous pouvons l'endommager. Je pense que par défaut,
je vais lui donner une valeur par défaut de 20, donc
nous allons en brancher 20 ici. Nous allons le promouvoir
en tant que variable. Encore une fois, n'oubliez pas que si vous
placez une valeur ici avant de la transformer en variable, cette variable l'aura
déjà stockée. Et l'essentiel est que
nous ne voulons pas de chiffres magiques. Je vais juste le renommer en
Projectile Damage. Appuyez sur compiler et
vérifiez simplement que le numéro
20
doit être renseigné ici. Idéalement, une fois cela fait,
nous souhaiterons peut-être commencer à
jouer des effets sonores
et des effets de particules
spécifiques au projectile J'ai produit
de
très petites étincelles plutôt qu'
une explosion complète, juste pour indiquer que
quelque chose a touché une surface au lieu de
provoquer une explosion Pour ce faire, je vais utiliser le même concept que celui que j'ai
mentionné précédemment. Je vais appuyer sur C à l'intérieur du graphique des événements
sans rien sélectionner. Je vais juste appuyer sur C
pour créer un nouveau commentaire, et je vais mettre
un gros signe à faire ici, puis nous allons simplement dire quelque chose
comme implémenter des effets. Ce sera quelque chose
que nous ferons dans notre pass polonais un peu plus tard. C'est très bien. Non, cela
nous rappellera simplement de revenir ici. Comme je l'ai mentionné, je lui donne
normalement une sorte de couleur jaune-vert juste pour me le rappeler et pour vraiment démarquer des autres éléments qui peuvent apparaître sur le graphique Mais ce que nous voulons
absolument faire c'est qu'une fois que nous avons
joué nos effets, nous voulons nous assurer que le projectile est
retiré du jeu Nous allons donc sortir
de l'épingle d'exécution, rechercher l'
acteur destructeur et nous
débarrasser de nous-mêmes. Le projectile a fait son travail,
il peut donc partir. Et
c'est à peu près tout. Nous allons donc vérifier
ce que nous avons superposé. Si ce n'est pas le propriétaire, nous allons
infliger des dommages. Maintenant, c'est un appel vraiment sûr. Vous vous demandez peut-être ce qui se passerait
si je heurtais les limites latérales ou quelque chose comme un plancher dans lequel je pourrais placer un pick-up
ou quelque chose comme ça Maintenant, si cela se produit
et qu'ils n'ont pas la fonction d'activation des dégâts
que nous avons vue plus tôt, nous pouvons
donc voir ici
s'il y a des dégâts. Cela n'est pas implémenté dans leur base de code,
alors c'est parfaitement bien. Ils recevront
ces informations, mais ils n'ont
pas système de santé ou
quoi que ce soit d'autre à gérer. C'est donc un peu un message jetable
très, très bon marché. Nous n'allons pas avoir problèmes de
performances à
moins d'en faire quelque chose de
vraiment
grave, et cela ne
servira à rien. Je ne détruirai les sols, ni les murs,
ni quoi que ce soit d'autre. C'est donc une fonction sûre et agréable. Nous n'avons pas besoin de savoir quoi que ce soit
à propos de l'autre acteur. Tant que nous avons
touché quelque chose, nous pouvons trouver des
informations génériques à ce sujet. Et si nous pensons que
nous voulons essayer d' infliger
des dégâts, alors
c'est parfaitement bien. Nous pouvons simplement envoyer ce message. La dernière chose à faire est donc
de le rendre réutilisable. Ce sont les dégâts
infligés de manière assez universelle. Nous voulons nous assurer
que nos projectiles correspondent à la couleur du tireur, afin que le joueur tire des
projectiles bleus et que les ennemis tirent projectiles verts ou ce que vous Nous allons donc revenir à
notre fonction de début de jeu ici. Nous voulons juste le faire une
fois que le projectile sera lancé. Nous voulons réellement
récupérer notre composant. Nous pouvons créer du code sur les composants que
nous avons déjà Nous allons
donc le faire glisser
dans le graphe d'événements, puis nous allons
extraire de là et
rechercher les composants que
nous avons déjà. Nous allons
donc le faire glisser
dans le graphe d'événements,
puis nous allons
extraire de là et
rechercher une instance de
matériau dynamique. Nous n'avons donc qu'
une seule option ici. Et c'est l'un des avantages de
l'utilisation d' instances de
matériau par rapport à
notre matériau principal Le code du shader de base est
intégré à l'instance de matériau, nous pouvons les transformer en
version dynamique et nous pouvons réellement mettre à jour
leurs propriétés au moment de l'exécution Nous voulons prendre la valeur de
retour ici, donc la version
dynamique créée, nous voulons la transformer
en variable, et nous l'appellerons matériau R. Donc c'est juste une référence
à notre matériau. À partir de là, nous pouvons modifier notre code pour modifier certaines
des propriétés de base. Si vous voulez en savoir plus à ce sujet, il
vous suffit de connaître les noms des
variables avec lesquelles vous pouvez travailler. Et
c'est vraiment simple. Si nous prenons le maillage statique, vous montrons très rapidement
certaines des autres choses que vous pouvez faire une fois que vous en aurez appris une que je suis sur le point de
parcourir avec vous. Si nous double-cliquons sur le projectile
MI underscore, nous savons qu'il s'agit de
notre instance matérielle Cela nous ouvrira la ressource. Et en gros, tout ce que je vous ai exposé
ici, souvenez-vous j'ai dit que j'ai
créé ce gros matériau
quelque peu personnalisable. Tout ce qui est nommé dans notre section ici est
accessible en code. Vous pouvez donc modifier la
spécularité au moment de l'exécution, si vous voulez rendre
les choses plus
brillantes et potentiellement humides Vous pouvez modifier la texture
au moment de l'exécution, les couleurs, les couleurs de remplacement, les propriétés
d'émission, si vous voulez la faire
briller. Tu voulais le faire. Tant que vous connaissez le nom
et l'orthographe spécifique, vous pouvez modifier et
affecter n'importe lequel d'entre eux. Donc, pour
faire quelque chose de très simple pour montrer ce type d' inaction, nous voulons obtenir
notre référence matérielle. Encore une fois, par préférence personnelle, j'ai toujours un nouveau nœud
à extraire d'ici, mais vous pouvez simplement trouver
les informations de cette
référence matérielle que vous venez promouvoir au rang de variable. Je vais récupérer notre
référence de variable ici, et à partir de là, je veux trouver la valeur du paramètre
vectoriel défini. C'est donc cette option ici. Nous voyons que cela entre dans
la catégorie des matériaux, nous cherchons
donc
la bonne chose. Cela nous permettra de définir la couleur
d'un vecteur, dans ce cas. Nous allons donc le connecter à la broche d'exécution. Le vecteur que nous voulons modifier sera la couleur,
donc la couleur émissive Et encore une fois, nous pouvons toujours
simplement vérifier ici. C'est ce qu'on appelle la couleur émissive, c'est
donc celle que
je recherche Et la nouvelle couleur que je
veux que ce soit sera basée sur l'
acteur qui l'aura créée Donc, si c'est un ennemi vert, je
pourrais le transformer en vert. Si c'est notre joueur, je le
transforme en bleu. Si vous avez un ennemi rouge, vous pouvez le
transformer en rouge. Alors vérifions-nous simplement
que cela fonctionne. Si nous changeons cela pour
quelque chose d'assez évident, nous allons simplement le rendre jaune
pour le moment, appuyer sur compiler, enregistrer. Nous n'allons pas voir cela
se produire avant d'avoir commencé à jouer. Nous pouvons donc le placer dans le graphique et
cliquer sur simuler ici. Nous devrions le voir
commencer à briller. Un autre problème que
je pense avoir ici
concerne le projectile MI
Underscore Je veux m'assurer
que c'est coché. Mais je dois aussi m'
assurer que cela a une propriété émissive Je vais donc entrer
et m'assurer que la valeur par défaut de la propriété
émissive ici est de dix Parce que encore une fois, nous le
multiplions pour le moment, n'importe quelle couleur par zéro la empêchera
de briller Donc, si nous appuyons
à nouveau sur Play ou simulons, en fait, nous pouvons voir que cela est maintenant
devenu jaune. Donc, si je fais un zoom arrière
un peu plus près, je vais appuyer sur simuler pour que nous puissions tout voir et que nous ayons
un projectile jaune brillant Donc, le seul changement
que vous souhaitez apporter est d'ouvrir le matériau et de
vous assurer qu' il brille
autant que vous le souhaitez Vous pouvez le rendre beaucoup
plus exagéré, afin que nous puissions en faire
un projectile très brillant et
lumineux, à vous de
choisir Je vais donc le mettre à 100 pour
que ce soit très, très visible. Et c'est à
peu près ce que nous faisons ici. Nous saisissons donc cette
propriété par son nom, et nous lui attribuons une
nouvelle valeur, simple et agréable Maintenant, une autre chose que
vous voudrez peut-être faire est d'avoir un peu
plus d'éclat que d'autres. J'ai donc juste eu
besoin de
modifier manuellement la force d'émission ici Donc, ce que nous pourrions faire à
la
place, c'est simplement montrer comment nous
pouvons utiliser ce système. Nous pouvons dupliquer la référence
matérielle, et cette fois, je vais
définir une valeur scalaire Ainsi, les valeurs avec lesquelles
nous travaillons, bien qu'elles soient
connues sous le nom de flottants, lorsque nous travaillons
avec des matériaux, sont
malheureusement
appelées scalaires Cela est dû au fait qu'ils sont
fabriqués sous forme de flotteur évolutif. Nous pouvons les modifier lors de l'exécution. Essayez donc de vous en souvenir. Il s'agit d'une terminologie légèrement nouvelle, mais c'est celle que vous
devez apprendre pour travailler avec des matériaux en
particulier. Nous allons donc prendre
notre valeur scalaire. C'est ce que j'ai appelé la force
émissive. Nous allons donc
le brancher. Nous allons trouver notre force d'émission. Ensuite, vous pouvez le modifier à la valeur que vous
vouliez qu'il soit. Nous pourrions donc en
faire quelque chose de vraiment stupide par défaut, comme 1 000 1 000, c'était peut-être
un peu extrême, mais cela reflétait le concept
général. Je vais le remettre
à 100. Je trouve que c'est
une
propriété quelque peu émissive plutôt cool une
propriété quelque peu émissive plutôt pour un projectile qui
se déplace assez vite Nous devrons peut-être le souligner
pour le rendre plus visible. Comme pour tout,
nous ne voulons pas que ces variables redeviennent des variables magiques. Nous ne pourrions modifier cela qu'ici directement dans le code. Nous allons donc
promouvoir notre couleur
au rang de variable que nous
pourrons suivre et utiliser ultérieurement. Nous nommons cette couleur de
projectile en fonction de notre valeur. Donc, la valeur à
virgule flottante ici. Nous allons en faire
une variable et l'
appellerons émission unique des projectiles. Cela nous donnera donc une
certaine flexibilité lorsque nous
commencerons à les faire apparaître
dans nos classes parentes, l'ennemi ou le joueur Certains d'entre vous se
sont peut-être rendu compte qu'il existe un autre problème que nous n'avons pas encore
vraiment abordé. Et c'est que les
projectiles peuvent potentiellement voler dans l'espace pour toujours s'ils
ne touchent rien du tout J'ai pensé que si des objets
touchaient le sol et les murs, j'ai dit qu'ils se
nettoieraient tout seuls. Lancez une fonction
jetable très bon marché, parfaitement adaptée pour
endommager le mur,
ce qui
sera essentiellement ignoré, ce qui
sera essentiellement ignoré, mais nous n'avons pas pensé à ce se passe s'ils ne
touchent rien du tout Ce qu'ils vont faire pour le moment,
c'est simplement s'envoler dans l'éternité, mangeant de la mémoire. Il y a donc deux choses
que nous pourrions faire. La première est que si nous nous emparons de
notre propriété principale ici, nous pouvons réellement donner à n'importe quel acteur avec
qui nous travaillons toute une vie. Je vais donc simplement le trouver dans
le panneau des détails. Nous pouvons rechercher ici la durée de vie, et nous pouvons lui donner
une durée de vie initiale. Si nous savons que cela ne
restera certainement pas à l'écran
pendant plus de 10 secondes, nous pouvons lui donner
une durée de vie de dix secondes. Et passé ce délai, s'il
ne touche à rien, si nous n'appelons pas la fonction de
destruction ici, il sera simplement
détruit automatiquement. Le problème, c'est
que nous pouvons nous retrouver avec projectiles qui se déplacent
un peu plus lentement que d'autres, ou que nous allons les utiliser
et peut-être les recycler plus tard, ce qui signifie que nous pouvons simplement
les cacher et les
remettre en jeu Et évidemment, nous ne voulons pas que
nos projectiles sortent de l' écran de
manière aléatoire au bout de 10 secondes Je ne vais donc pas vraiment
utiliser cette approche. Une autre chose que vous pourriez
voir est l'événement, une vérification constante pour voir s'il est actuellement hors
caméra ou hors zone Nous allons faire
quelque chose d'un peu similaire, mais je voulais me concentrer à nouveau sur les bonnes pratiques de programmation. Comme je l'ai dit, certaines
choses
peuvent et doivent certainement être sur Tick, mais ce n'est pas une des choses que
nous allons faire, c'est créer une nouvelle fonction
appelée out of bounds check Et ce ne seront que
des calculs très, très simples. Nous allons donc cliquer avec
le bouton droit de la souris et
rechercher l'emplacement de l'acteur G, l'emplacement du projectile
à son point actuel Nous allons
extraire de ce nœud, et nous allons
retirer un autre vecteur. Nous allons donc
soustraire un nœud ici, et nous pouvons utiliser ce que l'on appelle le gestionnaire de caméra du joueur Donc, si nous achetons le gestionnaire de
caméras pour joueurs, nous pouvons trouver le
préfabriqué toujours référencé et de toute façon
dans la mémoire d'Unreal Nous pouvons
donc aussi bien
utiliser ces valeurs qui existent déjà pour Et depuis le
gestionnaire des joueurs, qui suit
actuellement la caméra active
actuelle, nous pouvons obtenir l'emplacement de la caméra. Ce sera donc l'emplacement
actuel de la caméra que
nous examinons. Nous pouvons donc supprimer ces deux éléments, et cela fournit un nouveau
vecteur, une distance pour nous. À partir de là, nous pouvons tirer
à partir de l'épingle vectorielle ici, et nous voulons prendre
la longueur du vecteur. Donc, si nous recherchons la longueur,
nous pouvons obtenir la longueur du vecteur. Cela le convertira en une valeur à virgule flottante pour nous, ce qui nous donnera
essentiellement une distance en ligne
droite. Nous savons donc exactement combien d'
unités en ligne droite notre projectile actuel se
trouve loin de notre caméra Cela fonctionne quelle que soit
la direction, ce qui est un autre élément
très utile de ce type d'approche, qui
signifie que cela
fonctionnera pour les projectiles volant dans n'importe quelle
direction et dans n'importe quel angle Ensuite, ce que nous voulons faire,
c'est à partir de notre épingle d'exécution, nous allons tirer d'ici et nous allons obtenir une branche. Vous avez assez
d'espace pour travailler avec ça. Et nous
allons essentiellement dire que si longueur de
ce vecteur est
supérieure ou égale à
une certaine valeur, alors nous allons
détruire cet acteur. Je dis donc supérieur ou
égal à pour tenir compte, encore une fois, s'il
dépasse cette valeur. Si c'est vrai, nous allons le
brancher ici,
assécher un peu les choses ici. Et je vais vous dire que je pense qu'une valeur de 3 500 unités fonctionne C'est donc à peu près en dehors
des zones de caméra. Nous pouvons être un peu plus scientifiques
et essayer de tester cela plus tard. Si vous trouvez que des éléments
apparaissent trop tôt, vous voulez simplement
augmenter cette valeur, et si cela prend
trop de temps, vous pouvez la
diminuer. Mais je pense
que cela fonctionnera certainement. Peu importe qu'
ils existent
quelques secondes de plus qu'ils ne le devraient. L'essentiel est que nous ne
voulons pas les voir apparaître
comme par magie hors de
l'écran et disparaître Et nous ne voulons pas que
des centaines et des centaines de projectiles existent
pendant quelques minutes C'est plutôt le problème que
nous essayons de résoudre. Si c'est vrai, alors je
vais partir de là, je vais dire détruire l'
acteur juste pour que nous
puissions effacer ce projectile
de la mémoire C'est si beau et si simple. Comme toujours, il n'y a pas de chiffres magiques, je vais
donc redescendre et
le promouvoir en variable. Nous appellerons cela quelque chose
comme une distance hors limites. Et encore une fois, cela
rend agréable et simple le fait que nous
puissions toujours revenir directement ici. Et si nous rencontrons
des problèmes où nous
devions changer cela, augmenter ou le diminuer
, nous avons maintenant
un endroit facile à trouver
pour effectuer ce changement. Pour le moment, nous n'avons pas
appelé cette fonction, donc un
problème très simple à résoudre ou chose
facile à oublier est que nous ne pouvons pas simplement
créer la fonction. Nous devons également appeler ça. Nous ne voulons pas l'
appeler une seule fois. De toute évidence, nous ne voudrions pas le
faire au début du jeu. Et comme je l'ai mentionné,
nous ne voulons pas le
faire constamment sur Eventi Donc, au lieu de cela,
nous allons faire partir de l'épingle d'exécution, après avoir défini le
paramètre scalaire ici, nous allons encore une fois
utiliser des minuteries Ils sont très, très flexibles. Nous allons donc rechercher
cette même fonction,
qui est réglée
par le nom de la fonction en fonction du minuteur. La fonction
que nous
voulons sera évidemment notre outil de contrôle hors limites Encore une fois, je
vais le renommer, le
renommer mais appuyer sur Ctrl C, Control V pour le placer,
et nous pourrions le configurer en boucle
peut-être une fois par seconde. N'oubliez donc pas que si
nous le faisions sur Tick, cela reviendrait à vérifier
potentiellement 120 fois par seconde
sur la base de ma fréquence d'images actuelle. C'est donc un peu
exagéré. Nous n'avons pas besoin que ce soit aussi précis. faire une fois par
seconde n'alourdira pas
les performances
du jeu, et cela signifie que nous devons tout de
même vérifier à
une itération ou à un
intervalle relativement rapide les projectiles qui n'ont pas besoin d'être à Comme je l'ai mentionné, le
fait d'avoir un projectile pendant quelques secondes supplémentaires ne sera pas un risque que des centaines de projectiles soient vérifiés
120 fois par seconde.
S'ils devaient toujours exister, ce serait Nous voulons nous assurer que
cela est appelé en continu, donc plus d'une fois, nous
allons donc le mettre en boucle Donc, une fois par seconde,
cela sera désormais appelé. Nous avons une
itération en boucle de ce chronomètre, qui permet de vérifier
la position du projectile par
rapport à la caméra et de vérifier s' il est techniquement hors de vue Nous pouvons donc aller le tester.
Si nous branchons l'un d'entre eux, nous en créerons peut-être
deux, et nous appuierons sur Simuler juste pour que nous puissions le voir
se déclencher. Et vous pouvez voir que
l'un d'entre eux
a percuté l'avion ennemi, qui a
donc été détruit
en percutant l'avion. Mais l'autre
se déclenche, et une fois qu'il est une certaine distance,
on ne le voit plus. Donc, si j'appuie sur l'
avion à partir d'ici, l'essentiel est que
nous ne les voyions pas simplement disparaître à travers la caméra, c'est ce
que nous voulons éviter. Mais les
tests précédents nous ont appris qu'ils sont en train disparaître lorsque nous le
testons en mode simulation. Bien sûr, ils s'
envolent et apparaissent en dehors
du champ de vision de la caméra C'est donc une belle façon
propre de le faire. Cela ne va pas entraîner
de gros frais généraux. Cela ne poserait certainement
aucun problème de performance. Il s'agit ici d'un
calcul relativement simple et léger. Je pense que c'est beaucoup plus sûr que d'utiliser Lifetime,
car nous ne savons pas combien de temps ou à quelle vitesse
tous les projectiles vont se déplacer et
combien de temps ils peuvent rester à l'écran Et c'est suffisamment bon marché pour exécuter ce calcul pour ne poser aucun problème de performance. Et je voulais
juste montrer une simple
comparaison entre les endroits où nous pourrions utiliser Tick et ceux où
nous évitons d'utiliser Tick. N'oubliez pas que lorsque nous
jouons avec ces objets, revenez
toujours et supprimez les acteurs que vous
n'utilisez peut-être plus. Nous ne voulons pas les
garder. Nous allons les faire apparaître à partir de certaines fonctionnalités
de lutte contre le feu
un peu plus tard Encore une fois, si vous êtes toujours en train de
jouer avec ces éléments, n'hésitez pas à essayer
différentes vitesses, différentes couleurs, pour
voir si vous souhaitez affecter l'une des
autres propriétés l'instance de matériau. Voyez si vous pouvez trouver
comment modifier certaines des autres valeurs scalaires
ou paramètres vectoriels Encore une fois, l'essentiel est que vous
n'ayez besoin que de leur nom et l'orthographe exacte, et
tout ira parfaitement bien. Vous pouvez modifier les valeurs comme bon
vous semble. Encore
un beau défi. Non, j'espère que vous serez plus à l'aise avec une
petite partie du programme. Pour ajouter de l'accélération au fil du temps avec peut-être un type
d'interpolation. Vous pouvez voir ces approches dans
l'autre
code que nous avons. Et comme je l'ai
mentionné, c'est l'une des
bonnes choses à propos du
lancement de notre propre code. C'est juste quelque chose qui
est presque impossible à faire avec la composante de
mouvement du projectile Donc, si vous vouliez qu'il passe d' une vitesse plus lente à une accélération
au fil du temps ou en sens inverse, vous pourriez le faire
voler très vite puis ralentir pour
perdre de l'élan. Vous pourriez également
envisager des choses comme projectiles
en utilisant des techniques
similaires ou de les
intercaler vers un objectif spécifique au fil du temps Je l'ai mentionné, je
recommanderais de conserver la classe actuelle telle qu'elle est. Si vous faites ces tests et essayez certaines de
ces expériences. Je recommande toujours de
dupliquer ce que vous
avez et d'essayer de créer
votre propre version à partir de cela Mais c'est un excellent
moyen d'apprendre. Je ne veux pas vous
empêcher d'essayer de nouvelles choses,
mais, bien entendu, dans les prochains articles,
nous
utiliserons ces projectiles
tels qu'ils sont Je recommande donc
d'avoir
également cette version afin que nous puissions terminer
le projet ensemble.
21. 20 - Ennemi en feu projectile: Pour que les objets
tirent réellement leurs projectiles. Nous allons le
refaire, bien rangé. Une fonction incendie dans la classe de base personnalisée
par les enfants si nécessaire. Même schéma que celui que nous avons utilisé
auparavant, nous allons
donc nous retrouver avec
les mêmes fonctionnalités que notre exemple de projet que nous nous
efforçons de recréer quelque peu, mais nous adoptons une approche légèrement
différente abord, juste un rappel, si vous avez
des projectiles traînent, je
vous recommande de les supprimer Avant de commencer,
nous les créerons tous dynamiquement au moment de l' exécution lorsque
cela sera nécessaire. Nous allons commencer
dans notre classe d'avion de base. Donc, si nous passons à la base du
plan principal et
que nous effectuons notre
implémentation initiale ici, nous créerons ici une fonction
nommée fire. Nous allons faire une
chose très similaire à ce que nous avons fait avec notre classe de générateur d'ennemis. Nous allons
extraire l'épingle d'exécution et rechercher l'acteur d'
apparition dans la classe Nous le pouvons encore une fois,
nous allons partir de là et nous allons en
faire une variable. Et au cas où nous voudrions
changer cela plus tard,
je pense que nous n'aurons qu' une seule classe de projectiles Mais au cas où nous voudrions des projectiles
différents, nous en ferons la promotion pour les
rendre réutilisables Nous allons renommer celui-ci en classe
projectile. Laissez ceci comme type d'
acteur par défaut, appuyez sur compiler, et celui-ci est parfait. Maintenant, lorsque nous appuyons sur compiler, nous obtenons cette erreur
indiquant que nous
devons fournir des informations
supplémentaires. Nous avons besoin du TransponPin. Nous pouvons faire deux choses. Nous pouvons
diviser la goupille de la structure. Et si vous vouliez le laisser
complètement vide, nous pouvons appuyer sur compiler et cela
fera disparaître l'erreur. Maintenant, je vais
appuyer sur Ctrl dans Dead. Il y a autre chose
que nous pouvons faire ici. En ce qui concerne le lieu d'apparition,
nous devons savoir exactement où nous voulons que nos projectiles
apparaissent Et une façon de le
faire et de le rendre quelque peu visuel est d'
ajouter un nouveau composant. Je vais aller
dans le belvédère. Je vais ajouter
un nouveau composant, et je vais sélectionner le
composant de scène juste ici. Une chose que j'aurais dû
faire, c'est que cela
sélectionnait déjà le maillage, mais
c'est parfaitement bien. Je veux que ces composants de scène suivent
toujours ce
qui se passe avec le maillage. Je vais donc simplement le récupérer et le
supprimer
à nouveau en me concentrant sur hiérarchie afin que le
nouveau composant de scène soit un enfant du maillage statique. Pour que cela soit clair, si
vous le vouliez vraiment, nous pourrions le renommer
, et j'appellerai ce projet
notre lieu de création. Ainsi, lorsque nous examinons
notre hiérarchie, nous avons une idée précise de la
responsabilité de ces différents composants. Maintenant, nous n'avons pas besoin que
cela soit visuel, mais ce que nous pouvons faire avec cela, c'est que
nous pouvons maintenant
le
déplacer et avoir un contrôle direct l'endroit où nous voulons que le
projectile apparaisse On pourrait l'avoir un peu
devant l'avion. Eh bien, comme je l'ai
mentionné, nous voudrions peut-être que cela se trouve légèrement
à l'intérieur de l'avion, afin qu'il ne semble pas surgir de
nulle part
comme par magie Lorsque vous serez
satisfait de la position
de l' emplacement d'
apparition de votre projectile, encore une fois, si nous appuyons sur compiler,
nous obtiendrons
ce mauvais résultat de plan dans la fenêtre d'affichage, mais
c'est parfaitement Nous voulons simplement reprendre notre
fonction d'incendie. Nous allons faire glisser le apparition
du projectile dans
le sol À partir de là, je vais chercher
quelque chose qui s'appelle
Get World Transform. Nous voulons donc cette option juste
ici avec la fonction verte ? Get World transform va
fournir la transformation de ce
composant spécifique dans le monde par rapport à la rotation et à
tout ce qui s'est passé. Nous pouvons donc nous assurer que le projectile
sera dirigé vers l'avant Nous allons le brancher,
nous allons appuyer sur Compile, et nous pouvons voir que les problèmes
sont maintenant résolus. Je voulais juste
montrer autre chose, et je pense qu'il pourrait être intéressant de passer d'une
classe
d'acteur à une classe spécifiquement basée sur
les projectiles Si nous revenons simplement à
notre classe de projectiles ici, nous allons double-cliquer pour
ouvrir la classe de base et nous assurer
que
deux choses sont exposées ici Nous voulons donc que la
couleur du projectile soit exposée, la force d'
émission du projectile et peut-être que la vitesse de
déplacement du projectile pourraient également
être utiles Veiller à ce que ces
trois éléments soient publics. Vous pouvez revenir et encore une fois, j'
essaie de jeter les
bases pour vous. Vous pouvez revenir et une fois que
vous aurez vu ce que
nous sommes sur le point de
faire, apporter
les autres modifications souhaitées. Sont totalement facultatifs, mais je pense que ces trois
seront bons pour les tests. Et si nous appuyons sur compiler et enregistrer, nous retournerons dans
notre classe de base plane et dans la fonction fire. Maintenant, par défaut, étant donné que ce paramètre
est défini sur un acteur générique, aucune donnée n'est exposée. Maintenant, en
utilisant une saisie
spécifique nous pouvons rechercher notre projectile
BP Underscore Nous voulons utiliser l'option de base, nous devons la faire
défiler et sélectionner le type de référence de classe,
pas le type d'objet. Cela nous indiquera simplement que certaines choses
devront changer. Il se peut que nous ayons des références ou
des liens essentiellement
brisés vers différents types de classes, et c'est parfaitement bien. Nous allons dire de changer cette variable. Nous allons laisser ça faire son travail. Cela ne va vraiment rien
casser car nous n'utilisons rien spécifique pour le moment de toute façon. Nous n'avions qu'un acteur générique.
Nous pouvons donc fermer cela. Et ce que je voulais montrer, c'est
que si nous cliquons avec
le bouton droit sur l'acteur d'apparition et que nous choisissons l'option Actualiser le nœud ici l'option Actualiser le nœud ici
ou si nous nous assurons d'abord de
cliquer sur compiler, nous devrions voir les propriétés que
nous venons d'exposer, et je viens de comprendre
quel est le problème Il y a une autre étape qu'
il est très facile de négliger. Et nous allons retourner
dans la base des projectiles. En plus de les rendre publics, nous avons besoin d'une autre
case à cocher. Donc, juste certaines de ces informations que vous
devez savoir sur Unreal, et vous les découvrirez au
fur et à mesure. Donc, pour ce qui est de
la vitesse de déplacement et des deux autres que
nous avons exposées, nous voulons également choisir
cette option ici, exposer au moment de l'apparition dans
le panneau des détails Nous devons donc le faire
pour chacun d'entre eux, alors saisissez votre variable, puis cochez l'exposant sur span. Je suggère qu'il expose simplement cette propriété chaque fois que nous créons
cette classe quelque part Il est également très important que
nous nous assurions compiler et de sauvegarder dans
la classe projectile Sinon, si nous retournons dans notre base aérienne, nous
ne verrons pas cela. Et vous pouvez voir maintenant que la
principale raison pour laquelle nous voulions cela est de
préciser que nous allons utiliser
spécifiquement base de
projectiles BP Underscore plutôt qu'un acteur générique Nous avons maintenant exposé ces
propriétés, ce qui est vraiment utile. Cela nous donne le
pouvoir de changer la couleur en fonction la classe dans laquelle nous
allons l'apparaître, ainsi que de la vitesse de déplacement, la force d'émission,
etc.,
selon la manière dont vous le souhaitez . Avec tes classes de projectiles. Maintenant, tout cela est fait
une fois dans la classe de base. Nous voulons que cela soit
facilement réutilisable sans avoir à
entrer dans le code. Donc, bien sûr, nous n'allons pas abandonner ces chiffres magiques. Au lieu de cela, nous allons
promouvoir chacune d'entre
elles en tant que variable. Nous ferons la promotion de la
première, que nous
appellerons vitesse de
déplacement des projectiles Et ensuite, bien sûr, nous
ferons de même. Nous allons promouvoir
la couleur et la force d'
émission des projectiles selon leurs propres propriétés. Et
c'est bon pour y aller. Cela signifie que nous pouvons désormais avoir cette fonction réutilisable à la fois
dans l' avion du joueur
et dans le joueur ennemi, et tout ce que nous devons modifier pour chaque classe, c'est la
rapidité avec laquelle nous voulons que les
projectiles Parce que je me souviens que dans
l'exemple de projet, l'ennemi est tiré
plus lentement que le joueur, et nous pouvons changer
la couleur en
fonction de la personne à l'origine
du projectile Cela signifie que nous n'avons pas besoin de
chargements de différents types de projectiles spécifiques Nous pouvons simplement prendre notre base de
projectiles et apporter quelques modifications rudimentaires très
simples plan La seule
chose vraiment importante avant de partir d'ici, se souvenir de cette fonctionnalité sur la collision que nous sommes en train de faire là
où nous disons ici, si nous
chevauchons en ce moment notre propre propriétaire, alors nous ne
voulons pas endommager aucun d' Nous devons nous assurer que ce qui
donne naissance à la classe, ce que nous faisons actuellement dans
la base aérienne,
transmet réellement les informations sur l'identité
du propriétaire Donc, une autre chose
que nous pouvons indiquer ici dans l'acteur d'apparition de la base
aérienne, c'est que
le propriétaire est juste ici Donc, gentiment et simplement, nous
pouvons tirer de cette épingle, et nous allons
rechercher une référence G à vendre. Ou vous pouvez simplement taper
le mot cellule et vous verrez une
référence à soi ici. agit donc
simplement de s'assurer que
quel que soit l'avion ce projectile lorsque
cette fonction est appelée, il se désigne lui-même en tant que
propriétaire du projectile,
afin de s'assurer qu'il ne s'endommagera pas Si beau et propre,
on peut taper, empiler, économiser, et
celui-ci est prêt à être utilisé. Nous sommes donc arrivés à un bon
point où nous pouvons ajouter la
version la plus simpliste du tir, qui
deviendra notre classe ennemie Avant cela, je pense qu'
il y a une autre variable que les deux classes
pourront utiliser,
à savoir la cadence de tir,
la
fréquence
à laquelle l'avion sera capable de tirer. Nous allons donc créer une nouvelle
variable ici. Le premier portera sur le type de vol, alors appuyez sur Control ID sur
n'importe quel autre vol, et j'appellerai celui-ci
Fire Rate.
Il compile. Je pense que juste pour être sûr que nous
n'
oublierons pas de le régler plus tard, je vais simplement le remettre à zéro, et nous nous
assurerons de le modifier pour chaque plan. Et puis l'autre chose
qui, je pense, sera très utile dans nos deux classes plus tard sera un vecteur deux D pour la cadence de tir minimale et
maximale. Nous avons donc une certaine randomisation. Je vais donc créer une nouvelle
variable. Nous voulons que ce soit à nouveau un vecteur deux D. Mais pour l'instant, nous l'
appellerons juste une cadence de tir maximale d'une minute. Nous voulons le vecteur deux
D que nous avions auparavant, et encore une fois, nous pouvons
les laisser à zéro pour le moment. Nous reviendrons les
modifier ultérieurement. Et c'est l'un de ces cas
où nous obtenons
de nombreuses variables similaires
pour un système. Nous pouvons donc
les classer dans une catégorie, particulier pour les projectiles, les
combats ou tout ce que
vous souhaitez Nous pourrions également avoir une catégorie de santé,
quelque chose comme ça. Comme je l'ai mentionné, je ne vais pas
continuer à le faire à l'écran, car c'est juste un
travail fastidieux en arrière-plan, mais cela pourrait certainement
aider, car nous obtenons nombreuses autres variables à mesure que
nous affichons les classes individuellement. c'est très
bien. C'est une bonne chose pour un point de travail de base Nous pouvons
donc maintenant entrer dans
notre classe ennemie, donc nous allons entrer dans le noyau. Jouez à Enemy, et nous voulons créer une séquence dès
le début de la partie. La raison en
est que nous sommes maintenant confrontés à une
sorte de logique confuse Nous faisons
différentes choses lors l'initialisation de notre classe, ce qui est parfaitement bien, mais nous
pouvons simplement remettre les choses en ordre Une astuce rapide
est donc que nous pouvons retirer
l'épingle d' exécution après l'appel parent et entre
ce que nous sommes déjà en train de faire, et nous appellerons un nœud de
séquence ici. Et cela connectera
automatiquement la logique que nous avons
sans rien casser donc zéro est essentiellement notre initialisation pour la randomisation
générique Nous pourrions donc avoir un commentaire
disant de randomiser les valeurs ici. Ensuite, la prochaine chose que
nous allons vouloir faire est de configurer les détails de nos tirs. Donc, en fait, cela va
toujours être basé sur un certain niveau
de randomisation Je vais donc
cliquer avec le bouton droit de la souris, et je vais obtenir la propriété de la cadence de tir. Nous voulons donc régler
la cadence de tir ici, et celle-ci sera à nouveau réglée sur une distance flottante aléatoire. Nous allons l'intégrer, et
ce flottant aléatoire sera, bien
entendu, le minimum maximum que
nous venons de créer Nous allons donc obtenir la cadence de tir maximale
minimale, diviser la
goupille de la structure comme nous l'avons fait auparavant et les brancher ici. Donc un minimum, un maximum
pour le X et le Y. Encore une autre belle
randomisation simple pour que tous les ennemis ne tirent pas exactement
à la même cadence, sinon ça va paraître très répétitif et ennuyeux Si nous appuyons sur Compiler, nous
voulons également nous assurer que pour
la classe ennemie, nous définissons une cadence de tir minimale,
qui, je pense, se situe
entre 0,4 et 0,8 Encore une fois, vous pouvez modifier toutes
ces valeurs à votre guise, puis la
cadence de tir sera réglée spécifiquement entre cette plage Ensuite, à partir de la deuxième sortie et maintenant que nous avons effectué notre
randomisation, nous pouvons réellement commencer à configurer la fonctionnalité Fire
à appeler Nous allons donc
utiliser à nouveau le chronomètre défini par nom de fonction,
nous allons partir de là. Nous allons utiliser le
chronomètre défini par nom de fonction. Bien sûr, nous allons
appeler la fonction incendie. C'est ce que nous avons créé
dans notre classe de base, et ce
sera notre cadence de tir. Nous allons donc obtenir la cadence de tir que
nous venons de répartir de manière aléatoire, et nous allons nous assurer qu'
elle est réglée en boucle Cela continuera donc d'être
demandé tant que l'
ennemi sera en jeu. La randomisation garantit que chaque ennemi tire à sa
propre cadence aléatoire. Certains seront un peu
plus agressifs et d'autres plus calmes. Une autre chose pour les ennemis c'est que lorsqu'
ils quittent l'écran, si le joueur les rate,
comme pour les projectiles, ils devraient également être en train de se
nettoyer Nous allons donc passer à
la classe des projectiles, et je vais en fait
suivre la logique exacte de vérification
hors limites ici Nous pouvons copier tout cela, appuyer sur la touche NC, retourner
dans la classe ennemie. Nous allons créer une nouvelle
fonction. Encore une fois, nous
allons simplement appeler
celui-ci hors limites. Et il suffit de le coller
dans le graphique ici. Donc, un peu de duplication. Et encore une fois, c'est là que vous pourriez commencer à considérer que des choses comme l'utilisation de composants seraient une chose
précieuse ici. Vous constaterez peut-être que lorsque vous vous
intéresserez davantage à
la programmation, le concept fait
souvent référence à l'héritage
plutôt qu'à la composition, en utilisant des
composants comme celui-ci. Un peu hors de portée de ce système vraiment novateur. Nous allons donc
prendre un léger raccourci pour certaines choses , mais ce n'est toujours pas une mauvaise
approche pour le faire, juste un tout petit peu de duplication. Mais la
variable de vérification hors bande que nous avons copiée à partir de l'autre classe n'existe
évidemment pas ici Nous allons
donc cliquer avec
le bouton droit de la souris et créer une variable. Et celui-ci, nous
venons de cliquer sur Compiler. Nous allons vérifier la position de l'ennemi grâce
à la caméra. Pour la distance hors limites, nous pouvons utiliser une valeur similaire Je pense que 3 500
fonctionnaient plutôt bien. Nous voulons simplement nous
assurer de garder un œil sur les ennemis qui
quittent l'aire de jeu, et si nous les remarquons simplement disparaître
,
nous souhaiterons peut-être modifier
cela d' une manière ou d'une autre Maintenant que c'est
prêt, nous voulons
revenir à notre graphique des événements. Nous devrions peut-être commencer à ranger un peu
les choses et simplement à les déplacer pour nous
donner de l'espace L'essentiel ici, c'est que nous pourrions
définir un autre moment ici, donc cela pourrait être notre logique pour configurer les
fonctions récurrentes Nous allons donc créer un autre TO par nom de
fonction pour celui-ci. Ce sera notre vérification
hors limites, et nous devrions peut-être le
faire une fois par seconde Nous allons donc fixer une heure ici
, mais une fois par seconde. Nous allons le promouvoir en tant que
variable. Et je vais régler celui-ci pour qu'il soit appelé durée
de vérification hors limites Comme avant, nous allons appuyer sur Compiler. Nous voulons
nous assurer de lui donner une valeur, afin qu'elle ait une seconde,
et nous la réglerons en
boucle, de sorte qu'elle
continue jusqu'à ce qu'elle soit
retirée du jeu Comme je l'ai fait par
le passé également. Je pense que je vais
écrire, cliquer ici et trouver la fonction d'incendie. Nous allons donc simplement passer
à CallFireFunction. Nous n'
allons pas vraiment l'utiliser. C'est juste pour que, encore une fois, si
nous voulions vérifier ce qui se passe dans
cette fonction, nous puissions simplement double-cliquer ici. Je vais faire la vérification des
limites, obtenir le nom, et m'assurer que nous le
remplissons ici à notre rythme, puis que nous le faisons glisser
à nouveau pour la même raison Juste au cas où je voudrais
voir ce qui se passe, je peux simplement double-cliquer dessus
et voir le code exactement. Comme je l'ai mentionné, c'est juste
une préférence personnelle, mais c'est quelque chose que j'ai toujours
tendance à faire dans mon propre code. Enfin, je pense que nous avons
oublié de faire, c'est parce que nous avons légèrement
échangé les classes de projectiles Si nous revenons à la classe de base laquelle nous avons implémenté
la fonction de tir, si nous reprenons notre classe de
projectiles ici, nous pouvons voir qu'elle est définie Donc, si nous essayions maintenant, aucun
ennemi ne
tirerait quoi
que ce soit parce qu'on ne leur
donne pas le
type de classe spécifique à tirer. Donc, pour le moment, nous n'en avons qu'une, qui
est la classe de base. Mais si nous en faisions des cours pour
enfants, nous pourrions également utiliser ces versions
uniques. Nous l'avons donc envoyé comme base
de projectiles par défaut ,
car pour le moment, c'est la seule chose avec laquelle
nous devons travailler Appuyez sur compiler et enregistrer.
Et puis, chez l'ennemi, vous verrez
que cela se propagera automatiquement. Nous avons donc également défini la
classe des projectiles ici. Appuyez sur Compiler et Sauvegarder, et nous
pourrons empêcher l'ennemi de tirer. Rien de très chic donc,
mais ils le sont en effet. En tirant, nous pouvons
voir que nous obtenons cela des cadences différentes, à des vitesses
différentes. Nous avons donc un gameplay légèrement unique basé
sur les différents ennemis. Nous devrions également veiller à ce qu' après un certain nombre de coups, le joueur soit
retiré du jeu, afin que les dégâts soient
répercutés automatiquement. Tout fonctionne donc comme prévu,
du moins pour la
classe ennemie, ce qui est formidable. La dernière chose que je
remarque, c'est que
ça va probablement être un peu
rapide, et c'est très bien. C'est pourquoi nous avons défini toutes
ces valeurs de manière à ce
qu'elles soient faciles à ajuster et à
modifier en fonction des tests de jeu , des
commentaires et du terrain de jeu général
que vous recherchez Je pense donc que chez l'ennemi,
nous allons ralentir un
peu
ses projectiles parce qu'il y
en aura beaucoup Le joueur
veut probablement tirer plus vite, et les ennemis peuvent être un
peu plus détendus. Nous allons donc le fixer à
quelque chose comme 1 500. Et si nous pensons que c'est trop lent. Je suis donc en train de sélectionner la classe ennemie, saisir la vitesse de
déplacement des projectiles et de la ramener à 1 Nous pouvons également changer la couleur. Mes ennemis sont donc verts.
Je vais trouver une couleur un peu plus
proche du style ennemi ici. Vous devriez pouvoir
utiliser le sélecteur de couleur que nous puissions entrer dans la couleur,
obtenir le sélecteur de couleur, et vous pouvez également cliquer sur la partie
du plan dont vous souhaitez
faire correspondre la couleur Pour moi, cela ne fonctionne pas. Ceci sélectionne
la correspondance statique. Je vais donc juste
prendre une couleur qui peu près à celle du corps
de l'avion. Ce serait parfaitement
bien, je pense. Maintenant, encore une fois, si
nous appuyons sur compiler, nous avons des projectiles qui se déplacent
à différentes vitesses, et ils
représentent en fait la couleur du vaisseau qui
les tire Vous pouvez également modifier des éléments tels que la force d'émission
si vous ne vouliez pas qu'elles brillent ou si vous vouliez qu'
elles brillent plus ou moins Mais c'est tout. Voilà,
les ennemis sont prêts et c'est fait. n'est qu'une petite tâche secondaire pour vous, interrompez à nouveau le contenu
entre les sujets
et commencez peut-être à examiner
différentes variables
qui, et commencez peut-être à examiner selon vous pourraient fonctionner pour une cadence de tir minimale
et maximale. Peut-être ne ressentez-vous pas
assez de différence entre les différents
ennemis lorsqu'ils apparaissent Changez peut-être la couleur, les différents types
de vitesse de déplacement, les dégâts infligés,
exposez d'autres variables, jouez avec
toutes les valeurs auxquelles
vous savez maintenant avoir accès. Ensuite, nous allons examiner la fonctionnalité Player Fire. Ce sera
légèrement différent, un peu plus pratique,
mais vous pouvez voir que nous avons
déjà de très
bonnes bases sur mais vous pouvez voir que nous avons
déjà de très lesquelles nous appuyer.
22. 21 - Lecteur ProjectileFire: Vous pouvez désormais passer
directement que le joueur tire de la
même manière que l'ennemi. Nous allons donc réutiliser
une partie de cette logique de base, les
propriétés exposées des
projectiles, afin de contrôler un peu
plus précisément si et quand le
joueur doit tirer Donc, si nous entrons et ouvrons le lecteur
BP Underscore Plane, nous avons deux
options différentes. La première est que de nombreuses
personnes peuvent simplement les fonctionnalités de base en dehors des fonctions dans leur graphique d'événements
principal. Une autre chose que je
voulais présenter, c'est que nous pouvons créer nos
propres graphiques personnalisés. Le graphique d'événements par défaut
inclut donc des éléments
tels que le début
du jeu, les événements, ces
éléments intégrés
au moteur par
défaut. Parfaitement bien. Une chose que j'aime bien
faire, c'est que nous pouvons appuyer sur le bouton plus ici et créer un tout nouveau graphique. Je vais donner le nom
de cette nouvelle entrée graphique. Et c'est là que
nous mettrons toute notre logique spécifiquement basée sur la réception
d'informations pour le joueur. Encore une fois, nous avons commencé à
ajouter des éléments plus tard, comme
un bouton de redémarrage ou un bouton de menu ou différents
types de powerups, etc.
Toutes ces entrées
pouvaient être suivies ici dans un seul endroit
pratique. Pour enregistrer l'
entrée Fire, nous allons enfin
utiliser un événement d'entrée. Nous n'utilisions donc auparavant
que les variables
stockées dans des éléments tels que le trait de soulignement IA dans mouvement de
notre poignée que
nous avons observé ici Voici donc notre exemple d'
utilisation de la seule
valeur flottante renvoyée. À l'intérieur du graphique de saisie,
nous allons cliquer avec le bouton droit de la souris et rechercher IA Underscore Fire Et nous voyons que nous avons
l'option ici, nous voulons réellement utiliser cet événement qui est renvoyé. Ainsi, chaque fois que vous appuyez
sur le bouton de tir, quelque chose peut se
produire à cause de ce résultat déclenché par
la réception de l'entrée. Maintenant, la première chose que
nous voulons toujours prendre compte, c'est que nous voulons un feedback
immédiat, quelque chose qui relève davantage
de la conception du jeu et de la théorie, c'est que lorsque le joueur
appuie sur quelque chose, s'attend à recevoir
un feedback immédiat. n'y a aucun décalage entre le qu'ils pressent quelque chose
et qu'il se passe quelque chose. C'est pourquoi,
dès que l'entrée est reçue, nous voulons nous assurer que
quelque chose commence à se produire. Nous avons donc un tas d' événements
différents
qui sont déclenchés ici, et nous voulons tout d'
abord utiliser Started. Nous voulons donc nous assurer
que la fonction d'incendie est appelée immédiatement au démarrage. Nous allons
appeler ici la
fonction fire de notre classe mère. Nous pouvons voir qu'il s'agit
de la classe de base. Commencé est appelé
immédiatement dès que cette pression sur le bouton est reconnue ,
puis terminée
est
déclenchée dès que le
bouton est relâché. Nous pouvons donc utiliser ces différentes
étapes
de pression sur le bouton, mais l'
important pour le moment est que feu soit immédiatement déclenché. Ensuite, une fois que cette première
fonction de déclenchement aura été appelée, nous allons
extraire l'épingle d'exécution, et nous allons
créer un autre chronomètre par nom de fonction. La fonction, bien sûr,
sera le feu. C'est surtout par habitude. Je vais juste reproduire
la fonction d' incendie que nous avons
déjà, et encore une fois, je vais simplement la placer en
dessous du chronomètre parce que nous savons que c'est
celle que nous utilisons ici. Pendant le temps qui
s'écoule, nous allons
partir d' ici et je vais
trouver notre cadence de tir. Nous allons donc obtenir
la valeur de la cadence de tir. Et je pense que pour le
joueur, même si je l'ai dit, nous devrions peut-être envisager
la randomisation, c'est une autre de
ces choses maintenant lorsque l'on pense à des choses qui relèvent
davantage d'un principe de conception Nous voulons probablement
définir ce paramètre
plutôt que d'avoir un
minimum et un maximum, le joueur s'attend à
ce qu' chaque fois qu'il tire et qu'il joue au jeu, sa cadence de tir
soit la même. À moins que vous ne
fabriquiez quelque chose comme un roguec dans lequel
vous
dites spécifiquement au joueur qu'en fonction votre personnage ou de statistiques aléatoires, la cadence de tir peut être différente Dans ce type de jeu,
ils s'attendront
à ce que la
sensation soit
toujours la même pour pouvoir s'habituer aux mécanismes et
apprendre à jouer. Donc, si nous appuyons sur compiler,
nous allons récupérer la cadence de tir, et nous allons la
régler à 0,2. Nous allons nous assurer de le
configurer pour qu'il soit en boucle. Donc, en gros, ce que nous voulons
dire, c'est que nous allons appuyer sur le bouton, puis une fois que vous
maintenez le bouton enfoncé, nous allons appeler
cette fonction de sorte que lorsque vous maintenez le bouton enfoncé,
vous continuerez à tirer. Ensuite, nous pouvons revenir
ici et nous pouvons maintenant utiliser cette fonction
terminée. Donc, comme je l'ai mentionné,
cela s'appelle lorsque vous relâchez le bouton
que vous maintenez enfoncé. Ainsi, une fois terminé, nous
pouvons utiliser une autre partie de la fonctionnalité intégrée
, et c'est une très bonne façon de garder votre code
à nouveau propre et ordonné Vous avez peut-être vu dans d'autres
exemples que cela sur l'événement
avec certains retards, ce qui peut être très déroutant
si vous pensez à exécuter un événement et un délai , en
combinant essentiellement une logique, qui est censée s'exécuter
constamment à un intervalle donné, puis en
essayant de le retarder tout en Nous allons donc éviter un code
bâclé comme celui-ci. Nous allons plutôt
trouver une fonction nommée clear
Tir par le nom de la fonction. Nous allons donc utiliser cette fonction ici, et c'est vraiment simple et
agréable. Nous allons saisir le nom de
notre incendie ici, donc nous allons récupérer le texte ici, puis nous allons le
coller ici. Nous avons donc maintenant un contrôle
total sur le moment où cela a commencé
et quand cela se termine. Donc, la première fois que nous
appuierons sur le bouton de tir, nous allons appeler
la fonction d'incendie. Nous allons ensuite également nous
assurer de
continuer à nous en souvenir tant que nous
maintenons le bouton enfoncé. Mais si jamais nous
voulons que cela cesse, dès que nous reconnaîtrons que le
bouton a été relâché, nous allons effacer le nom de
cette fonction, donc cette fonction de minuterie. Il va donc le trouver
parce qu'ils partagent
le même nom. Cela va annuler
la boucle ici, et cela signifie que nous
ne tirerons plus. Nous n'avons donc pas de fils
qui circulent partout, choses qui essaient de
s'annuler au fur et à mesure de l'événement. Il ne s'agit que d'un seul incendie, et nous n'ajoutons qu'une
pile toutes les 0,2 seconde. Appelez une fonction vraiment simple. Encore une fois, très faible surcharge, très bon en
termes de performances, très propre à lire et beaucoup
plus facile à gérer. Et vraiment pour le joueur, cela ne laisse que
deux choses à régler. La fonctionnalité de tir
est donc relativement simple. Nous voulons simplement
entrer dans les détails du cours ici et apporter des modifications
similaires à ce que nous avons fait auparavant. Donc, je pense que la vitesse de
déplacement des projectiles, 2 500 pour le joueur, est bonne. Laissez l'émissif,
c'est parfaitement bien. Et nous allons juste
changer de couleur. Mes joueurs sont plutôt
de couleur bleutée, alors nous allons y aller.
Avec ça juste ici. Essayez peut-être de l'égaler
un peu plus. Comme je l'ai mentionné, sur votre système, vous pourrez peut-être vous en tirer
avec le sélecteur de couleurs Mais pour moi, il s'agit
simplement de sélectionner le noir. Je vais donc simplement régler
cela de manière plus manuelle. Nous pouvons ensuite appuyer sur compiler, enregistrer, puis nous pouvons entrer
et jouer à tester cela. Voilà. Ainsi, le joueur
dispose d'un feedback continu sur le bouton. Cela tourne en boucle
jusqu'à ce que nous relâchions
le bouton de tir. Donc, comme je l'ai mentionné,
vraiment beau et propre. Si vous ne l'avez jamais vu
auparavant, je ne
trouverai pas de didacticiel spécifique
pour les expliquer, mais jetez un œil sur YouTube
avant de regarder un film
comme Unreal Engine, Blueprint Fire Function
ou Gunfire Logic, quelque chose de générique comme ça
et voyez le résultat que Faites attention à
ceux-ci en particulier,
ce qui vous amènera à participer à l'événement,
et éliminez certains délais
en fonction
de cadence de
tir et voyez
comment ils utiliseront éléments tels que des portails pour
annuler
l'appel de la fonction incendie lorsqu' un bouton est
enfoncé ou relâché Ensuite, comparez cela à ce que
nous venons de faire ici avec deux appels très simples pour démarrer la fonction et la terminer
au fil du temps. Encore une fois, comme je l'ai mentionné, avec les exemples épiques
et autres choses de ce genre, il s'agit jamais de faire appel à
d'autres personnes ou à d'autres projets. Explicitement. Mcde n'est certainement
pas toujours le meilleur, mais c'est juste pour
vous faire réfléchir et critiquer
ce que vous voyez au fur et à mesure que vous apprenez, car l'
une des pires choses que vous puissiez faire est de
tout suivre aveuglément et de
supposer que c'est toujours
la meilleure ou la seule supposer que c'est toujours
la meilleure ou la Il y aura toujours différentes manières d'
aborder un problème, et je veux simplement
vous demander si
ce que vous faites dans le cadre de vos projets ou ce que vous voyez en ligne est une méthode que vous souhaitez
mettre en œuvre dans vos propres projets pour les rendre gérables et
faciles à utiliser C'est à peu près
tout pour les projectiles. Encore une fois,
assurez-vous simplement que vous avez bien
vérifié que les valeurs précises
sont
renseignées si vous souhaitez suivre les étapes supplémentaires que vous pourriez prendre pour
améliorer votre projet. Je vais laisser cela sur égalité avec l'exemple de projet, mais nous avons des problèmes
qui ne sont peut-être pas facilement perceptibles, mais
ils existent certainement. Par exemple, nous pouvons envoyer du
spam en cliquant sur le bouton de tir
plus rapidement que la cadence de tir. C'est vraiment difficile à
faire parce que j'ai réglé la cadence de tir relativement
rapidement de toute façon, mais vous pouvez voir que
je clique ici plus rapidement que si je
maintenais simplement la touche. Alors réfléchissez peut-être à la façon dont vous
pourriez résoudre ce problème vous-même. Je ne vais pas
suivre ce processus. Il s'
agirait essentiellement de suivre
une valeur sur une minuterie
séparée lorsque vous appuyez pour la
première fois sur le bouton. La prochaine fois que vous
appuierez sur le bouton, si ce chiffre est inférieur à
la cadence de tir définie, il vous suffira d'annuler l'
appel de la fonction incendie. Dans ce cas, il ne s'agit pas d'un projet
si complexe que je pense vraiment qui
fasse une grande différence. Et comme je l'ai mentionné, cette
même fonctionnalité se trouve dans l'exemple de projet avec lequel nous
essayons de toute façon d'atteindre la parité. Mais c'est juste un bon exercice de réflexion pour voir si vous pouvez
intégrer une logique similaire, empêchant le joueur
de cliquer et tirer plus vite que
la cadence de tir donnée. Notre prochaine étape principale, cependant, c'est
que les navires soient armés. Le joueur et les
ennemis tirent tous les
deux, en utilisant des couleurs et des cadences de tir
différentes. Vous pouvez également modifier à nouveau ces
valeurs. Si vous trouvez que le
jeu est trop difficile ou trop facile, modifiez des éléments tels que les dégâts, qui sont infligés en fonction où les projectiles
ont été tirés, de la cadence de tir,
etc. Ensuite, nous allons
revenir à l'utilisation
de notre générateur Actor générique. Et je vais commencer
à ajouter des arrière-plans défilants pour que les choses nous paraissent un peu plus intéressantes
23. 22 - ScrollingBackgronds: Il est temps d'aller un peu
plus loin dans ce
projet et de le
faire ressembler à un jeu. Nous allons ajouter de l'eau,
des îles défilantes, et nous allons le faire en
réutilisant notre système Spanus, c'est
pourquoi nous l'avons conçu
pour avoir une configuration aussi générique Nous pouvons fermer tous
les cours que nous avons
actuellement. Cliquez avec le bouton droit sur l'onglet principal et sélectionnez
simplement pour fermer les autres onglets Cela supprimera
tout ce dans lequel vous ne vous trouvez pas actuellement, puis nous
pourrons simplement fermer le lecteur. De retour dans le démarrage de la vue principale, nous voulons utiliser le
bouton Ajouter juste ici, et nous allons
ajouter un avion simple. Donc, si nous optons pour les formes et que nous pouvons trouver un plan, nous voulons
simplement que ce
soit une surface plane. Nous allons
réinitialiser l'emplacement Nous allons
donc le mettre à zéro en
cliquant sur le
bouton d'annulation juste ici. Appuyez sur le bouton de verrouillage pour assurer que l'
échelle est uniforme, puis nous allons simplement régler la valeur sur 80
pour couvrir l'ensemble de
la zone de jeu, c' est-à-dire tout ce
que nous pouvons voir Nous pouvons également nous
débarrasser du sol. Nous
l'utilisions auparavant uniquement pour le contexte afin de voir exactement où et
quand nous nous déplaçons. Nous utilisons cette grille
essentiellement pour détecter les mouvements. Nous n'en aurons plus besoin, nous pourrons
donc nous débarrasser de l'emplacement réel
de l'avion lui-même. Nous voulons que ce soit
moins 4 000 sur le z. Et encore une fois, cela dépend simplement configuration de ma caméra, l'avion et de la position des ennemis. Vous constaterez peut-être que la configuration de votre niveau est
légèrement différente, mais si nous partons d'un projet à
peu près similaire pour le moment, vous pourrez le
modifier ultérieurement fait d'avoir une telle
profondeur rend les ombres un peu plus
subtiles et nous laisse de la place pour les
îles flottantes, car certains
des objets que j'ai fournis
sont intentionnellement assez grands. À partir du dossier, nous allons accéder
à notre dossier de ressources. Nous trouverons les matériaux,
et nous pouvons trouver l'eau soulignée par le MI et simplement la faire
glisser sur l'avion Cela
nous donnera donc un beau matériel aquatique animé simple et
basique. Comme je l'ai mentionné,
certains détails et propriétés
devront peut-être être modifiés ici, comme la taille de l'
avion ou son emplacement. nous procédons à une analyse
complète et
affinons le sujet une fois que nous sommes arrivés à la fin du sujet Cependant, nous procédons à une analyse
complète et
affinons le sujet une fois que nous sommes arrivés à la fin du sujet en
fonction de l'apparence
des choses Si vous souhaitez changer
votre eau, encore une fois, nous pouvons double-cliquer sur le matériau MI
underscore water Faites-le glisser dans la fenêtre ici. C'est une bonne façon
d'
utiliser une fois de plus l'instance
matérielle. Si vous trouvez que l'eau
coule trop vite ou si vous
n'aimez pas la couleur, nous pouvons obtenir des informations en direct
même pendant que nous jouons pour voir exactement
ce que vous vouliez
faire avec des
éléments tels
que
le fondu en profondeur , la distance, les différentes propriétés de
couleur, etc. Vous avez donc un contrôle total sur l'apparence que vous souhaitez donner à
votre eau. Je vais le
garder tel quel, mais juste pour dire
que ces valeurs sont là si vous
voulez les modifier. Ensuite, nous voulons
considérer nos îles. Nous allons donc retourner
dans notre dossier Blueprints. Nous allons créer un nouveau
dossier ici. Nous appellerons celle-ci « îles ». le dossier des îles, nous allons cliquer avec le bouton
droit de la souris, accéder à classe
Blueprint,
créer un nouvel acteur. Nous avons juste besoin de
quelque chose nouveau présent dans le monde, et nous l'appellerons
BP Underscore Island À l'intérieur de la classe, configuration
très standard maintenant. Nous allons ajouter
un nouveau maillage statique. Nous allons la définir comme racine de scène
par défaut Nous allons
donc remplacer la racine de scène
par défaut ici Une fois le
maillage statique sélectionné, nous allons passer
au panneau des détails. Nous trouverons l'îlot de
soulignement SM rond, donc le plus grand pour
commencer Nous pouvons appuyer sur F dans le point pour voir à quoi ressemblerait cette
île. Ensuite, nous voulons simplement passer
aux propriétés de collision, et nous allons prendre les détails de la
collision ici. Nous allons le réduire, le
régler sur « Pas de collision ». Nous allons désactiver la fonction de
génération d'événements de chevauchement. Il suffit de s'assurer que
cela n'a pas de physique, qu'il n'y a pas de contrôles de chevauchement. Ce sera un objet jetable très
bon marché,
qui n'est là que pour les visuels Maintenant, avant même de commencer utiliser notre générateur pour
les mettre au monde, nous savons que cela
va paraître très répétitif, très ennuyeux Nous allons obtenir le même maillage
statique à la même taille, la même rotation à chaque
fois qu'un maillage est créé. Passons au début du jeu, et nous allons résoudre
ce problème immédiatement. De même, nous
allons nous débarrasser de l'appel de fonction Actor
Begin
Overlap Nous voulons commencer à jouer
ici, et nous pouvons faire choses simples à partir de
l'épingle d'exécution ici. Donc, tout d'abord,
nous pouvons aléatoirement un peu
l'échelle de l'
acteur Nous allons donc appeler le set
Actor scale trois D. Et nous allons
procéder d'une manière un peu étrange. Mais si nous cliquons avec le bouton droit de la souris et
recherchons un flottant aléatoire dans la plage, nous pouvons
redéfinir cette plage en
fonction d'un vecteur deux D. Nous allons donc
créer une nouvelle variable. Nous appellerons cela
une échelle Min Max. Déposez-le vers le bas, trouvez le
vecteur deux D. Il compile et fournit
des valeurs ici pour peut-être quelque chose comme 0,8 à 1,2. Déposez-les comme
nous l'avons fait auparavant. Comme vous pouvez le constater, encore une fois, nous
en sommes arrivés au point où une grande partie du code va
devenir très familière. Et c'est cette
idée de répétition. Nous vous aiderons à mieux vous
familiariser avec le projet et à travailler avec Unreal.
Nous allons donc scinder la structure en. Nous allons intégrer cela au
minimum et au maximum. Et nous pouvons simplement
prendre notre valeur flottante ici et
la convertir en vecteur. De la façon dont cela fonctionne,
la façon dont nous utilisons un flottant ou
un vecteur peut sembler un
peu étrange. En gros, je vais
juste m'assurer que
le X, le Y et le
z prennent le résultat. Donc, si cela choisit
1,1, cela signifie que les X, Y et Z seront
tous définis sur 1,1. Maintenant, si vous
vouliez étendre
les choses , ayez un contrôle plus précis. Bien entendu, vous savez que vous pouvez diviser la broche de structure du vecteur et peut-être créer un flottant
aléatoire sur le X, le Y et le z individuellement Le problème que je trouve, c'est
que vous n'avez
pas vraiment contrôle précis empêcher le maillage
d'être complètement créé. Vous pouvez vous retrouver avec quelque
chose de vraiment bizarre et écrasé ou de vraiment
étrange et étiré Donc, pour cette raison, je vais simplement le configurer
pour qu'il soit uniforme,
afin qu'il s'agisse simplement de redimensionner tous les
axes ensemble. Ensuite, nous pouvons également saisir
notre maillage statique. Nous allons le placer dans
le graphe des événements, et nous allons extraire de
notre référence de maillage ici, donc d'une référence à notre composant, nous allons rechercher la fonction de maillage statique
définie. Nous voulons
ici celui-ci, celui qui nous
donnera le composant de maillage, juste pour être sûrs que vous avez vu que nous voulons passer au maillage
statique des composants et définir le
maillage statique. Pas celui-ci ici. agit en fait de mettre à jour
la variable elle-même, alors que cela prend le
composant que nous avons et il accède aux détails via
notre panneau de détails ici. Nous voulons donc peut-être également randomiser le maillage statique que
nous utilisons Nous pouvons donc partir d'
ici. Vous avez probablement une idée de la direction que cela
va prendre, car encore une fois, nous l'avons déjà fait à
de nombreuses reprises. Nous n'avons que deux
options statiques différentes pour les îles Je vais donc
utiliser un nœud sélectionné. Et comme nous n'en avons que
deux, le moyen le plus simple moi de le voir est que
si
nous en avions plus, nous pourrions utiliser un entier
aléatoire dans une plage, et si nous en avions cinq,
nous choisirons une plage 0 à 4 ou un, cinq, peu importe Et en fonction de ce qui a été choisi entre cette plage de nombres entiers, il choisirait l'un des quatre
ou cinq modèles différents. Maintenant, comme nous n'en avons que deux, je vais juste utiliser un booléen Je vais choisir une balle
au hasard ici. Nous n'avons même pas besoin que
ce soit une variable. Ensuite, nous avons en gros
50 % de chances de frayer sur la grande
île ou sur la petite île Donc, gentiment et simplement, nous
n'avons pas besoin de le rendre
trop complexe, au moins nous obtenons maintenant
une certaine randomisation Nous pouvons faire apparaître la même grande
île trois fois de suite, mais au moins l'échelle
sera légèrement différente
sur chacune Si ce n'est pas le cas, il
se peut que nous fassions un tri aléatoire entre la grande et
la petite île Et encore une fois, ils
auront toujours une
belle mise à l'échelle aléatoire appliquée Et enfin,
ils
auront toujours la même apparence. Nous pouvons donc récupérer les détails
de notre rotation, et nous pouvons également
les rendre aléatoires Nous allons donc extraire
du maillage statique, et je vais trouver
la rotation active définie. Dans ce cas, nous voulons uniquement effectuer une rotation autour de l'axe z,
car n'oubliez pas que cela va se faire vers le haut
ou vers le bas dans le monde. Nous allons donc cliquer avec le bouton droit de la souris
et diviser la structure en. En fait, je vais juste
être un peu paresseux et saisir le
flotteur aléatoire à portée. Dupliquez-le ici,
nous allons juste le faire
pivoter de 0 à 360 degrés. C'est donc l'un de ces
moments où je ne pense pas qu'il soit utile de le
promouvoir en tant que variable. Je pense que c'est assez clair.
Lorsque nous examinons quelque chose, nous définissons la rotation
des acteurs, et nous allons de 0 à 360, ce qui signifie évidemment que nous
autorisons une rotation complète Je ne
recommanderais donc pas vraiment de
le promouvoir en tant que variable. Certaines choses peuvent être bonnes
comme un chiffre magique, autant plus
que nous savons que nous n'allons pas mettre
à jour ou les modifier. Il n'y a aucune raison pour laquelle
je
pense que nous allons vouloir l'
associer à une autre solution. Le fait
de le promouvoir en tant
que variable signifiait-il que nous n'avons pas besoin de
revenir dans le code ? Et si nous voulions changer
complètement l'échelle sans
trouver le code lui-même, nous pourrions la définir sur
0,4 ou 2,5 ou ce que nous voudrions
pour vraiment
exagérer la mise à l'échelle.
Je ne vais pas faire ça. Je vais garder cela à 0,8 et 1,2. Donc, avec ces trois
changements, nous allons
avoir quelque chose qui semble maintenant
beaucoup plus aléatoire et un peu plus unique que le simple fait que les deux mêmes objets
apparaissent exactement sur
la même échelle
et dans
la même rotation lorsqu'ils sont
mis en jeu Nous pouvons maintenant passer
au mouvement. est pourquoi nous avons conservé l'événement. Encore une fois, nous voulons un mouvement agréable,
constant
et fluide, et avec une logique très
simple, cela ne deviendra pas
trop coûteux à exécuter. Nous allons tirer parti de
l'épingle d'exécution et nous trouverons le monde de l'
acteur publicitaire. Nous voulons celui-ci
ici ? Ajoutez Actor World Offset pour l'ensemble de l'
acteur de l'île. Donnons-nous de la marge de manœuvre,
car nous devons faire quelques calculs
ici pour le décalage. Nous allons créer une nouvelle variable. Je vais à nouveau promouvoir les Delta Seconds, juste
pour être paresseux. Passez cette valeur à variable pour
obtenir le bon type, et j'appellerai cela
une vitesse de déplacement unique. Appuyez sur Compiler, et nous l'avons définie une valeur par défaut d'environ 400 unités de vitesse, mais nous voulons nous
assurer de lui donner
une valeur négative,
donc moins 400 pour assurer que cela fait
défiler l'écran vers le bas Nous pouvons nous débarrasser de
notre vitesse de déplacement. Nous voulons simplement
multiplier
notre vitesse de déplacement par le delta des secondes. Et nous allons
intégrer cela à notre valeur ici. Je viens de m'en rendre compte en
regardant ça. Nous ne voulons pas ajouter
de décalage mondial ici, nous allons
donc le supprimer. Nous voulons en fait
ajouter le décalage local. Nous allons donc utiliser le décalage local d'ajout d'un
acteur. Divisez la structure du Delta en
p, puis nous l'intégrerons notre position Delta X,
car encore une fois, nous ne faisons que la déplacer
sur le X vers arrière sur l'écran. Nous n'avons pas besoin de calculer avec de la physique ou
quelque chose comme ça, ou d'essayer de créer une
pseudo-physique au fil du temps. Nous n'utilisons donc pas
l'offset mondial. Nous pouvons utiliser le décalage local. Je vais prendre l'endroit où se trouve actuellement l'
acteur, et cela ajoutera simplement cette
valeur à cette direction X. En fait, la raison
qui m'est venue à l'esprit est que si nous revenons au tutoriel
Shoot 'em up, nous passerons à nos projectiles
et ouvrirons une classe de projectiles Nous pouvons voir l'événement ici. C'est en fait la même logique que celle que nous utilisons pour
déplacer nos projectiles L'île n'est essentiellement
qu'un projectile
très lent et très gros dans la
façon dont nous avons notre code Encore une fois, il s'agit en fait de
quelque chose qui utilise le même code. Il ne faut pas oublier que nous
procédons à nouveau à une petite
duplication,
ce qui pourrait être le cas
dans le cadre d' un projet plus vaste où vous commencerez à
examiner des éléments tels que la composition, où nous pourrions avoir un composant de
mouvement personnalisé Comme il est tellement
similaire et que tout
ce dont nous avons vraiment besoin, c'est d'une
direction ou d'une vitesse, nous pouvons
exposer ces valeurs dans un composant personnalisé et nous pourrions les confier aux différents acteurs qui en ont besoin. Comme je l'ai mentionné, c'
est un peu hors de portée
du contenu que nous
examinons actuellement, mais juste un élément à prendre en compte. Ce n'est pas la fin du monde, donc nous allons
continuer comme ça. Et maintenant, nous pouvons réellement
commencer à les générer. C'est donc là que la simple classe d'acteur
générique, la classe spawner
que nous avons créée deviendra très utile Donc, si nous passons à
notre niveau,
je veux d'abord tester très rapidement à quoi ressembleront
les îles Je vais
donc prendre l'une des îles et
la déposer sur le
hydravion en bas. Nous voulons avoir une idée approximative de la hauteur à laquelle nous
voulons le générer Encore une fois, cela
se résumera à quelques ajustements. Je vais en faire une partie
maintenant, mais je vais probablement l'affiner hors écran Donc je pense qu'en fait, la première fois que j'en ai fait tomber un, c'était, en fait, le même que l'avion
lui-même, donc -4 000 Nous pouvons donc utiliser
cela comme base de référence. Nous allons probablement placer
le générateur au même endroit. Nous voulons nous
assurer que cela se passe plus loin de la caméra. C'est donc quelque chose que nous
pouvons maintenant tester facilement. Nous allons chercher
notre acteur de caméra. Nous allons l'épingler ici,
et nous pouvons commencer à peaufiner et à nous
assurer que tout
apparaît hors écran. Donc, pour la grande île, peut-être qu'une partie de prise en compte que nous pouvons atteindre une échelle de 1,2, souvenez-vous, est notre échelle
aléatoire Donc, si nous obtenons le
plus gros spondm insulaire, il
faut qu'il soit au
moins
11 360 sur le X pour être complètement hors de
vue lorsqu'il y a un spondu C'est donc le
point essentiel dans lequel nous
voulons que notre générateur insulaire
soit placé Donc, en fait, je vais
prendre ceci ici, mettre le zéro sur le y, donc nous allons
commencer par le milieu. Ce que je vais faire,
c'est qu'avec le fichier sélectionné, je vais revenir dans
le dossier du plan ici Je vais aller dans
le dossier spawners. Sélectionnez ceci. Et une fois cette
option sélectionnée dans le tirage au sort,
voici un conseil pratique que vous
allez voir ici. Nous pouvons cliquer avec le bouton droit de
la souris sur cette île. Nous allons remplacer Actor, et nous pouvons le remplacer par
l'élément que nous
avons actuellement sélectionné dans notre tiroir
de contenu. Nous allons donc le renommer
. Nous pouvons voir que cet objet est maintenant un trait de soulignement
BP. Je vais renommer celui-ci en
Island spawner . Ce que cela fait est donc
clair. Et en fait, quand
il s'agit de nommer, cela va commencer à devenir
un peu bâclé comme nous Ce que j'aurais dû faire
, c'est que nous appellerons ce spawner underscore island parce que nous pouvons voir que
cela Nous pouvons donc également
renommer celui-ci
pour faire apparaître un ennemi souligné. Il est donc maintenant un peu clair qu'il s'agit de
notre générateur d'ennemis. C'est notre générateur insulaire, et ils vont être
regroupés Maintenant, une autre chose que nous
pouvons considérer comme un problème est que le maillage statique
n'est pas de la bonne taille. Je pense que j'ai peut-être
envisagé un autre actif avec lequel je
travaillais auparavant. Nous voulons donc simplement
augmenter ce chiffre à quelque chose comme 120 sur tous les axes, peut-être même 160. Parfaitement bien. L'essentiel est de
couvrir l'ensemble de la caméra. Nous pouvons donc voir maintenant qu'en mode jeu, l'eau
recouvre tout. Le générateur sera
situé juste à l'extérieur de la caméra afin que
nous puissions nous assurer que les
îles apparaissent Maintenant, une chose vraiment importante que
j'allais complètement
oublier , c'est que si nous
revenons sur l'île des créateurs,
lorsque je l'ai peaufinée,
j'ai réglé l' Maintenant, nous voulons toujours nous
assurer de
les garder uniformes, car dans
certains codes d'apparition, vous pouvez prendre en compte la rotation
de l'échelle de la position de l'
acteur comme point
d'apparition Nous ne voulons donc pas
ajouter de valeur par défaut, peu comme un décalage prédéfini
à la mise à l'échelle de quoi que
ce soit, alors assurez-vous simplement de revenir à un. Ensuite, pour que cela fonctionne
pour le frai sur l'île, nous allons
l'ajouter et sélectionner notre classe d'îles Nous voulons donc l'îlot de
soulignement BP. Nous allons autoriser un
décalage aléatoire, nous allons donc cocher cette case. Nous fournirons une distance de
décalage de, disons, 5 000
unités de chaque côté. N'oubliez donc pas qu'il s'agit simplement d'utiliser les fonctionnalités intégrées que
nous avons déjà implémentées lorsque nous avons
planifié un
peu à l'avance lors de la création de notre
classe de générateur générique. Et pendant les intervalles d'apparition, nous ne voulons pas que trop d'îles
encombrent Nous allons donc régler ce
paramètre à environ
5 secondes et toutes les 10 secondes. Donc 5 à 10 secondes, nous
devrions trouver une nouvelle île. J'ai juste un
bref résumé de la raison pour laquelle nous utilisons le décalage ici. Rappelez-vous que nous
l'avons créé dans
notre base de générateurs, que
nous avons notre branche sur le début du spawn ou qu'
une vérification booléenne est ici,
désolé, pour savoir si nous devons Si nous disons non, nous créerons simplement l'île exactement à la pointe
du générateur, qui signifie que nous n'avons qu' une ligne droite
d'île constante,
ce qui, encore une fois, serait
un peu étrange Si nous disons oui, alors
il choisira flottant aléatoire dans
une
plage, ce qui, dans notre cas, nous l'avons fixé à 5 000, soit entre
5 000 sur le Y et moins 5 000 sur le Y. Cela devrait
donc nous donner une grande
variation dans leur point de départ, leur échelle, leur rotation
et même le maillage Nous pouvons donc tester cela maintenant, si nous
appuyons sur nous, nous devrions voir
quelque part dans les 5 secondes. Je vais me débarrasser de
l'appareil photo très rapidement. En mode jeu, nous pouvons tester cela et attendre
un peu, et nous devrions voir les
îles commencer à apparaître Nous cherchons à nous assurer
qu'ils ne se contentent pas d'
apparaître, à nous
assurer qu'ils
vont dans la bonne direction,
ce qui, je pense, peut nous
poser un problème ici, et aussi à ce qu'ils
apparaissent correctement
dans le décalage que nous avons
fourni et aussi à ce qu'ils
apparaissent correctement
dans le décalage que nous avons
fourni.
Donc je ne
vois rien. Il y a une toute petite île. Cela a peut-être pris
10 secondes, mais nous avons
là une toute petite île qui s'affleure
depuis le bas C'est un peu comique, mais je trouve que ça
a quand même l'air plutôt bien Et nous devrions voir,
espérons-le, d'autres îles arriver dans les
prochaines secondes. OK, nous avons donc en fait
beaucoup d' îles. L'un des problèmes nous avons, c'est qu'avec
leur rotation aléatoire, elles avancent en fonction la direction dans laquelle
elles sont apparues. Allons-y donc. Je pense que j'ai peut-être
gâché une partie de la logique lorsque nous avons
créé la logique du mouvement. Et je pense, en fait,
qu'il s'agit simplement d'un retour à ce que nous
recherchions auparavant. Pour en revenir à la classe insulaire,
je pense que c'est à cela que j'avais en tête, le
décalage local par rapport au décalage mondial. Ce serait donc bien si
nous pouvions conserver le code, similaire au
projectile, et nous pourrions probablement changer le code du
projectile à la Mais je pense que ce que
nous faisons juste pour rester simple et agréable, nous allons
changer cela par rapport à notre décalage
local, car souvenez-vous que lorsque nous effectuons un ajout
local ou un décalage par rapport à la
position locale de l'acteur, cela tiendra compte la rotation actuelle
qu'il a,
parce que nous voulons faire une rotation
ou si nous faisons pivoter l'autre à 180
degrés la direction, puis vers l'avant localement
a changé, nous allons
donc passer
dans l'autre sens. Cela dit, je me suis
rendu compte que nous pourrions probablement faire quelque chose d'un peu plus ici, en nous concentrant sur la hiérarchie. Encore une fois, c'est
quelque chose j'ai
simplement oublié lors du pré-développement. Et c'est moi, je pense un
peu sur place, c'est
pourquoi je m'
en tiens à cela juste pour montrer comment nous pouvons résoudre différents
problèmes de différentes manières. Donc, ce que je suis tenté de faire, c'est parce que je
veux garder cette logique. Je veux faire le mouvement
offset local. Je pense que
nous allons plutôt ajouter
un nouveau composant. Nous allons créer un composant de scène
vide et en faire
le nouvel itinéraire. L'élément de scène
sera donc la façon dont nous faisons face, qui sera
toujours en avance dans le monde. Et je pense que
nous allons plutôt définir notre rotation, mais nous n'allons pas définir
la rotation de l'ensemble de
l'acteur. Nous allons laisser le composant de scène
toujours orienté vers l'avant. Et cela ne fera
que vous donner un bel exemple des différentes manières dont nous pouvons également
utiliser la hiérarchie. Nous pouvons récupérer notre correspondance statique, et à la place, nous allons
définir la rotation de celle-ci. C'est également quelque chose
que nous n'avons pas encore vu Nous pouvons
donc définir la rotation
relative de nos composants par rapport au composant parent
auquel ils sont attachés. Mais c'est exactement la
même logique. Nous allons
le brancher. Nous allons prendre ce flotteur aléatoire
que nous avons déjà, diviser l'épingle de la structure
comme nous l'avons fait auparavant. Nous allons simplement le brancher sur le Z ici à la place. Cela signifie que nous pouvons conserver exactement la même logique de mouvement. Et maintenant, nous ne
changeons pas la rotation de l'ensemble de l'acteur ni
la façon dont il fait face. C'est toujours dans
la même direction. Nous modifions simplement la
rotation de l'élément visuel. Un peu comme nous avons
séparé cela des avions,
où l' élément visuel n'
est que le corps de l'avion, mais où la
collision réelle et ce sur quoi tout repose, c'
est cette collidéosphère Donc, si nous y retournons et jouons, nous devrions voir que cela fonctionne maintenant. Une autre commande de console utile est que nous pouvons appuyer sur
la touche Tilda, taper slow mo, puis régler ce paramètre sur le nombre de fois
plus rapide que nous voulons que cela aille Donc, si nous réglons ce
paramètre sur slow mo 5, vous pouvez constater que cela se
déplace cinq fois plus vite, beaucoup plus facile de
tester et si
les îles apparaissent correctement Ils se déplacent donc maintenant vers le
bas de l'écran. Cela semble
fonctionner correctement. Nous n'avons pas oublié ce test, où nous n'allons pas
continuer à générer des objets Si le joueur est mort. Encore une fois, commande console, nous
pouvons taper un niveau de redémarrage, revenir directement à Slom 5, et nous pouvons faire quelques tests
juste pour nous assurer que les îles, juste nous
assurant de faire plusieurs
tests sur le pouce, fonctionnent correctement. Ils regroupent donc
beaucoup de choses, mais je veux dire, encore une
fois, c'est là qu'intervient
la randomisation Cela se produira peut-être,
mais cela offre
une belle variation, et je pense que cela
semble plutôt bon. aimerais peut-être ajouter un
peu plus de délai entre les îles
initiales, mais je pense que rien que pour
ce type de projet, cela a l'air plutôt
cool et le fait d'avoir un certain chevauchement
donne encore plus de variété. Une autre chose que
vous voudrez peut-être faire est d'utiliser la classe de base Si nous arrivons ici,
nous allons
immédiatement faire apparaître Nous devrions donc en avoir
un. Si nous appuyons simplement sur des simulations. Nous devrions
juste vérifier. Oui, on en reçoit un tout de suite,
ce qui est très bien. Je pensais que
nous avions peut-être déjà
eu un retard initial, mais je pense que la seule
raison pour laquelle nous ne le
voyons pas pendant un petit moment, c'est simplement parce qu' il faut un tout petit peu de temps
pour apparaître à l'écran. Nous apparaissons donc immédiatement avec
une île. je
me demande juste Mais je
me demande juste où c'
est en ce moment. Donc, c'est juste que ça prend surtout s'il en fait apparaître un
petit, tout d'abord Il va falloir un
peu plus de temps pour le voir
avant qu'il n'entre dans le cadre.
Ce n'est pas la fin du monde. Encore une fois, avec la randomisation, vous allez obtenir des résultats
différents Même avec la plus grande
île, je pense que cela prend un certain temps pour
passer à l'écran. Alors peut-être que ce que je serais
tentée de faire, et encore une fois, cela se résumera à beaucoup de voyages maintenant. Peut-être que nous étions un peu trop préoccupés par la
distance qui nous sépare ce matin. Nous allons donc y
revenir un peu,
et encore une fois, en veillant à ce et encore une fois, en veillant que chaque fois que vous appuyez sur la plaque, surveillez pour vous
assurer que rien n'apparaisse, mais nous voulons que cette île
apparaisse peut-être à l'écran un
peu plus tôt Comme je l'ai mentionné, essayez et
essayez,
observez comment les choses se passent, surveillez les résultats
que vous obtenez et assurez-vous
que le jeu est beau au fur et à mesure que
vous le jouez. Je pense donc que c'est plutôt cool
là-bas. devraient commencer à devenir un Mais c'est là que les choses
devraient commencer à devenir un
peu plus
intéressantes. Vous avez maintenant
le contrôle total de la conception des niveaux, de l'endroit où vous
vouliez que les objets apparaissent, de
la vitesse
à laquelle vous souhaitez
qu'ils se déplacent, en quelque sorte affinant le jeu et l' apparence du jeu que vous avez Si des objets apparaissent
, vous pouvez simplement reculer le générateur
un peu plus Si vous
voulez qu'ils apparaissent plus tôt, nous
pourrions les rapprocher
un peu plus. Si l'eau ne
couvre pas toute la vue, augmentez simplement le
plan comme vous venez de le voir. Et si les îles
sont trop proches, il suffit de réduire la
vitesse de reproduction et d'autres choses de ce genre Et ce n'est qu'une pure itération,
jouez, observez, ajustez, répétez Il est rare que vous obteniez
ce résultat parfait du premier coup. Vous venez de me voir
devoir peaufiner et changer certaines choses, même pour
cette démonstration,
mais c'est là que devrait
entrer en
jeu le plaisir de créer
des jeux, car c' est là que vous avez désormais
beaucoup plus de contrôle sur le peaufinage
du résultat final Maintenant, une chose que je
dirais, c'
est que cela vaut la peine à
ce stade également garder un œil sur les grandes lignes,
comme je l'ai déjà mentionné Nous avons certaines choses, nos volumes de blocage
sont parfaitement corrects. Peut-être mettre
des objets dans des dossiers comme avec
l'éclairage fourni par défaut. Une chose dont j'ai réalisé que nous
n'exploitons pas réellement c'est la sphère céleste en arrière-plan.
Il s'agit d'un objet ancien. Ça ne fait rien. Nous pouvons nous débarrasser de
la sphère céleste. Vous pouvez voir que rien ne change, juste pour vous assurer qu'il n'y a pas plus d'objets dans le
niveau que ce dont nous avons besoin. Tout le reste va bien. Cela fournit la lumière et l'atmosphère
en arrière-plan. Mais n'hésitez pas à commencer à
jouer avec ceux-ci, en modifiant la direction de
la lumière directionnelle, sa force pour rendre
les choses plus claires et plus sombres. Encore une fois, commencez vraiment à faire
preuve de créativité et à jouer avec les différentes
propriétés et détails pour que le jeu ressemble à ce que
vous vouliez. C'est donc tout pour notre
niveau. Les choses semblent maintenant un
peu plus vivantes. Nous avons des îles aquatiques, avec lesquelles vous pouvez jouer avec une
parallaxe. En fait, cela commence à
ressembler à un
petit jeu. Ensuite, nous pouvons commencer à passer à la
bonne passe,
en rendant les choses
vraiment intéressantes et rendant les choses
vraiment intéressantes et encore plus
attrayantes visuellement pour le joueur.
24. 23 - NiagaraParticles: Point où nous pouvons
commencer à améliorer
l' ambiance générale et attrait de quelqu'un qui
joue à notre jeu. Nous allons commencer par la
finition soignée des effets,
en ajoutant des éléments tels que des
propulseurs, des explosions, des
impacts, le tout en utilisant le moteur
Unreal intégré au système Niagara Voici donc un bref
aperçu des systèmes et des émetteurs que nous allons
examiner dans le cadre de notre projet Si nous accédons à notre projet, accédons au
dossier Assets et aux effets, nous avons nos
systèmes Niagara juste ici. Mais il suffit d'en ouvrir
un. Nous allons utiliser le moteur de pixels pour le moment juste pour montrer sur quoi
nous travaillons. Nous nous trouvons donc dans
un système Niagara en
ce moment . Les systèmes sont généralement
constitués d'un et bien souvent
de plusieurs émetteurs. Nous pouvons voir ici que les panneaux à onglets
orange représentent nos émetteurs constituant
les différents points
de notre système global Cela rend l'utilisation de Niagara beaucoup
plus flexible que
l'ancien système de particules
en cascade. Dans le nouveau système
, il est beaucoup plus facile créer des émetteurs de base, puis nous pouvons commencer à les
assembler pour créer des systèmes personnalisés et
uniques D'une
manière vraiment simpliste, vous pouvez considérer cela
comme un système de particules de
flamme Il se peut
que de nombreux émetteurs soient concernés. Les étincelles
viendraient du haut de la flamme. Vous
fumeriez un peu. Vous pourriez avoir un effet de
distorsion, et vous auriez le corps
principal de la flamme et le feu lui-même. Tous ces émetteurs peuvent être
des émetteurs individuels construisent ce grand système. important
de garder à l'esprit que les émetteurs sont
censés être réutilisables Nous ne les plaçons pas directement dans nos plans ou dans
les systèmes que nous allons
utiliser et que nous
utilisons réellement dans notre code
ou dans le niveau lui-même Si vous voulez commencer
à essayer de jouer avec certains
des systèmes que j'ai
déjà fournis, vous pouvez voir que j'en
ai plusieurs ici. Vous pouvez très facilement
entrer et commencer à jouer avec les
propriétés des émetteurs. Si vous
voulez voir quelle
partie est responsable d'un certain effet dans
le pot d'affichage, nous pouvons les
décocher ici Nous pouvons voir qu'il ne s'agit
que d'une source de lumière, donc rien ne change vraiment. Si nous le réactivons, puis que nous éteignons l'autre émetteur, nous pouvons voir que c'est clairement
lui qui est responsable l'effet des
particules de notre moteur à cet endroit Donc, si vous vouliez
ensuite commencer à
essayer de jouer avec des
choses comme la couleur, la taille, vous
ne savez peut-être pas exactement ce que vous recherchez tout de suite, ce
qui est parfaitement bien Mais en jetant
un coup d'œil aux
propriétés fournies,
nous pouvons voir que jetant
un coup d'œil aux
propriétés fournies, nous pourrions
probablement changer la couleur à partir de nos valeurs d'
échelle ici. Cela rend la couleur
jaune-orange ici. Si nous lui donnons plus de bleu,
nous obtiendrons une couleur différente au cours de la
durée de vie de la particule. C'est un autre excellent
moyen de s'habituer à certains systèmes
d'Unreal, trouvant
simplement ce qui vous semble
instinctivement logique jouant avec les
valeurs que
vous pouvez trouver et en les modifiant Vous pouvez également ajouter différentes
choses, comme de la vélocité
supplémentaire, pour prolonger ce
voyage. Et comme je l'ai déjà
mentionné, un très bon moyen de
découvrir de quoi choses sont responsables est d'
ajouter une valeur vraiment stupide
à cela.
Ainsi, si
nous fixons la vélocité ici à 11 000 au lieu de 1 000, nous pouvons voir exactement de quoi
cela est responsable, puis nous pouvons affiner
et ajuster jusqu'à une valeur avec laquelle nous pensons
avoir envie Ainsi, comme pour certains
des autres systèmes du projet que
nous avons examinés jusqu'à présent, l'aspect plus artistique
des choses n'est pas vraiment au centre de ce que
nous essayons de
faire passer dans ces sujets. Je ne vais donc
pas approfondir le Niagara. Je veux vous montrer
comment l'utiliser et comment nous pouvons l'
implémenter dans un projet. Utile si vous avez
accès à des Asset PAC ou à des
exemples gratuits
tirés du
projet d'exemple de contenu fourni par Epic Tout d'abord, puisque nous sommes
déjà dans cette particule, nous pourrions l'
utiliser pour le propulseur de nos deux classes d'avions Les deux en auront besoin, à la fois l'ennemi et le joueur. Donc, si nous suivons notre cours de
plan, nous passerons au CR, et nous trouverons la base aérienne BP Underscore Nous pouvons donc le mettre à nouveau dans
la classe de base, et cela sera utilisé pour nos
deux plans différents. Nous devons
encore une fois faire très attention à l'endroit où nous
allons le placer. Nous pourrions le placer
directement sur la sphère, mais je pense que pour le moment, au cas où nous voudrions effectuer une rotation de décalage
spécifique, choses comme ça sur
le maillage statique, nous le placerons plutôt ici. Nous allons donc prendre le maillage statique. Nous allons ajouter
un nouveau composant et nous voulons
rechercher Niagara. Nous pouvons voir ici que nous
n'avons qu'une seule option, le composant du
système de particules Niagara. Et dans le panneau des détails,
nous verrons le menu déroulant que nous recherchons probablement et que nous connaissons déjà bien. Nous pouvons le faire défiler vers le bas et
sélectionner le moteur de pixels. Si nous accédons à la fenêtre d'affichage, nous pouvons voir qu'elle est en quelque sorte ancrée au milieu d'Amopla Il va
donc falloir la reculer un peu reculer Et je pense que je vais juste le
placer approximativement à côté du cercle métallique que j'ai
ajouté sur l'avion juste ici. Si nous appuyons sur Compiler en toute sécurité, nous
devrons peut-être tester certaines choses avec celui-ci La première concerne donc
la rotation différente que nous allons appliquer
aux différentes classes d'enfants. Donc, si nous commençons dans le lecteur ordinaire et que nous nous contentons de
regarder le point de vue ici, celui-ci est
parfaitement beau. Il s'agit essentiellement de la
même configuration que la base plane. Si nous passons à Plain Enemy,
passez dans le belvédère ici, afin de voir que
l'effet des particules est également bon ici Cependant, si nous appuyons sur Play, donc si nous passons dans notre
fenêtre d'affichage et en mode jeu ici, nous pouvons voir que cela
semble bien pour le joueur,
mais que les particules ennemies semblent un peu
étranges, cela sera parce que souvenez-vous que
lorsque nous entrons en mode jeu, nous
inversons mais que les particules ennemies semblent un peu
étranges , cela sera parce que souvenez-vous que
lorsque nous entrons en mode jeu, nous complètement la rotation de notre ennemi en fonction de l'emplacement
du Et même si cet effet de
particules est imbriqué, si nous examinons la configuration du moteur de pixels de soulignement
P,
nous pouvons constater que la
vitesse est réglée dans nous pouvons constater que la
vitesse est réglée une direction spécifique, moins 1 200
. Donc, ce que nous voulons faire,
c'est simplement
une modification très simple d'un système de particules
existant Pour que vous puissiez commencer à vous familiariser
au moins un peu, nous devons créer une copie
du moteur à pixels. Nous allons donc
revenir sur nos effets. Nous allons passer à
nos réseaux du Niagara. Nous avons notre
moteur de pixels juste ici. Autre chose, ils
ont été copiés à partir des exemples de contenu, ils
n'ont pas le meilleur nom Nous allons
donc
prendre celui-ci et le
renommer en Ns La convention de dénomination appropriée
serait donc le système Nagra, le moteur de pixels de
soulignement, et nous appellerons cela un lecteur de
soulignement Nous pouvons donc laisser
celui-ci tel quel. Nous pouvons ensuite appuyer
sur Ctrl, pour le dupliquer,
et nous appellerons celui-ci un ennemi souligné Et si nous double-cliquons pour
ouvrir la version ennemie, nous
voulons trouver notre vélocité. Nous avons déjà vu que
cela contrôle la direction dans laquelle se
dirige l'effet des particules, et nous allons simplement supprimer
l'option de négation ici Nous pourrions également faire quelque chose
pendant que nous sommes ici, rendant celui-ci peut-être un
peu plus vert afin faire glisser la valeur vers le haut pour lui donner une teinte légèrement
différente. Et si nous
dépassons la valeur rouge, nous pouvons voir qu'il s'agit un
peu plus d' un propulseur vert, juste
pour le rendre un
peu plus unique à
la version ennemie sur laquelle nous
allons le placer Nous pouvons donc appuyer sur compiler
et enregistrer dessus. Nous allons retourner dans
la classe ennemie. Nous allons récupérer notre système de
particules Niagara ici, et tout ce que nous voulons faire, c'est le
changer depuis le joueur, qui est celui que
nous venons de renommer et le remplacer par
la version ennemie. Cela va donc sembler
cassé dans le plan. C'est parfaitement normal, car dès que nous passons au playode,
celui-ci prend en compte
la direction mondiale du
mouvement
du système de particules
plutôt que l'entité qui est activée Nous pouvons donc voir que cela
fonctionne parfaitement maintenant. Légèrement différent parce que
nous avons des couleurs différentes, donc ça a l'air un
peu plus intéressant. Un petit ajustement simple pour se familiariser un peu avec
le système de particules qui s'y trouve, et nous avons à la fois le système joueur
et le système ennemi qui fonctionnent C'est donc une façon
d'appliquer des particules sans code directement dans les composants
et les fonctionnalités existantes. Maintenant, si vous vous souvenez,
nous avons quelques éléments prêts
à être implémentés
dans notre code également. Souvenez-vous de certains d'
entre eux pour faire des commentaires. Donc, l'un de ceux que je me rappelle
avoir reçus figurait dans notre cours de dessin
pour nos projectiles Donc, si nous passons à la base de projectiles BP
Underscore, et exactement ce que je
disais tout à l'heure, je vais juste
taper todo ici Nous trouverons le
commentaire que j'ai laissé moi-même, et il se trouve juste ici. Donc, si vous n'avez pas laissé ce
commentaire, il vous suffit de
naviguer vers le début du chevauchement de vos
composants, et c'est là que nous
voulons ajouter certains effets. Et nous allons commencer par
notre système de particules simple pour montrer que deux
facteurs ont eu un impact. Donc, entre les dégâts que nous infligeons
et, encore une fois, ce qui est très important avant de détruire
le projectile, nous allons
tirer sur l'
épingle d'exécution et rechercher
ce que l'on appelle un
système d'apparition sur place Nous voulons donc cette
option juste ici, étendre le système sur place. Maintenant, il y a
plusieurs choses à faire si
vous commencez à vous
intéresser davantage aux particules vous-même pour tirer parti de ce que
nous faisons ici. Vous pouvez également rencontrer
le terme spawn emitter. Donc, si nous recherchons l'
émetteur Born sur place, il s'agit d'une terminologie très similaire, et il s'agit essentiellement de
l'ancienne version du système de particules Il n'est donc pas encore complètement supprimé, mais je l'ai mentionné très
brièvement il y a un instant. Il existait autrefois
ce que
l'on appelait le système de particules en cascade. Il n'était pas aussi flexible et ne possédait pas autant de fonctionnalités. Ce n'est pas aussi facile
à programmer, alors que nous utilisons maintenant
le système Niagara. Donc, lorsque vous souhaitez
travailler avec Niagara, sur quoi
vous vous concentrerez idéalement, vous devriez
rechercher ce que
l'on appelle le système de mots qui
revient souvent. Lorsque vous travaillez avec une
cascade, que vous participiez à un ancien projet ou à
un projet plus ancien, le
mot émetteur peut apparaître Les articles en cascade étaient donc
appelés émetteurs, alors que maintenant, comme je l'ai mentionné, un émetteur n'est qu'
un élément unique qui construit un système
Niagara complet C'est donc le
moyen le plus simple de
s'en souvenir . Nous cherchons donc
un système. Vous savez que vous avez
également
la bonne réponse , car si
nous la supprimons, nous n'avons rien de
valide à mettre dans l'emplacement de l'émetteur.
Nous allons donc nous en débarrasser. Si nous abandonnons
celui-ci, nous voulons trouver notre impact métallique. C'est donc ce que nous
voulons utiliser lorsque deux projectiles ou un projectile touchent une autre surface
. C'est donc l'émetteur
que nous voulons générer. Cela nous permet de les
intégrer au moment de l'exécution, ce qui donne aux projets une apparence un
peu plus dynamique. L'emplacement va
être très simple. Nous allons partir de là,
et nous allons juste
chercher la localisation de l'acteur. C'est donc
là que nous voulons que l' effet
des particules apparaisse, le point
d'impact, essentiellement, où deux choses se produisent. Nous allons laisser la rotation de l'échelle par défaut. Nous n'avons pas besoin de
les changer. Nous reviendrons et nous ferons des
effets sonores et d'autres choses plus tard. Je vais donc laisser ce commentaire pour moi plus tard, car je devrai revenir
et ajouter quelques éléments supplémentaires. Mais encore une fois, nous pouvons maintenant
entrer et tester, et ce que nous devrions
voir, c'est que chaque fois un projectile touche quelque chose, nous obtenons un effet de particule. C'est donc un
peu extrême, mais nous pouvons certainement
voir que cela se produit. Et encore une fois, vous pouvez
entrer, affiner les différentes échelles
et autres choses de ce genre. Mais nous avons maintenant des commentaires selon lesquels deux
choses se sont affrontées, ce qui rend le
jeu encore plus intéressant et
intuitif à jouer J'ai également fourni,
ainsi que l'impact métallique. Vous pourriez également
utiliser l'explosion de pixels, c'est à vous de décider. Je pense qu'ils ont l'air
légèrement différents. Vérifiez simplement à
quoi ils ressemblent. Celui-ci est peut-être un
peu plus approprié en fait, compte tenu du
faible impact qui y est associé. Je vais donc m'en tenir à
l'explosion de pixels. Mais c'est le principal élément que nous avons maintenant, ce feedback visuel. Ensuite, nous voulons
faire la même chose pour nos deux avions. Encore une fois, nous l'avons
indiqué dans la classe de base, nous allons
donc passer à la base plane
BP Underscore Je pense que je m'en suis laissé
un aussi ici, et nous allons simplement
double-cliquer dessus. Donc, implémentez les effets mortels des
avions. Ce sont donc les
effets que je veux jouer lorsque l'un des
avions sera détruit. Encore une fois, c'est pareil. Nous
allons partir d'ici. Nous rechercherons l'option système
Born. Prenez le système Span sur
place. Même propriété. Donc, là où l'avion
vient d'être détruit, ce
sera l'endroit. Nous allons donc trouver
le moyen de nous rendre sur place. Et nous allons procéder d'une manière
très légèrement
différente ici. Donc, comme nous l'avons fait par
le passé, nous voulons
rendre cela flexible
car nous l'
exposons pour une utilisation dans
les classes enfants du parent où se trouve
la logique de base. Nous allons donc utiliser
notre modèle de système ici, et nous allons simplement le
promouvoir en tant que variable. Nous allons renommer celui-ci en « effet de particule d'
explosion ». Et nous devrons changer cela pour
les classes pour enfants,
car les effets de
particules
du joueur et de l'ennemi sont
légèrement différents. Nous avons donc cliqué sur compiler et enregistrer. Nous allons
passer à la classe avion, la classe avion joueur. Assurez-vous que
l'élément supérieur est sélectionné, et nous devrions pouvoir
voir quelque part en bas que nous avons maintenant un effet de
particules explosives. À partir de celui-ci, je vais
trouver Pixel Explosion Player, puis nous allons appuyer sur compiler,
enregistrer et entrer dans l'avion ennemi. Pareil.
Attrapez l'élément supérieur. Nous allons trouver notre particule d'
explosion, et nous allons remplacer celle-ci par
la version ennemie. C'est tellement simple et agréable,
compilez et enregistrez à nouveau. Et maintenant, nous voulons
tester et voir comment cela
fonctionne lorsque les choses se bousculent réellement. Nous constatons donc qu'il y a un petit décalage la première
fois que cela arrive. Dans un jeu entièrement éclairé, vous devez exécuter quelque
chose
pour que les shaders soient précompilés,
afin
de vous assurer que tous les effets sont au moins
arrondis, afin de ne pas avoir afin
de vous assurer que tous les effets sont au moins
arrondis , afin de ne pas Mais maintenant que nous avons
surmonté cela, nous pouvons voir que nous avons les
différents effets. Et nous pouvons également simplement tester. Quand le joueur meurt,
nous obtenons la même chose. C'est donc légèrement différent si nous les
vérifions et les examinons. Je pense que l'un est
légèrement plus bleu, donc nous avons une sorte d'explosion
bleue ici, et l'autre
a cette teinte verte. Vous pouvez donc entrer et
modifier les propriétés de couleur. Et vous pouvez constater qu'au fur et
à mesure que les choses se complexifient, nous pouvons constater que
le nombre d'émetteurs augmente Mais une fois que vous commencez à vous
familiariser avec les éléments que vous recherchez, ils
sont relativement
faciles à modifier et à configurer pour
fonctionner exactement comme vous le souhaitez C'est l'
aspect programmatique des choses. C'est vraiment tout ce que
nous devons faire pour obtenir des
effets de particules. Il s'agit donc d'une étape relativement simple pour
peaufiner notre projet. Et c'est une autre de ces choses où
l'expérimentation et jeu avec
les choses vous seront
vraiment bénéfiques
plus que toute autre chose. Par exemple, j'ai pris les effets de particules directement à partir des exemples de contenu épiques, et je pense que, pour
ce qui est
de la configuration générale , les explosions semblent
un peu trop fines, pas aussi épaisses que
je l'aurais souhaité Donc, ce que je pourrais être tenté
de faire dans les deux cas
serait d'entrer et trouver les éléments spécifiquement liés à l'
échelle du maillage. Voici donc trois de
ces mesures statiques. Je peux voir ici que nous
avons une échelle de maillage, et je pourrais simplement l'
augmenter à quelque chose de beaucoup
plus grand par défaut. Je peux voir ici exactement sur
quel élément cela
prend effet, afin que nous puissions voir lesquels
viennent de prendre de l'ampleur. Je l'ai fait quatre fois
plus grand qu'il ne l'était. Encore une fois, cela
prend un peu de temps car je dois le
faire pour chacun des
différents éléments. J'aborderais donc celui-ci, par
exemple, en le réglant
sur quatre, quatre et quatre. Mais nous avons maintenant immédiatement
une bien plus belle explosion en gros morceaux pour le type d'étoile
que nous recherchons Des modifications très simples comme
celles-ci peuvent donc vraiment
faire une différence sur les émetteurs et il ne
me reste
plus qu'à trouver le maillage Donc, si je voulais tester cela sur notre ennemi, je referais
la même chose, afin que nous puissions saisir l'échelle de maillage, la régler sur quatre, quatre et
quatre, pour qu'elle corresponde à celle du joueur. Et nous le
faisons simplement pour chacun
des différents émetteurs afin que
tout reste assez uniforme, car ils sont
censés représenter différents éléments
du système d'explosion Alors compilez et enregistrez
cela, nous pouvons
entrer , jouer et voir à
quoi cela ressemble. R Je pense que c'est beaucoup mieux. Je pense que cela montre simplement une
belle différence entre l'
impact général des
projectiles et l'explosion des navires. Donc de très
petites choses comme ça. Vous pouvez également trouver les
couleurs, surtout si vous avez des ennemis de couleurs
différentes
de celles que j'ai choisies. Vous pourriez entrer dans
l'explosion ennemie, trouver toutes les
propriétés de couleur entre les différents émetteurs, voir lesquels sont
responsables quelle couleur, puis
les modifier à votre guise. N'oubliez pas que
si vous ne savez pas quel élément est celui que
vous souhaitez modifier, nous pouvons simplement décocher les différents émetteurs ici et nous pourrons voir qui
est responsable de
quelle partie. Vous pouvez donc passer. Ce serait juste
ce genre d'
après-fumée , donc on peut l'
éteindre. Celui du milieu correspond
à la couleur principale. Donc, si mes ennemis
sont vraiment verts. Alors peut-être qu'il serait plus
logique d' avoir une couleur plus verte, afin que nous puissions
augmenter la valeur verte .
Et puis on y va. Nous avons plutôt une
explosion verte pour la nuit ennemie. Nous avons donc une jolie
sorte de jaune commence par une explosion
de chaleur. Mais nous montrons ensuite
que cela revient
en fait à
une prolongation verte, qui est la couleur
de carrosserie du navire ennemi. Donc, encore une fois, un changement
vraiment très rapide. Tant que vous savez à peu près
ce que vous recherchez, nous pouvons apporter ces modifications
assez rapidement à la volée. Et voyez ce genre de choses se
combiner très bien. Alors jouez avec
ce genre de choses. Ce sont des approches
qui vous permettront comprendre les systèmes
beaucoup plus rapidement. Vous ne
saurez pas nécessairement exactement ce que vous recherchez au début,
mais je pense que, surtout en ce qui
concerne le système Niagara, les conventions de
dénomination,
les éléments que vous
recherchez et les commentaires immédiats que vous
obtenez sur
le point de vue, c'est un moyen très pratique d'
apprendre cela très rapidement en faisant quelques erreurs d'essai et
en ajustant différentes valeurs C'est donc la première étape améliorer notre feedback
visuel. Cela donne l'impression que tout est vivant. Les ennemis continuent
de surgir de nulle part. Ensuite, dans la rubrique suivante,
nous voulons ajouter ces très belles animations
d'apparition fournies dans
l'exemple de projet
25. 24 - AudioEffects: aurais pu dire que
nous allons nous lancer dans le festival d'animation, mais je me rends compte que nous
négligeons en fait la pièce manquante
de notre vernis. Et c'est quelque chose
qui est souvent oublié bien trop tard dans le développement
des jeux, à savoir l'audio. Nous voulons commencer par
étudier l'utilisation des signaux San pour répartir de manière aléatoire un minimum de fichiers
audio afin de rendre les choses un peu
plus variées et intéressantes C'est également l'une de ces choses
: si vous prototypez votre propre
jeu, il est
très facile de négliger et de sous-estimer l'
importance du Vous pourriez avoir l'impression que votre jeu
est plat ou ennuyeux. Vous pouvez ajouter des éléments
tels que des effets de particules , des tremblements de
caméra
et toutes
ces autres choses, et il se peut
qu'il
manque du son au projet qui
pourrait manque du son au projet qui vraiment l'
aider à prendre vie. Nous allons donc nous concentrer
sur ce festival. Donc, si nous accédons à
notre tirage au sort du contenu, nous allons accéder
au dossier audio. J'ai fourni quelques fichiers audio
différents. Nous en avons un pour l'explosion, donc nous les utiliserons
pour nos avions
lorsqu'ils explosent,
et nous avons l'effet de coup de feu, qui se produit
chaque fois que nous tirons Nous n'allons probablement pas le
confier à l'
ennemi, mais encore une fois, vous pouvez modifier et
contourner les choses pour voir comment vous souhaitez que le
projet soit mis en place Je pense que si trop de
choses se déclenchent en même temps, cela peut très facilement devenir
une surcharge auditive Si vous souhaitez tester les fichiers audio et
voir comment ils sont sonores, nous pouvons cliquer sur
le bouton de
lecture ici, et vous pourrez les lire immédiatement dans l'éditeur. Si nous nous concentrons sur nos coups de feu, tout d'
abord, puisque
nous en avons deux,
nous voulons les sélectionner tous les deux, cliquer avec le bouton
droit sur l'un ou l'autre, et nous avons cette option ici
pour créer une file d'attente unique Donc, si nous choisissons de
créer un multiple que, cela créera un
fichier, un fichier que pour chaque fichier wave que
nous avons ici. Au lieu de cela, nous pouvons prendre ces
deux fichiers wave et les compresser
dans une seule file d'attente. Nous allons donc cliquer sur
celui-ci. Renommez celui-ci SC Underscore gunshot Vous pouvez voir qu'il s'agit d'un type d'actif légèrement
différent. Et en gros, les indices SN sont un moyen très simple si nous
double-cliquons pour les ouvrir. Ils nous permettent de travailler avec plusieurs fichiers audio sans avoir à modifier le fichier source. Nous pouvons donc conserver le
Gunshot One et 71 exactement tels qu'ils étaient
lors de leur importation, et nous pouvons remplacer
ici individuellement éléments tels que la question de savoir
s'ils doivent être en boucle, le volume par défaut,
etc. Une chose à noter
est que vous pouvez voir les ongles assez intelligemment Il sait que,
comme nous avons introduit plusieurs fichiers signés
différents, nous avons probablement voulu aléatoirement l'ordre dans lequel ils
sont joués, ce que nous voulions en fait Une fois que les randomisations auront
été effectuées, nous voulons partir de
là, et nous allons
rechercher ce qu'
on appelle un modulateur Ou, en fait, vous pouvez le
voir juste ici. Nous allons brancher
le résultat de notre modulateur sur la sortie Cela permettra donc de basculer entre le
son à jouer. Ça va randomiser l'
un d'entre eux. allons ajouter
un modulateur pour que nous
puissions modifier légèrement le son. Et puis, quel
que soit le résultat de sortie,
c'est ce qui sera diffusé
à l'utilisateur final. Le modulateur étant
toujours sélectionné. Vous pouvez voir que la principale chose
que je voulais annuler ici est la hauteur minimale
et maximale Cela permettra simplement de garantir que même si nous n'
avons que deux fichiers son, ils n'auront pas
exactement le même son lorsque nous
les lancerons des centaines ou
même plusieurs fois de suite. Je donne à ces deux
options un décalage de tonalité assez important, nous allons
donc régler 12,5 et
l'autre 1,5. Encore une fois, ces valeurs peuvent
être assez extrêmes, et si le son
est trop déformé, c'est là que nous pouvons
revenir et commencer à l'affiner
progressivement pour obtenir le
son exactement comme nous le souhaitons. Pareil pour le
volume, nous pouvons régler un à 0,9 et un à 1,1. Nous avons donc une sorte
de décalage similaire entre minimum et
le volume maximum pour les deux effets sonores à
chaque fois qu'ils sont joués. C'était donc génial. Nous avons
pu constater que cela prenait
définitivement
effet exactement comme nous le souhaitions, avec une petite mise en garde Un problème courant avec
l'ancien système Q que nous utilisons ici La randomisation n'est pas
vraiment aléatoire. Vous pouvez voir qu'il s'agit
simplement de passer d'une option à
l'autre Il jouera A puis B, puis A,
puis B. C'est assez prévisible. Donc, si nous prenons notre note au hasard, une chose que nous voulons faire est
de la décocher ici, pour la randomiser
sans la Quelque chose que les gens oublient
souvent. Mais maintenant, si nous appuyons sur Play, nous n'avons pas nécessairement
besoin de les écouter Je vais
donc couper
le volume rapidement Mais
vérifiez simplement que vous pouvez voir quel fil est en train de se déclencher. Et ce que nous devrions voir, c'est que j'ai eu environ quatre ou
cinq clics, obtenant la
même lecture audio, tout en obtenant la
même lecture audio,
ce qui se rapproche véritable randomisation plutôt
que d'une volte-face entre A et B. Évidemment, vous devriez le
faire également si vous aviez
plusieurs ondes sonores en plus
de cela dans votre single que plusieurs ondes sonores en plus
de cela dans votre single Donc, si vous en aviez cinq ou six, vous ne voudriez pas que ce soit un, deux, trois, quatre, cinq, un,
deux, trois, 45, etc. Vous voudriez qu'il choisisse
au hasard entre ces cinq ou six effets sonores. N'oubliez donc pas de toujours
entrer et de décocher la case Randomiser
sans la remplacer Cela étant fait, nous voulons faire même
chose
avec les explosions. Je vais donc cliquer avec le bouton droit de la souris sur
la vague d'explosion. Nous allons créer une file d'attente
audio unique pour celui-ci. Nous l'appellerons SC
Underscore Explosion. De toute évidence, nous n'aurons
pas besoin de randomisation
entre celui-ci Nous n'avons qu'un seul
fichier, mais nous pouvons toujours
utiliser des choses comme ajouter à nouveau
un modulateur entre les deux Je vais donc simplement connecter un autre modulateur ici
de la même manière et peut-être fournir des différences légèrement moins intenses ici Donc peut-être 0,7 à 1,3. Et encore une fois, nous pouvons
revenir et affiner si c'est un changement
de ton trop important. Je vais laisser les volumes minimum et
maximum tels quels. Et c'est juste un ajustement très
simple que nous allons apporter à notre file
d'attente audio Si vous utilisez un arrière-plan
plutôt audio, peut-être utiliser d'autres
terminologies et fonctionnalités pouvez peut-être utiliser d'autres
terminologies et fonctionnalités
sur le côté droit Vous pouvez simplement les
faire glisser dans le graphique,
les jusqu'à la propriété et les
modifier comme bon vous semble. Pour cette simple démonstration, je vais le garder
tel que nous l'avons fait ici. Je vais donc
passer très rapidement et
commencer à fermer certaines
fenêtres dont je n'ai pas besoin, en particulier celles liées aux effets de particules, afin que nous puissions nous en débarrasser. Et si nous commençons par
la base de jeu, je suis déjà là, donc je
vais d'abord m'occuper de l'effet
mortel. Je vais laisser le
commentaire ici, car nous aurons probablement besoin de quelques informations
supplémentaires un peu plus tard. Donc, entre notre système de
particules d'apparition et l'appel à la fonction Destroy
Actor, je vais utiliser
l'épingle d'exécution, et je vais rechercher le son de
diffusion sur place C'est donc encore une fois une
fonctionnalité très intéressante dans Unreal. Nous avons déjà intégré l'audio spatial
par défaut. Nous pouvons donc fournir
le point initial d'où nous voulons que cet
audio soit diffusé. Nous pouvons donc rendre les choses un
peu plus crédibles
si un avion est détruit dans la partie supérieure
gauche de la caméra, alors nous allons avoir un effet sonore qui
devrait se produire un
peu plus sur le
côté gauche de votre casque Nous allons donc utiliser la fonction
standard ici. Nous allons utiliser
get act location pour découvrir où l'
avion qui a explosé a été détruit Ensuite, nous allons utiliser le menu déroulant du son
ici et nous choisirons notre SC, notre signal sonore que nous avons personnalisé pour
souligner l'explosion Maintenant, nous n'avons pas vraiment besoin de
promouvoir cela car, encore une fois, ils utiliseront tous les deux les mêmes effets
sonores d'explosion, et ils ont tous deux leur propre randomisation
et des choses comme ça Maintenant, je ne vais pas l'
utiliser ici, mais je voulais également vous
montrer les fonctionnalités auxquelles
nous avons accès. Donc, si nous utilisons le menu
déroulant de ce nœud, si vous ne voulez pas
jouer avec les signaux sonores ou si vous voulez simplement
utiliser le fichier d'ondes de règles, nous pouvons toujours entrer
et faire des choses comme multiplication
du volume, la multiplication de la
hauteur tonale. Nous pourrions ajouter quelque chose
comme un flotteur aléatoire, comme
nous l'avons vu de
nombreuses fois, ou idéalement un flottant aléatoire dans la
plage, comme nous l'avons déjà vu. Et c'est très similaire
à ce que nous avons configuré dans le signal sonore pour
le multiplicateur de hauteur. Mais comme nous avons une belle file d'attente audio
personnalisable avec laquelle travailler, nous l'utiliserons simplement à
la place des fichiers d' ondes
sonores par défaut des zones rurales. Il y a beaucoup plus de choses que nous pourrions
approfondir , comme les paramètres
d'atténuation Cela fournit donc au système audio en
trois D, une sorte de chute,
une une sorte de chute,
une plage à laquelle le son
devrait être de plus en plus fort,
selon l' endroit où le sport est pratiqué Pour cela, cependant, je vais
simplement copier
les fonctionnalités que nous
avons ici parce que nous voulons les ajouter à
notre fonction d'incendie. Nous allons donc simplement déplacer
le commentaire. Nous allons
revenir ici et faire
quelques autres choses lors nos dernières passes dans les effets, donc c'est toujours d'actualité. Mais nous allons saisir
cette commande de presse en C. Je vais passer à
la fonction incendie. Et une fois le projectile généré, on pourra le déposer ici Encore une fois, nous
voulons l'endroit
où l' effet sonore du feu doit être joué. Et nous allons
prendre notre coup de feu ici,
et celui-ci jouera automatiquement
un coup et celui-ci jouera automatiquement de feu à chaque fois que
quelque chose C'est parce que je pense que s'il y a quatre ou cinq ennemis
à l'écran et qu'ils les tirent tous
en succession rapide, nous devrions peut-être
baisser leur volume. Je pense donc que ce que je vais
faire, c'est qu'au lieu d'avoir fonctions de tir
distinctes
dans chaque classe, nous allons
encore une fois
utiliser l'héritage là où nous le pouvons. Je vais promouvoir
le modificateur de volume et le transformer
en variable, et nous l'appellerons «
fire volume offset ». Nous pouvons donc utiliser par défaut une valeur de un, ce qui était déjà le cas. Nous allons donc jouer
par défaut le volume total
du signal sonore du
coup de feu Donc, bien sûr, si nous l'avons réglé pour qu'il soit un peu aléatoire
ici avec le modulateur,
le volume par défaut pourrait
être de 0,9 vers 1,1 Nous allons ensuite annuler cela et soit le multiplier par un total
de un,
soit pour les
ennemis, par exemple La raison pour laquelle je veux l'utiliser
est que nous allons appuyer sur compiler et enregistrer. Je vais entrer dans
la classe ennemie. Nous trouverons cette valeur
ici dans les propriétés. Je vais lui donner un décalage de
volume par défaut de 0,5. Nous allons donc
avoir le
volume par défaut pour les tirs ennemis. Donc, même s'ils commencent à
s'accumuler un peu, ils ne devraient pas devenir complètement insupportables et, comme je l'ai dit, trop stimulants OK, donc un test de jeu très
rapide. J'ai découvert que les coups de feu étaient probablement aussi forts ou peut-être plus forts que
les explosions Je pense donc que ce que je vais faire, définir
un volume minimum, c'est définir
un volume minimum,
potentiellement basé sur les types de
signes que j'ai trouvés. Ils ont probablement
simplement été exportés, mais pas avec un volume
normalisé satisfaisant Donc peut-être que par défaut, en fait, nous allons porter
cela à 0,5 à 0,7 ou peut-être 0,4 à 0,7. Et
nous verrons ce que cela signifie. OK, donc après quelques ajustements,
j'ai trouvé que la
bonne valeur était de 0,1 et
0,2 pour un minimum et un
maximum pour la valeur par défaut, puis nous allons l'abaisser encore plus chez
l'ennemi en ajoutant ce décalage de
volume Ce n'est donc pas la fin
du monde. Comme je l'ai dit. Les actifs sont parfaitement exploitables, mais ce ne sont que des éléments
utiles,
sachez que vous pourriez vous
faire livrer ou que vous pourriez trouver des actifs
sur des marchés, etc.,
et que certains ont peut-être
simplement été exportés avec un volume complètement
différent Il est donc utile de savoir que nous avons plusieurs endroits où nous pouvons appliquer différents décalages de
volume et autres
choses de ce genre Un projet ou un jeu
de production complet. C'est pourquoi il est également
très important de
disposer d'
un menu de paramètres avec des
curseurs audio vraiment flexibles afin que les utilisateurs
puissent choisir de rendre leurs effets sonores
plus faibles ou plus forts que leur musique, leur voix
off, etc. Et pour le plaisir de tout le monde
, y compris des miennes, veuillez régler votre volume principal
par défaut à environ 50 %. Personne n'aime activer le jeu et se faire détruire les
tympans
à 100 % du volume principal
lorsque le
volume
de votre jeu est complètement différent joué
sur le système son peut donc être très
important et il peut faire une très bonne ou une mauvaise
première impression sur votre jeu, selon
la façon dont vous l'utilisez. Mais encore une fois, c'est juste
quelque chose d'autre que vous
aurez envie de peaufiner
et de jouer avec Écoutez ce que vous pensez coups
de feu sur votre système
par rapport à l'explosion Découvrez où vous pourriez vouloir
modifier les modificateurs de volume, jouer avec les
différentes options
que je
vous ai présentées pour essayer de faire votre jeu sonne bien
et soit aussi intéressant à
écouter que possible, même si nous n'avons que quelques
fichiers audio différents avec lesquels jouer Vous pouvez également consulter
différents sites Web, HIO, freesound et d'
autres sites
similaires pour télécharger de nouveaux effets sonores
et voir ce que vous pouvez ajouter au projet pour vraiment
commencer à le personnaliser La principale chose que
vous recherchez est jouer au jeu
pendant quelques minutes. Est-ce que quelque chose commence
à devenir ennuyeux après cette 32e minute ? Et si c'est le cas, pouvez-vous
simplement résoudre ce problème en réduisant le
volume général de la file d'attente audio ? Ou si nécessaire, comme je l'ai dit, nous pourrions même
intervenir et retirer le coup de feu de l'ennemi car cela va
se produire si souvent Aucune de ces règles n'est claire et
précise que
nous devons suivre. Comme
pour beaucoup d'autres
choses, il faudra beaucoup d'
essais et d'erreurs pour
voir ce qui fonctionne et ce qui a le plus d'
impact sur votre résultat final. Le
feedback audio étant terminé, le jeu est désormais
présent, fournissant des commentaires
visuels et auditifs Ensuite, nous allons passer
aux animations de spawn, qui ne sont qu'une
option supplémentaire en plus de
la touche visuelle que nous avons déjà commencé à
ajouter à notre projet
26. 25 - SpawnAnimations: Dernière couche de finition, nous allons
présenter nos navires en détail. Le joueur
et les vaisseaux ennemis arriveront et tourneront vers leur position au lieu de simplement apparaître Encore une fois, une animation dans la classe de base
qui fonctionnera pour tous les plans avec lesquels
nous voulons travailler. C'est pourquoi
nous allons accéder
directement à notre tiroir de
contenu, à notre dossier de
plans, à notre
noyau, et nous
trouverons la base
plane de soulignement BP Nous voulons revenir
à notre graphique principal des événements, et à côté de notre début de partie, nous allons cliquer avec le bouton
droit de la souris pour rechercher une fonctionnalité pratique
appelée Ajouter une chronologie. C'est donc cette option en
bas. Nous pouvons lui donner un nom.
C'est une sorte de fonction qui possède son propre graphe intégré. Nous y reviendrons
dans un instant, mais nous pouvons donner ces noms. Nous appellerons donc celui-ci
anime, comme dans animate in. Comme pour tout le reste,
ils ne seront activés que lorsqu'une
exécution les atteindra. Nous allons tirer parti de
notre objectif d'exécution et nous voulons l'
intégrer dès le départ Il s'agira donc d'une courbe graphique sur
laquelle nous pouvons animer, et nous voulons simplement nous assurer
qu'elle commence toujours à jouer à partir de l'image zéro de la
courbe jusqu'à la fin Nous avons d'autres options, comme
jouer à partir d'un certain point, arrêter l'animation, jouer
en sens inverse ou autre. Nous voulons juste jouer essentiellement de zéro à la fin. façon dont cela fonctionne est un peu
comme une mise à jour temporaire, donc très pratique si vous n'avez pas besoin quelque chose pour animer une constante. Cela déclenchera chaque
image tant que
la chronologie sera jouée
avant qu'elle n'atteigne sa fin. Et
tant que cela se déclenche, il appellera le code de
mise à jour juste ici. Ensuite, une fois l'animation
terminée, il appellera l'épingle terminée. Nous savons donc si et quand
il joue toujours, et nous savons également quand il est atteint à la fin
de l'animation. Tout cela va
être très pratique. Donc, si nous double-cliquons sur
ce nœud jaune ici, et que nous
commençons à remarquer que la plupart des nœuds avec lesquels nous avons
travaillé ont des couleurs
différentes Ces fonctions bleues sont les
fonctions que nous sommes en train de créer Vous pouvez
donc toujours voir qu'une fonction
est désignée par du bleu Tout événement personnalisé ou un événement dans le graphique comme celui-ci reste
essentiellement une fonction, mais ceux-ci sont indiqués en rouge Nous avons des éléments tels que
les variables vertes, et nous avons maintenant une
fonction temporelle légèrement personnalisée,
notre chronologie d'animation,
qui est jaune. Lorsque nous les voyons assez souvent, nous pouvons double-cliquer dessus et nous aurons une
nouvelle fonctionnalité ici. Double-cliquez donc sur ce
nœud, et nous serons dans la chronologie. Il y a certaines choses que
nous voulons faire. Tout d'abord, nous avons besoin
d'une piste pour travailler avec une courbe d'animation
pour commencer à créer. Donc, si nous appuyons sur la piste
plus, nous avons plusieurs options différentes Nous pouvons essentiellement créer une courbe flottante, une courbe vectorielle, une
piste d'événements une courbe vectorielle, une
piste d'événements ou des
courbes de couleur. Nous voulons juste une très
belle valeur simple de zéro à un, essentiellement une
valeur normalisée que nous pouvons suivre Nous allons donc créer
une piste flottante ici. Et ce qui
est vraiment important, que nous pouvons cliquer avec le bouton droit de la souris et
faire glisser le pointeur pour passer au centre de la
souris pour zoomer, comme dans la plupart des autres
navigateurs d'Unreal Mais avant de commencer à
ajouter des images-clés
ou des épingles,
il est très
important ajouter des images-clés
ou des épingles,
il de définir la
durée de notre animation Si nous commençons à ajouter des épingles maintenant, vous pouvez voir que nous passons
d'un délai de zéro à 5 secondes. Nous allons donc réduire
cette longueur à un,
ce signifie simplement que
nous
travaillons immédiatement avec une chronologie courbe, c'
est-à-dire la longueur que
nous voulons qu'elle soit. Maintenant, la raison pour laquelle je fais
cela, c'est que
nous le verrons un peu plus en précisant les choses, mais nous ne considérons
pas cela comme un moment. Nous ne le faisons pas
en une seconde. Nous pouvons essentiellement considérer
cela comme un pourcentage. Cela représenterait 0 %
de notre animation, et cela représenterait 100 %
de notre animation. vous montre une
petite astuce pratique que je ne vois pas souvent
un peu plus tard. Et c'est ainsi que
nous pouvons adapter
cela pour en faire une animation de cinq
secondes,
une animation de dix secondes, une animation d'une
demi-seconde, comme nous le voulions. Tant que nous l'avons normalisé une plage de zéro à un, nous pouvons le traiter
davantage en pourcentage Maintenant, si nous zoomons
un peu ici, nous avons réduit légèrement la courbe
,
nous pouvons maintenir la touche Maj gauche enfoncée et
cliquer avec le bouton gauche de la souris et nous allons créer
ces images-clés ici Donc, si vous avez travaillé avec
d'autres logiciels d'animation, ceux-ci vous seront
très familiers. Ce sera le
moment où cela se produira et ce la force ou la valeur
à ce moment-là. Si vous avez cliqué au
hasard comme moi, nous n'avons besoin que de
deux points ici. Je vais donc faire glisser et
sélectionner certains de ces points, ces images-clés, et
je vais m'en débarrasser Première image-clé, je vais
la régler sur un temps de zéro et une valeur de zéro Donc, à ce stade, exactement aucune animation n'a eu lieu. Ensuite, pour la
deuxième image-clé, je vais simplement
sélectionner celle-ci, et je vais la régler sur un temps
de un et une valeur de un Voilà, 100 % de
l' animation est
maintenant terminée à 100 %. Vous pouvez donc commencer à voir comment
nous envisageons cela en pourcentage
plutôt qu'en
tant que valeur spécifique. Une autre chose que nous
voulons faire est de
rendre cela beau et
lisse tout de suite. Si nous devions animer le long de
cette piste, pour le moment,
ce serait juste une animation
très plate, cohérente et un peu ennuyeuse Donc, si nous faisons glisser et sélectionnons
les deux, cliquons avec
le bouton
droit sur l'une des images-clés et que nous la réglons simplement sur Auto, cela nous donnera un assouplissement
et un relâchement fluides Vous pouvez maintenant jouer
avec ceux-ci si vous le souhaitez. Vous pouvez le faire exagérer
quand il arrive pour la première fois, ou vous pouvez le faire très
lentement lorsqu'il arrive pour la première fois Et l'un des avantages
de travailler avec
ces images-clés comme
celles-ci est que nous pouvons modifier l'
animation pour la
rendre plus stylisée,
plus caricaturale, selon de travailler avec
ces images-clés comme
celles-ci est que nous pouvons modifier l'
animation pour la rendre plus stylisée,
plus caricaturale, ce que
vous recherchez BDefelt, je vais quand même le garder
comme ça. La dernière chose est que
cette piste zéro ou nouvelle piste zéro est quelque chose
que nous pouvons également modifier Je vais donc cliquer dessus. Je vais appuyer sur F deux pour le renommer, et je vais juste lui donner
le nom d'Alpha Parce que lorsque nous
commencerons à animer nos avions pour les faire voler, ce sont essentiellement les heures supplémentaires
Alpha que nous
suivons plutôt que la valeur de rotation
spécifique Et c'
est une chose que dans
de nombreux exemples, en travaillant
avec des chronologies, vous pouvez voir des personnes
animer directement l'emplacement
ou la rotation des valeurs vectorielles
réelles sur une période donnée, et j'espère que vous
verrez à la fin quel point
cela peut être assez
rigide, car,
encore une fois, si vous animez quelque chose qui prend exactement 7 vous pouvez voir des personnes
animer directement l'emplacement
ou la rotation des valeurs vectorielles
réelles
sur une période donnée,
et j'espère que vous
verrez à la fin à quel point
cela peut être assez
rigide, car,
encore une fois, si vous animez quelque chose
qui prend exactement 7 secondes, et vous
Je l'ai fait sur tous les XY et Z des valeurs de position
ou de rotation, puis vous décidez
que c'est trop rotatif et que cela doit prendre
deux fois moins de temps. Vous devrez entrer,
modifier la longueur de la piste, déplacer toutes les images
clés, et cela peut devenir un peu
fastidieux et fastidieux C'est où ? Nous
ne pouvons le définir qu'une seule fois, et nous avons désormais le contrôle total de l'animation dans notre code
actuel. C'est ça. C'est à
peu près terminé. Notre courbe est donc prête à fournir une
valeur Alpha au fil du temps. Donc, si nous appuyons sur Compiler
et que nous
revenons à notre
graphique d'événements ici, tout ce
que nous avons fait est de vous placer dans un onglet à l'intérieur de la
chronologie de l'animation que nous avons créée. Nous allons donc revenir
au graphique des événements. Donc, pour définir notre animation , tout d'
abord, à partir de
notre épingle de mise à jour, souvenez-vous de celle qui
s'exécute
constamment jusqu'à la fin de cette
animation, nous voulons appeler la fonction de
localisation de l'acteur à partir de là. Ce sera le
résultat d'un lp, encore une fois, nous allons
donc simplement utiliser la fonction larping
que nous avons déjà vue Donc, notre interpolation linéaire
entre deux vecteurs, pas l'interp deux
ou quoi que ce soit d'extraordinaire,
se contente d'un point A à un point
B avec un alpha Vous pouvez donc voir que la
raison pour laquelle nous l'avons appelée Alpha
est que nous pouvons les
connecter directement et nous avons déjà
une partie de la réponse ici, basée uniquement sur les conventions de
dénomination. Il nous suffit donc de
calculer ou de déterminer quel sera le point A et
quel sera le point B. Pour résumer ce concept, le point A
sera simplement le lieu de reproduction Donc, quel que soit le point
de départ , nous arriverons
au point A. Ensuite, nous
voulons atteindre un certain nombre d'unités avant ce point d'
apparition,
qui sera notre point B, ce qui
fait monter les joueurs dans le vif du sujet lorsqu'ils
travaillent sur
des animations sournoises et cela
crée de la confusion parce que
cela semble Mais quand on y pense, ce que je vais vous montrer ne
fait qu' embrouiller un peu
l'animation. Donc, ce que certaines personnes
feraient lorsqu'elles travailleront pour la
première fois avec des interpolations
linéaires, c'est que nous savons que le point A est notre point de
départ Nous pouvons donc cliquer avec le bouton droit de la souris et
rechercher la localisation de l'acteur. Pour beaucoup de gens, il
pourrait être logique que nous allions passer de notre point de
départ à un point final. Et nous pourrions dire que le
point final, par exemple, serait tout simplement l'
endroit où nous sommes actuellement plus une unité vectorielle dans une
certaine direction. Donc, si nous prenons l'endroit où nous nous trouvons
au point de départ
et que nous
projetons , disons, 300 unités avance, c'est là que
nous voulons aboutir. Ce
serait essentiellement notre point final. Cela ne marcherait pas de toute façon, mais pour mettre
très rapidement du code pour montrer que,
nous pourrions dire quelque chose comme nous savons que X est
avant », donc nous pourrions obtenir la position x plus 300
unités sur le X. Cela
semble être notre début et notre fin. Je voulais expliquer
cela et expliquer pourquoi nous ne l'
utiliserons pas précisément parce que je vois dans de nombreux projets
étudiants
et dans de nouveaux projets de développement, parce que, comme je l'ai mentionné,
cela a du sens. Nous avons notre point de départ et notre point final
en fonction de cela. Mais ce que les gens ne prennent pas en
compte lorsqu'ils le font c'est que cela ne se
déclenche pas une seule fois. Je pense que c'est là que les
gens trébuchent un peu. S'ils imaginent que cela n'est
lancé qu' une seule fois et que cette
valeur reste la même. Donc, si nous commençons à 000
et que nous ajoutons 300 à cela, nous nous attendons à avoir
30 000 comme point final Mais ce qui se passe réellement, c' chaque image
est appelée, et cela est revérifié Donc, si nous commençons à
zéro, zéro, puis que nous déplaçons certaines unités,
disons que nous avons déplacé cinq unités. À l'image suivante, lorsque cela se refroidit, nous sommes maintenant à 500. Cela signifie donc que le point de
terminaison sera plutôt de 30500. Ces deux valeurs sont
donc constamment en mouvement. Nous n'allons animer
que pendant cette seconde
ou aussi longtemps que
ce sera de toute façon Cela signifie que nous
arriverons à une fin, donc il semble que les
animations se produisent, mais cela paraîtra toujours un
peu bizarre, et peut-être même un
peu imprévisible parce que ces deux valeurs
sont constamment revérifiées et
mises à jour et qu'
un résultat lp différent est appliqué un résultat lp différent à la fin du calcul,
si cela a du sens était juste pour expliquer pourquoi
nous allons avoir besoin de
nous donner de la place, de faire
de la place ici. Et ce que nous voulons faire, c'est
nous assurer que ces valeurs sont
stockées et immuables Ce n'est donc pas une
chose difficile, mais je voulais simplement souligner que cela
se produit assez souvent, et je comprends
pourquoi les gens le font. Et c'est juste
quelque chose
à surveiller chaque fois que vous essayez de créer votre propre animation ou
de la personnaliser ultérieurement. N'oubliez pas qu'une boucle
a besoin d'un démarrage constant et d'une cible constante pour s'
animer harmonieusement entre elles. Donc, ce que nous allons faire à la
place, c'est prendre ceci, donc je vais couper Control X et coller la position de l'
acteur. Nous allons le
promouvoir en tant que variable, et nous l'appellerons « emplacement de départ
unique ». C'est très clair, branchez-le, et ensuite nous ferons quelque chose de très similaire ici. Et comme je l'ai mentionné,
cela ne fonctionnerait pas toute façon parce que nous ajoutons
simplement une unité. Nous ne
prenons pas vraiment en compte la direction dans laquelle
l'avion regarde, nous devons
donc faire un
peu plus que cela de toute façon. Mais même si nous
faisions le processus complet, celui-ci ne
fonctionnerait toujours pas. Nous allons donc simplement le
déplacer, le saisir,
donc le couper et le coller ici. Nous pouvons toujours
en utiliser un tas. Maintenant, la première chose à faire
est
de se rappeler que les ennemis veulent également l'
utiliser, et qu'ils seront renversés lorsqu'ils apparaîtront Nous ne voulons donc pas qu'
ils soient animés en haut de l'écran comme le joueur. Nous voulons qu'ils
soient animés en
fonction de la direction dans
laquelle ils se trouvent. Donc, ce que nous allons faire, c'est
rechercher vecteur vers l'avant de l'acteur
G. Cela permettra donc d'obtenir
la direction dans laquelle l'acteur fait l'objet d'une rotation
ou dans laquelle il fait actuellement face Souvenez-vous de cette flèche que nous avons
appliquée au projectile, je vais essentiellement vérifier dans
quelle direction cette
flèche est orientée Nous voulons ensuite le multiplier
par une valeur. Nous allons donc prendre
le vecteur avant, qui est une direction et
non une valeur. Il sera
donc soit
11 et un, sera
donc soit soit 100 s' il est orienté vers l'avant, soit moins 100 s'il est orienté vers l'
arrière, par exemple Nous allons multiplier
la direction, pas la position réelle du vecteur, c'est
pourquoi nous
pouvons la multiplier. Nous allons le multiplier
par un flottant Nous allons
donc
cliquer avec le bouton droit sur l'épingle ici, transformer en valeur
flottante, et nous pouvons
toujours prendre cette valeur de 300
unités ici. Nous voulons donc déplacer 300 unités vers l'avant. Nous
pouvons ensuite en faire usage. Nous voulons donc prendre
cette valeur et ajouter à
un autre vecteur. Et en fait, nous allons nous
débarrasser de celui-ci. Ces notes ne
seront donc plus nécessaires, juste pour garder les choses
bien rangées, et nous allons les
ranger un peu Et ce que nous voulons emporter,
c'est que là où nous avons commencé, nous voulons que notre position
de départ soit le XY et le Z. Plus 300 unités
vers l'avant. Donc, en multipliant notre vers l'avant pour
obtenir un retour négatif ou positif, selon que
nous sommes orientés vers l'avant ou vers l'
arrière
et le X, nous allons prendre cela
et diviser certaines valeurs ici Donc, la première chose à faire pour que
cela soit un peu plus facile à lire est de promouvoir
cette épingle au rang de variable, et nous nommerons cet
emplacement cible. Nous pouvons utiliser Alt et
cliquer avec le bouton gauche de la souris pour le faire défiler vers le bas. Nous allons diviser l'épingle de
la structure ici. Nous avons maintenant tous
les nœuds dont nous avons besoin. Nous pouvons
arranger les choses un peu, nous voulons vraiment que notre première
épingle soit notre point de départ. Encore une fois, juste par préférence
personnelle, je vais contrôler et faire glisser le point de départ
et remplacer celui-ci. Nous pouvons donc prendre
notre point de départ plus un décalage dans la direction que nous recherchons d'un nombre X d'unités. Cela va
nous déplacer de 300 unités dans le X, c'est ce que nous cherchons
ici parce que X vaut quatre. Donc, si nous pouvions obtenir le vecteur
get actor up, et si nous le
branchions à la place,
cela appliquerait un décalage sur l'axe Z uniquement parce que
Z est situé à l'intérieur d'Unreal X est en avant, Y est sur le côté. Nous pouvons donc obtenir différentes positions
vectorielles avec certaines
fonctions intégrées ici. Nous voulons simplement envisager d'
aller de l'avant. Ensuite, nous ne pouvons pas
utiliser la valeur totale ici parce que nous voulons que
nos Y et Z restent cohérents quel que soit l'endroit où nous tournons ou nous déplaçons ici. Je vais donc saisir à nouveau l'emplacement de
départ, dupliquer ici,
diviser l'épingle de la structure. Et nous pouvons ajouter le Y et
le z à ces valeurs ici, c'est
pourquoi je l'ai séparé
il y a un instant. Et puis, quelle que soit cette valeur, donc le calcul de
la distance que nous voulons parcourir dans notre direction locale
vers l'avant, nous allons également diviser cette
structure en deux, et ce sera la valeur
X que nous voulons. N'oubliez donc pas qu'il ne s'agit de
calculer que le X de toute façon, nous pouvons
donc prendre cette valeur X. Ce sera le nombre
d'unités vers lesquelles nous voulons voler dans la valeur
X ou future. Et ce sera notre
cible. Nous allons donc les brancher. Il se peut que nous ayons besoin de ranger
les choses et
de les déplacer un peu,
mais c'est parfaitement bien Nous pouvons simplement
le déplacer vers le bas et
revenir y remédier
un peu plus tard L'essentiel est que nous puissions
maintenant revenir à notre boucle. Et encore une fois, cela rend
les choses claires et claires maintenant. Nous allons lui donner
notre position de départ et notre position cible comme arguments
A et B. Donc, si nous y allons, nous pourrions
probablement tester cela juste pour nous assurer que quelque chose se passe vraiment ici. Et nous pouvons voir que l'avion du
joueur glisse définitivement un
peu vers l'
avant , tout
comme l'avion ennemi. Il glisse donc vers l'intérieur, puis
il se déplace d'un côté à l'autre. Nous pouvons donc voir que l'animation
initiale fonctionne et qu'il en va de
même pour le joueur, ce qui signifie que
nous voulons
probablement reprendre le jeu et le recommencer un
peu plus loin arrière
et le recommencer un
peu plus loin. En fait, nous
pouvons simplement venir ici. Autre chose dont vous n'êtes
peut-être pas au courant. Et c'est très
pratique car nous pouvons obtenir notre position parce que nous savons que c'est là que nous
voulons nous retrouver à ce
stade de l'écran, et nous pouvons taper ici -300 Donc, si nous tapons -300, cela fonctionne en fait
comme une équation mathématique, qui nous donne -190 -300, et nous obtenons exactement moins 490, ce qui sera notre point de départ, puis nous arriverons par avion et nous finirons exactement
là où
nous Donc ça a vraiment l'air un
peu plus intéressant. Je trouve que ça a l'air plutôt cool. C'est donc certainement
un bon début. Et vous pouvez voir,
espérons-le, comment tous ces calculs s'
assemblent et fonctionnent. Encore une fois, nous avons fait en
sorte que cela fonctionne
en prenant en compte le
vecteur avant de l'acteur. Donc, la façon dont il a été
pivoté, et juste pour récapituler
pourquoi c' est pertinent,
c'est que lorsque nous apparaissons
dans les ennemis,
nous les faisons pivoter de
180 degrés pour qu'ils
correspondent à la direction
de pointage de notre classe d'apparition ici Ils avancent donc selon
qu'ils pointent ou non, qui signifie que tout
s'anime correctement C'est donc la première
partie du puzzle. La deuxième partie
rendra cela encore plus intéressant en fournissant également un décalage de
rotation. Ainsi, après avoir défini la position des acteurs, nous voulons uniquement modifier
l'élément visuel de la rotation,
afin de ne pas perturber le collisionneur de
sphères et modifier potentiellement la façon
dont les acteurs font face Nous allons donc simplement en
faire un
changement visuel plutôt qu'une position ou un changement
réel. Donc, pour ce faire, nous obtenons
souvent des choses comme utiliser le
maillage statique à la place. Nous allons l'enfoncer dans le sol, nous allons
en tirer parti et nous allons
rechercher une rotation mondiale définie. donc la même chose, mais nous n'affectons plus que le maillage à la place. Et c'est bien mieux
parce que nous ne faisons aucune collision ou quoi important avec le maillage de toute façon. C'est là uniquement
pour faire des choses visuelles, et il s'agit d'un changement visuel. Nous allons donc le brancher pour
qu'il soit appelé immédiatement, et nous allons faire
quelque chose de très similaire Nous allons prendre
notre Alpha et faire une boucle pour le rotateur Nous allons donc partir d'ici
et rechercher à nouveau une boucle, rotateur
p, et encore une fois, obtenir la même chose, A
et B avec un Alpha Cette option est totalement facultative.
Vous pouvez transformer l'Alpha en variable uniquement pour
l'utiliser dans cette fonction. Une autre chose
que je voudrais présenter
, c'est que nous
pourrions simplement le faire. J'ai double-cliqué sur le fil. Et encore une fois, juste pour
que les choses soient un peu plus ordonnées, je vais juste brancher
les Alpha de cette façon Comme ce sont
les deux seules fois où nous allons l'utiliser ici,
je pense qu'il est peut-être
un peu exagéré de créer une variable de trajectoire
juste pour cet incendie
ponctuel peu exagéré Je vais donc simplement présenter
l'utilisation des nœuds de réinitialisation. Cela permet de le garder un peu ordonné et facile à
visualiser et à utiliser Ensuite, pour l'A&B, nous allons refaire une chose très
similaire ici, mais nous allons obtenir
les valeurs de rotation Vous voudrez donc peut-être commencer à ranger certaines
choses ici C'est là que, comme
je l'ai mentionné séquences peuvent être vraiment bonnes. Donc, une découpe très rapide ici. Nous voulons éventuellement commencer à suivre ce que nous faisons
pour initialiser les valeurs, essentiellement lorsque nous définissons
et analysons des valeurs
au début C'est ce que l'on appelle
normalement l'initialisation. Et je pense que je pourrais
séparer cela de notre animation
chronologique réelle. Tellement simples et gentils, encore une fois, ces facteurs de référence ne prennent pas
vraiment longtemps. Si nous tirons de
l'épingle d'exécution ici et
que nous recherchons une séquence, elle sera automatiquement connectée. Nous ne
changeons donc rien vraiment. Encore une fois, il s'agit simplement d'organiser l'ordre dans
lequel les choses sont traitées. Je vais juste décrocher ces
nœuds juste ici, puis je déplacerai
l'animation vers le bas. Ce que nous allons faire, c'est
d'abord nous assurer que toutes les variables
sont
prêtes, puis une fois que nous aurons suivi
toutes les variables que nous allons utiliser
à l'
époque, nous appellerons
notre animation pour qu'elle soit jouée. Encore une fois, tout
cela ne fait que rendre les choses
un peu plus ordonnées, plus faciles à lire et
plus faciles à utiliser Cela signifie que nous pouvons maintenant commencer à en déplacer certains, car nous voulons d'abord toutes ces vérifications
basées sur la localisation. Cela nous permet donc de conserver notre position de
départ. Ensuite,
nous voudrons également
obtenir notre rotation de départ. À partir de là, nous pouvons rechercher la rotation du monde
G sur le maillage statique, de la même
manière que nous l'avons fait précédemment. Je vais faire glisser notre maillage statique, nous
utiliserons la rotation du monde G. Et comme nous
l'avons fait pour les emplacements, nous allons simplement prendre cette valeur et la
transformer en variable. Et c'est
exactement pour la même raison. Lorsque nous l'utilisons
dans une animation, nous ne voulons pas que cette valeur
change au fil du temps. Cependant, nous commençons notre rotation lorsque
nous apparaissons dans le monde. C'est notre point de départ,
et nous allons également avoir une compensation permanente par rapport à cela une compensation permanente par rapport à cela
en tant que point
cible permanent. Maintenant, nous pouvons le faire un
peu plus facilement. Nous n'avons pas besoin d'une
cible réelle pour le B. Vous pouvez promouvoir une variable
en cible si vous le souhaitez, mais c'est un
peu plus simple. Donc, pour notre rotation de départ, nous allons simplement placer la rotation de
départ sur A, donc c'est de là que nous effectuons
la rotation. Et puis notre cible. Donc B, nous pouvons simplement diviser la goupille de la structure
ici, car la seule chose dont nous
voulons tenir compte
, c'est que nous effectuons une rotation de roulement de 720
degrés. C'est du moins ce qu'ils ont
fait dans l'exemple de projet. Et encore une fois, nous ne faisons
que recréer cela d'une manière un peu
plus ordonnée Donc, ce que nous pourrions faire,
c'est faire glisser notre rotation de départ ici,
diviser l'épingle de la structure. Nous savons que nous voulons que le Y
et le z restent identiques. Nous ne voulons pas ajouter de rotation
ascendante ou descendante. Nous ne tournons pas
autour de nous. Nous savons que nous indiquons que
le maillage statique
commence toujours par une rotation de zéro, car nous
n'avons pas changé cela. Et même en ce qui concerne les
ennemis, nous faisons pivoter l'ensemble de
leur acteur
plutôt que leur
maillage statique au départ. Cela signifie que nous
pouvons en toute sécurité simplement ajouter une rotation de 720 degrés au X, qui roule sur lui-même. Souvenez-vous de ce que nous faisons
pour que cela
fonctionne de cette façon. Nous faisons une chose très
similaire ici. Donc, si nous appuyons sur compiler et sécuriser, nous pouvons tester cela, et
encore une fois, cela devrait fonctionner. Tellement sympa, facile. Vous pouvez voir que cela
fonctionne parfaitement. C'est donc ce que nous voulions
là-bas, une rotation de 720 degrés ou deux fois
sur elle-même. Si vous vouliez
qu'il s'agisse d'un seul 360,
pour qu'ils tournent un
peu plus lentement, nous pouvons certainement
le réduire,
donc il ne s'agira que d'un
seul rouleau, ou vous pourriez vous déchaîner, peut-être le faire effectuer cinq rotations 360
différentes, et il tournera plusieurs fois ici Pour que tu puisses t'amuser. Tu peux jouer avec
ça exactement comme tu veux. Comme je l'ai dit, d'après
le projet de référence, celui que nous
essayons de recréer, je pense que c'est juste un rouleau à 720 degrés
qu'ils y ont fait C'est ainsi que nous pouvons appliquer cela. Joli et simple. Nous
n'avons pas vraiment besoin d'une cible précise, car il s'agit
simplement de la rotation de départ avec un décalage de 720 degrés pour la
faire tourner deux fois. Cela permet également de combler un élément important qui nous manquait
depuis longtemps, même si le
code était prêt dans notre projet. Et c'est que le joueur et les ennemis ne devraient pas
vraiment se déplacer côte à côte tant qu'ils n'ont pas terminé leur animation
sportive. Encore une fois, c'est juste pour la parité
avec l'exemple de projet. Si vous y jouez à partir
des exemples de contenu, vous verrez que vous
n'êtes pas réellement autorisé à contrôler et à déplacer les navires tant qu'ils n'ont pas
terminé cette animation d'introduction Nous pouvons donc réellement en
faire usage. Notre
mouvement est déjà activé. Cela a toujours
été vérifié, donc nous n'en avons tout simplement rien
fait. Nous pouvons donc maintenant l'extraire
de notre classe de base. Nous pouvons définir ce paramètre sur false
par défaut, afin de ne pas autoriser
le mouvement au départ. Donc, si nous entrons et que nous
appuyons sur Play, nous sommes complètement
bloqués, tout comme
l'ennemi, et c'est en
quelque sorte ce que nous voulions. Et c'est là
qu'il était important de vous
présenter le système d'animation. Parce que souvenez-vous, j'ai dit que
cela nous indique que toutes
les informations
sont appelées ici
pendant que les animations se produisent
encore. Et
dès que les animations terminées, on l'appelle. Nous pouvons donc maintenant tirer
à partir d'ici ou simplement faire glisser le
mouvement B activé. Cela nous donnerait
un setter juste ici, et nous pourrions le définir pour qu'il soit vrai uniquement lorsque l'
animation intra est terminée Nous pouvons donc maintenant entrer, tester, jouer. Nous ne
pourrons pas bouger
tant que cette animation ne sera pas
terminée. Encore une fois, c'est complètement facultatif, mais j'essaie juste rapprocher le
plus possible du projet Example. C'est une fonctionnalité qu'ils ont implémentée, alors j'ai pensé
en parler ici. Mais c'est à peu près tout.
Techniquement, cela fonctionne. Comme pour tout, je
voulais approfondir un peu plus avec vous. C'est certainement une option à 100 %, mais je trouve que c'est une chose
vraiment très intéressante à connaître en ce
qui concerne les chronologies et la façon dont nous pouvons manipuler la vitesse de lecture de notre animation sans passer par
le graphique des événements Maintenant, une chose que
je pense vouloir faire, juste une dernière chose à modifier, c'est de saisir le nœud ici, et je vais y donner
un mouvement un peu plus exagéré Cela va en quelque
sorte accélérer puis
diminuer au fil de
cette animation. C'est donc purement visuel, mais cela vous donne une grande
liberté quant à la fluidité ou à
la netteté de certaines animations. Je ne veux donc pas qu'il soit trop élevé. Si nous avions une courbe comme celle-ci, elle dépasserait en fait
le point cible, qui se trouverait à peu
près ici. Ainsi, la cible pointe ici, elle dépasserait
ce point cible, puis elle
reviendrait à son point cible Donc ça aurait l'air un peu bizarre. Jetons un coup d'
œil. En fait, il vaudrait mieux que je clique sur Simuler. Vous pouvez voir que l'ennemi était bien au-delà de sa cible
et qu'il avait besoin de s'animer en retour. Alors fais attention à ne rien
faire de tel, mais je pourrais le rendre un
peu plus précis, afin que nous puissions intervenir un
peu plus vite un peu difficile à voir parce qu'il y a
ce temps de chargement, mais c'est probablement
très bien. Maintenant, ce que je
voulais vous présenter, c'est que, comme je l'ai mentionné, une chose que je vois
beaucoup de développeurs
faire, c'est qu'ils peuvent
essayer cela et penser,
en fait, une faire, c'est qu'ils peuvent
essayer cela et penser, seconde, c'est trop rapide. Je veux que cette animation
dure 3 secondes. Vous devez donc
remonter, ajuster votre longueur,
saisir vos images-clés, déplacer vos images-clés, jouer
à nouveau avec les courbes Vous pouvez voir à quel point cela
va devenir assez compliqué, si vous devez continuer à faire des
allers-retours Nous n'allons donc pas le faire. Si vous ne faisiez que
suivre,
appuyez plusieurs fois sur Ctrl, et nous
ramènerons la longueur de la courbe à un, donc la
longueur totale à un. Ce que nous pouvons faire à la
place, et je trouve
que c'est cette astuce qui
est vraiment puissante avec délais, c'est que nous pouvons
revenir ici et peut-être juste après avoir défini
le lieu et la rotation Nous pouvons récupérer les informations de notre
chronologie qui
sont réellement
transformées en un composant. Donc, si nous déposons ce composant dans la section des
variables, nous pouvons récupérer notre Anim dans détails de la
chronologie et le
déposer ici Nous allons donc obtenir les
informations pour Anim. À partir de là, nous pouvons
tirer et trouver
ce que l'on appelle un taux de jeu défini. Nous pouvons donc voir que c'
est le taux de jeu à
quelle vitesse cette
chronologie se joue Et puis, si nous le branchons ici, nous avons maintenant contrôle
total, car nous savons
que nous avons normalisé cela, avons
donc porté à 0 à 1 seconde Si nous augmentons le
taux de jeu, disons simplement que nous travaillerons avec de simples
nombres ronds. Nous allons dire deux. Ce jeu se joue maintenant
deux fois plus vite, donc cela va
prendre une demi-seconde, car s'il
joue une seconde par défaut , c'est sa durée. S'il joue deux fois plus
vite,
il jouera évidemment deux fois moins
longtemps Toute cette
animation sera donc désormais réalisée en une demi-seconde. Donc, en gros,
à cause du chargement, nous ne voyons
même pas cela se produire. J'aurais besoin de simuler. Et oui, c'est presque
impossible à voir. Mais si nous le fixons
à quelque chose comme 0,5, cela va maintenant
prendre deux fois plus de temps, donc cela va prendre 2 secondes. Nous avons donc maintenant une belle animation longue
et fluide, il ne leur reste plus que 2
secondes pour entrer. Nous avons donc maintenant des mathématiques
vraiment basiques, nous avons maintenant un contrôle total
sur le temps que cela prend Nous pouvons réduire cela à
quelque chose de vraiment très lent, 0,1 suit toujours
la même courbe. Il fait toujours
la même animation, mais cela prend maintenant
plus de temps en
fonction de l' impact que vous faites
sur le taux de jeu ici. J'espère que vous pouvez en voir l'intérêt,
comme je l'ai mentionné. Cela signifie simplement que
nous n'avons jamais besoin de revenir dans notre chronologie. Nous n'avons
plus jamais besoin de modifier la courbe , car nous l'avons
normalisée pour l'organiser Et si nous voulions augmenter ou diminuer le temps de lecture, nous pouvons simplement récupérer
cette valeur ici. Et je pense que ce que je
pourrais faire, c' qu'une seconde était probablement
un peu trop rapide, donc je pourrais régler ce paramètre sur
quelque chose comme 0,75 Nous pouvons appuyer sur compiler et
enregistrer, puis vérifier. Je trouve que ça a l'air
plutôt beau et fluide, donc j'en suis content. Mais encore une fois, vous pouvez certainement jouer, modifier les valeurs Et c'est
tout l'objectif de ces sujets, car je ne
vous donne pas un résultat
spécifique prédéfini à atteindre. J'essaie de vous montrer
les différentes manières
dont vous pouvez exposer
et extrapoler certaines des valeurs et
variables avec lesquelles nous
travaillons et vous
approprier réellement le projet Donc, si vous voulez qu'elles soient vraiment rapides et qu'elles pivotent trois fois, vous avez le
contrôle total sur cela avec les variables ci-dessous Vous avez le
dramaturge. Et encore une fois,
c'est probablement le
bon moment pour commencer à réfléchir à la propreté
de votre projet. Nous avons maintenant un grand nombre de variables. Nous devrions donc peut-être commencer à les
classer dans des catégories. Nous avons des chiffres magiques, nous pourrions
donc également commencer à promouvoir des choses comme
celles-ci dans une variable. Nous pourrions promouvoir
celle-ci à une autre variable, l'
appeler quelque chose comme les diplômes d'
introduction ou quelque chose comme ça. J'
essaie d'être un peu plus clair. C'est l'animation d'introduction et pas spécifiquement la
rotation que nous voulons obtenir, mais le nombre de
degrés qu'elle fait rouler Et puis ici, nous pourrions avoir le taux de lecture des
animations, donc nous allons également le
promouvoir en tant que variable. C'est donc bien parce que
l'essentiel, comme je ne cesse de le mentionner
avec les variables, même si nous ne faisons rien de
spécifique avec elles, est excellent car nous
n'avons pas besoin de
plonger dans notre code. Nous voulons toujours éviter d'
avoir à entrer et à nous
plonger dans des
éléments codés en dur de notre logique. Au lieu de cela, si jamais nous
voulions essayer quelque chose rapidement, nous pourrions simplement prendre
la base aérienne maintenant. Nous pouvons appuyer sur compiler, nous
assurer que cela a été mis à jour. Nous pouvons saisir toutes les variables et trouver ici
que nous pouvons modifier le taux de jeu dans les deux sens
et toutes les valeurs avec lesquelles nous voulions rapidement
voir des modifications Comme je l'ai mentionné, il en va de même pour C plus, et cela
se produit en bleu. Vous vous retrouvez avec un
grand nombre de variables, alors vous voudrez peut-être
commencer à classer les choses dans de belles catégories logiques
ou quelque chose comme ça, mais c'est
à vous de le faire entre les sujets. Autre chose pour vous
entre deux sujets, une petite expérimentation, car
nous
n'avons fait que jeter un
bref coup d'œil aux animations. Je recommande vivement de
jouer avec les objets. Voyez si vous pouvez le
faire jouer en sens inverse fois qu'il a déjà été joué une fois. Faites quelque chose comme
utiliser des événements personnalisés. N'oubliez pas comment nous pouvons créer
nos propres événements personnalisés, comment nous pouvons
les appeler de n'importe où. Nous pourrions certainement connecter
quelque ch
27. 26 - CameraShakeKnockback: Pas encore terminé. Nous pouvons encore
peaufiner ce projet. Nous allons envisager des moyens de
neutraliser collisions
et
les tremblements de caméra,
afin de faire en sorte que chaque coup
donne l'impression que c'est important Nous verrons le
contrecoup un peu plus tard. C'est un peu plus pratique que
le tremblement de l'appareil photo. Nous allons commencer ici. Donc, pour commencer,
nous allons simplement accéder à notre tiroir de contenu et nous
assurer que notre structure de
dossiers est configurée. Et dans le dossier principal des
Blueprints, nous allons créer
un nouveau dossier ici, que nous
appellerons simplement un tremblement de caméra Nous pouvons ajouter différents types de vibrations de caméra à notre projet. Nous pouvons donc avoir certaines intentions
pour les explosions, et peut-être en avoir d'
autres plus modérées
pour les projectiles qui
tirent ou Encore une fois, c'est
à vous de
décider, en fonction de l'impact que vous
souhaitez avoir sur le joueur. Pour créer un tremblement de caméra, nous avons en fait besoin d'une classe personnalisée, ce qui est vraiment agréable et
facile. Nous faisons un clic droit. Nous pouvons suivre notre
cours de dessin ici. Je ne sais pas trop où
il se trouve dans les catégories, mais on peut tout simplement
rechercher Camera Shake. Vous pouvez le constater, étant donné
que Epic New
est très populaire à ajouter
à de nombreux jeux, ils ont en fait créé
des classes personnalisées avec lesquelles nous pouvons travailler. Nous voulons celle-ci ici,
la base de vibration de la caméra. Nous avons quelques anciennes options et une version personnalisée de celle-ci, mais nous
allons simplement travailler avec
la version de base rudimentaire,
appuyer sur Select, et
nous l'appellerons
BP Underscore Camshak Small BP Underscore Nous allons double-cliquer pour l'ouvrir, et nous n'avons en fait pas besoin du graphique des
événements en
arrière-plan ici. Je vais donc le fermer
très rapidement car un moyen très
simple de revenir à l'affichage
des données uniquement dans affichage
des données uniquement dans certains Blueprints est de
les fermer , de double-cliquer
pour les rouvrir Et tout ce que nous avons vraiment
besoin de voir, ce sont nos
propriétés de vibration de la caméra juste ici. Nous ne
programmerons rien, nous pouvons
donc simplement travailler avec les
propriétés prédéfinies fournies. La principale chose que nous voulons
changer, c'est que le
modèle Root Shake est défini sur none. Nous allons le laisser
tomber et rechercher Perlin. Cela fournit une
belle randomisation
en utilisant des modèles de bruit
Perlin prégénérés Si vous vous souvenez de ces raccourcis que j'ai mentionnés il y a de nombreux sujets, c'est là
que des choses comme maintenir la touche Maj enfoncée et glisser les flèches vers le bas
peuvent être très utiles. Donc, si nous cliquons
à nouveau dessus en maintenant la touche Shift
enfoncée, toutes les catégories seront
dépliées. Et si nous voulons
tout replier,
nous pouvons maintenir la touche Maj enfoncée,
cliquer dessus pour les sauvegarder. Et encore une fois, ça les
range bien. Donc, comme il y a
tellement de propriétés différentes auxquelles
nous voulons accéder, je vais tout
rabattre, afin que nous puissions
les parcourir dans l'ordre et trouver par quoi. Pour commencer, nous avons l'amplitude de localisation
et le multiplicateur de fréquence. Je vais les laisser
à une. Cela prend l'ensemble de l'animation générée et ajoute
un multiplicateur à l'amplitude et à la
fréquence sur
le X, le Y et le z
pour la rotation, emplacement et le champ de vision. C'est pratique si nous voulons apporter de très grands changements, mais en général, nous voulons
travailler sur une base par point. Donc, compte tenu du faible impact que
nous avons en ce moment, peut-être chaque fois qu'un
projectile touche quelque chose, nous voulons que la caméra avance
légèrement vers
l'avant, juste pour montrer qu'un certain
impact a été reçu Nous savons donc que l'
avant est le X, nous pouvons
donc prendre cela
et commencer à
ajouter de l'amplitude à
la position X. Si nous ajoutons ici une valeur de 200, c'est une amplitude, une
sorte de force,
qui est appliquée. Ensuite, la fréquence
correspond au nombre de secousses avant et en arrière que
cela va produire Donc, si nous nous en tenons à
un, ce sera comme une belle secousse à chaque
fois qu'un projectile frappe Il faut éviter d'ajouter
trop de fréquence dans de nombreux cas, car c'est
ce qui donnera aux gens un
peu le mal des transports. Il sera un
peu plus difficile lire et
de juger ce qui
se passe à l'écran. Mais encore une fois, tout cela
peut dépendre de
vos préférences personnelles, du
type de projet et du style
général que vous avez adopté. Je vais laisser cela
pour la fréquence, et je tiens cela à l'esprit, nous pouvons passer un peu plus vite pour les autres axes ici. Je veux donc que cela
oscille un
peu plus d'un côté à l'autre, mais
avec moins Je vais donc régler cela à
40 et à 10 pour la fréquence. Encore une fois, dix, c'est peut-être
trop d'oscillation côte à côte, mais en vendant ce chiffre
à quelque chose de plus grand, nous pouvons revenir et affiner cela plus tard si cela pose un Pour la rotation,
je vais
les laisser toutes par défaut. Bien souvent, nous
ne voulons pas faire pivoter la caméra, ce qui est presque sûr de provoquer une
sorte de perturbation du
feedback visuel,
vous aurez certainement le mal des
transports à cause de
cela sorte de perturbation du
feedback visuel, . À moins que vous n'ayez une
très bonne
raison de l'utiliser et que vous sachiez
ce que vous faites. Je vais donc laisser la
rotation totalement intacte. de même pour le champ de vision, vous pouvez jouer
avec eux si vous le souhaitez, mais je ne veux pas trop les
modifier Enfin, le
mélange pendant la nuit, le temps qu'il faut
pour atteindre leur apogée
et le temps qu'il faut
pour revenir du pic à l'arrêt de l'animation
, puis la
durée et le temps qu'il faut pour revenir du pic à l'arrêt de l' animation
, puis la Je vais donc faire en sorte que
ça dure 3 secondes. L'impact sera
relativement faible, mais il durera
un certain temps. Nous avons donc dû compiler et enregistrer. C'est à peu près notre configuration de classe
Camera Shake. Maintenant, avec la configuration de la
propriété de base ici, pendant que nous faisons cela, nous pouvons tout aussi bien créer
quelques options différentes pour nous permettre de les intégrer et de les
tester. Je vais donc faire légèrement trembler
notre appareil photo, appuyer sur la touche Ctrl, en effet,
pour le dupliquer, et je vais en créer
un appelé medium. Je vais dupliquer celui-ci
et le qualifier de grand. Nous pourrions donc avoir
différents types d'impacts, en particulier pour des choses
comme les explosions. Je voudrais probablement un impact légèrement différent mais beaucoup plus important car cela ne se produit pas
trop souvent de toute façon, et nous pouvons ensuite modifier ou itérer entre les impacts faibles et moyens pour
différentes raisons Pour Medium, je vais venir
ici. Nous allons porter l'amplitude à
environ 500, peut-être augmenter l'
amplitude sur le Y à 90, 15 sur la fréquence. Encore une fois, nous pouvons toujours
revenir et nous pouvons les
modifier si cela est trop important. Je viens de me rendre
compte en
repensant à la façon dont je
voulais mettre cela en place. Si l'appareil photo tremble légèrement,
je pense que nous voulons la durée soit de
0,3, et non de 3 secondes. D'une durée de 3 secondes. Si vous imaginez que je parle maintenant, cela
prend environ 3 secondes. L'écran
aurait vacillé pendant toute la durée de cette phrase, ce qui est un peu trop. Nous allons donc le
compiler, réduire à 0,3 parce
que nous ne voulons pas trop stimuler visuellement
les gens. Nous pouvons donc
faire la même chose ici. Nous allons régler ce paramètre sur
0,3. Nous pouvons peut-être porter ce chiffre à 0,4 parce qu'
il y a encore plus de secousses. Il y a peut-être une raison de le laisser persister
un peu plus longtemps Nous allons donc définir ce paramètre sur 0,4.
Même chose pour les grands. Nous voulons que celui-ci
ait vraiment car comme il se
trouve
tout près de l'appareil photo,
vous aurez l'impression que quelque chose explose, ces
effets de grosses particules se produiront. est donc logique que celui-ci soit un
peu plus fort. Je vais donc modifier le multiplicateur
global ici pour
vraiment donner un coup de pouce. Nous allons donc régler ce paramètre sur cinq, puis sur l'amplitude, je vais le régler sur 900 L'amplitude Y,
mettez-la à 160. Je vais laisser
la fréquence à dix heures. Nous ne voulons pas trop que cela se passe
côte à côte. Encore une fois, je pense qu' s'agit de
régler celui-ci à 0,5 seconde ou simplement de
leur donner de petits incréments, afin qu'ils soient tous
sensiblement différents lorsque nous effectuons notre
lecture et nos tests Encore une fois, il
n'y a ni bien ni mal. J'ai peut-être atteint des valeurs
très élevées, peut-être même trop élevées, mais nous pouvons toujours les affiner
et les ramener disant que c'est
définitivement trop élevé. J'ai dit 900, mais jusqu'à 9 000. Il serait presque impossible de voir
ce qui se passait, alors nous allons
nous assurer de modérer les choses. Ne dis pas ça trop haut. Nous n'avons donc pas trois
intensités à tester, il suffit de l'
implémenter dans notre code Un système
pré-construit est tellement beau et simple qu'il est prêt pour nous. Je vais retourner à la base aérienne BP
Underscore. Je les
garderai ouvertes au cas où je
voudrais revenir et modifier
les valeurs à tout moment À l'intérieur de la base aérienne BP, l'
une des
plus évidentes à gérer premier serait la fonction de
mort. Nous avons donc notre fonction Handle
Death. Nous avons encore du travail à faire ici si vous deviez
le trouver de cette façon. J'ai donc mon
commentaire à faire, et c'est l'effet final que je savais que je voulais
revenir et mettre en œuvre Nous pouvons donc tirer parti de l'épingle
d'exécution ici. Nous allons rechercher
une fonction appelée Play World camera shake.
Vous pouvez le voir juste ici. Cela ressemble beaucoup
à nos trois signes D,
donc à nos signes directionnels et
même à notre système de particules. Encore
une fois, une fois que vous commencez à
apprendre à utiliser
l'une des différentes
fonctionnalités d'Unreal, vous
comprenez également comment faire les autres choses,
si cela a du sens Nous avons donc ici,
par exemple, l'épicentre, qui est l'endroit à partir duquel le
shake commence à émettre Donc, c'est simple et agréable, nous
allons dupliquer ceci, obtenir
la localisation de l'acteur
et le brancher. Donc, le tremblement de la caméra
devrait
provenir du vaisseau Aber qui
vient d'exploser, puis il va en quelque sorte projeter
de la lumière vers la caméra, c'est le
genre d'idée générale Nous le faisons en fonction d'un rayon, sorte que
c'est dans le rayon intérieur que
cela sera le plus fort. Donc, si la caméra se trouve juste à
côté de l'avion qui explose, elle subira toute la force du plan de tremblement de la caméra Nous allons donc régler ce paramètre sur quelque chose
comme 2000 unités de rayon. Ensuite, le rayon extérieur
est l'endroit où tout ce qui se trouve en dehors de cette zone ne
sera probablement pas affecté par le tremblement de la caméra, ou s'il est très
proche, il
se peut qu' il y ait un dernier type
d'oscillation Et je pense que nous allons fixer
ce
chiffre à 5 000, et encore une fois, environ 5 000, et encore une fois,
vous pouvez jouer
avec eux si cela se produit trop
ou trop fort, vous pouvez modifier le rayon
et le type de jeu avec cela. Comme je
l'ai dit, en ce qui concerne les explosions, lorsque les navires explosent, nous allons le
laisser tomber, et nous allons
rechercher le signe de
soulignement de BP Cam Shake Lidge, donc ce sera notre tremblement de caméra d'
explosion Nous pouvons appuyer sur compiler et enregistrer, et nous pouvons simplement tester celle-ci
parce que nous avons définitivement les fonctionnalités prêtes à fonctionner. C'est
donc un peu ce que je voulais dire lorsque certaines d'entre elles peuvent être
un peu trop intenses. Cela va donc
être facile à corriger. Je pense que la
radio devrait fonctionner correctement parce que la caméra
ne fait que vérifier. Si le joueur commence à 130 sur le Z et que la caméra mesure
2 400 unités sur le Z, cela signifie
que nous sommes de toute façon
légèrement en dehors du rayon intérieur de n'importe laquelle
des explosions Nous devrions donc
avoir un léger
tremblement de caméra. Ce que nous pouvons faire. Je pense que je suis
peut-être passé directement dans le multiplicateur un
peu trop haut. Mais comme je l'ai mentionné,
il s'agit en fait d'une approche très courante pour
ce genre de choses qui consiste à
doubler, réduire ou quadrupler ce que
vous pensez
être une
valeur raisonnable , puis à la redimensionner une fois que
vous l'avez testée Cela vous évite d'effectuer de très petites modifications incrémentielles qui peuvent souvent
prendre encore plus Cela me semble donc un
peu mieux, peut-être 1,5, afin que nous puissions
faire une dérogation plus importante, tout en gardant les mêmes
paramètres généraux ici Et je pense que c'est
bon. Je ne vais donc pas passer trop
de temps à le peaufiner. C'est désormais visible. Je peux voir et continuer
à jouer ça avec trop de perturbations, donc je
vais laisser les choses telles quelles. C'est donc notre gros tremblement de
caméra et encore une fois, vous pouvez l'affiner
et le modifier complètement pour
l'adapter à votre
projet comme vous le souhaitez. Passons donc à la
question de nos projectiles. Devons-nous le faire
trembler chaque fois qu' un projectile est tiré
ou chaque fois qu'un projectile touche quelque chose ou Ce serait essentiellement
une secousse constante, ce qui pourrait être
quelque peu nauséabond Je pense donc que dans ce
type de projet, une meilleure approche
serait d'en
faire quelque chose qui
avertisse le joueur
qu'il a été touché. Ainsi, nous apportons cette touche visuelle tout en
l'intégrant au gameplay Donc, l'une des
choses les plus ennuyeuses pour tout joueur jeux
impliquant un combat est d'être touché sans se rendre compte que
vous avez subi des dégâts ou de ne pas être capable
de les différencier des dégâts de bronzage de l'ennemi. Cela résout donc deux problèmes différents,
car pour le moment, nous recevons un tout petit
feedback si nous sommes touchés par des
pointes sur notre vaisseau Mais il n'est pas évident
que nous perdons des dégâts
ou des points de vie tant que
nous ne sommes pas détruits. Cela pourrait donc être
une bonne solution à cela. Cela indique que le
joueur subit des dégâts. Cela ne montre pas que l'
ennemi subit des dégâts, mais ils sont sur le point
d'exploser de toute façon Ce n'est donc pas aussi
important parce qu'ils n'ont pas autant
de santé à vivre. Et nous continuons de donner impression visuelle
que les particules ont impact sur l'avion ennemi Cela va donc
être assez clair. Une façon simple et agréable de le faire, alors,
c'
est dans cet esprit que
nous allons suivre notre cours
de projectiles Nous voulons faire
tout ce qui
concerne les projectiles dans la classe des projectiles Si vous n'êtes pas déjà
là, il se trouve que je suis juste à côté de
moi pour faire des commentaires, alors nous allons y retourner pour
faire des commentaires à nouveau. Et en fait, je
vais être un
peu paresseux, comme je l'ai
fait par le passé. Je vais suivre
le cours d'avion. Je vais récupérer
tout ce code,
pour localiser l'acteur
et trouver la caméra Playworld Appuyez sur la touche Ctrl en S pour le copier. Pendant que je suis ici, je peux également me
débarrasser de ce commentaire. Nous avons maintenant terminé
toutes nos tâches. Nous avons tous les
différents effets que nous allons implémenter,
donc je vais m'en débarrasser. Ensuite, nous retournerons à la base du projectile, placée dans le
monde du jeu, où
la caméra tremblera un
peu Et la logique est très similaire. Nous voulons donc refaire la
même chose. Nous voulons connaître l'endroit où
l' impact vient de se produire, et nous allons
jouer à partir de là, même rayon, car nous voulons
toujours que le même type
de caméra tombe. Mais tout ce que nous allons
faire, c'est peut-être vérifier, voir si le faible impact est suffisamment
important pour commencer, et nous souhaiterons peut-être
passer à moyen. Et c'est autre chose.
Si vous pensez que cela n'a pas suffisamment d'
impact, vous
pouvez essayer de le modifier. Ainsi, chaque coup produit
une secousse, mais peut-être que sur les navires ennemis, ce n'est qu'une petite
secousse, et sur le navire joueur,
c'est une secousse moyenne. Encore une fois, cela dépend entièrement de vous. Nous avons différents cours maintenant. Vous pouvez jouer avec
ça et voir ce qui fonctionne. Je pense que pour mon projet, je
vais le laisser juste pour indiquer que les
joueurs subissent des dégâts. Maintenant, il y a une chose pour laquelle nous avons juste besoin d'un
peu de place, et je voudrais encore une fois vous
montrer comment j'ai vu des gens
déchiffrer leur code accidentellement. Nous savons donc que nous
avons une condition ici. Nous voulons que cela se produise uniquement si nous touchons
le vaisseau du joueur. Donc, ce que vous pourriez faire, c'est
lancer une branche ici, alors nous allons
faire une vérification de la succursale. Et nous voulons vérifier. Nous savons déjà que nous
suivons ce que nous rencontrons,
afin de pouvoir prendre notre acteur
qui se chevauche Je ne pense pas que tout cela soit un nouveau concept pour vous. Nous allons donc le dupliquer,
donc je vais aller chercher mon acteur superposé, en m'
assurant de tenir celui-ci. Appuyez sur la touche
Ctrl, en effet, pour dupliquer. Et nous voulons vérifier si ce
que nous recouvrons n'est pas le propriétaire, nous avons déjà résolu ce problème Mais si c'est égal à, et nous l'avons déjà
vu, nous pouvons utiliser le get PlayerPawn Donc, si c'est égal
à ce qui est actuellement suivi
sous le nom de PlayerPawn, uniquement si c'est vrai,
voulons-nous jouer au
World Nous avons
donc juste légèrement augmenté les choses. Et vous avez probablement
remarqué que ce n'est pas exactement le plus gros
problème ou problème à résoudre. Certains d'entre vous l'
ont peut-être déjà vu, mais si ce n'est pas vrai, si c'est faux, si
c'est autre chose, alors nous bloquons
cet appel de fonction ici. Donc, n'oubliez pas
qu'il suffit de vous familiariser avec
l'ordre de fonctionnement, le contrôle du flux de votre code. En langage C plus plus écrit, c'est beaucoup plus facile car
nous utiliserons des instructions
FL que nous pouvons simplement supprimer de l'intérieur du corps de
la fonction. Il est donc beaucoup plus facile
de suivre cela. Dans Blueprints, il est très facile d' arrêter
accidentellement le reste des fonctionnalités lorsqu'
une seule
vérification de succursale a été effectuée Je voulais donc simplement
mentionner que
si vous suivez ce processus
où vous mettez simplement
à jour et améliorez votre
code de manière additive ou que vous ajoutez des fonctionnalités, il est très facile de ne pas nous
détruire accidentellement
chaque fois que l'ennemi est touché maintenant Donc, une chose que nous pourrions
faire à la place est, encore une fois, de résoudre tout cela
à l'aide d'une séquence. Donc, si je passe à autre chose, et c'est juste
pour essayer l'importance de
réfléchir à la propreté du code, non seulement pour perdre du temps et le
rendre
joli dans Blueprints, mais aussi parce que cela le
rend littéralement plus facile à lire et à
entretenir et pour éviter de commettre erreurs vraiment faciles
à commettre Donc, si nous ajoutons notre séquence
ici, et encore une fois, nous voulons
considérer cela comme
une gamme
de fonctionnalités spécifique,
qui dans notre cas, consiste à infliger des dégâts, et je serais peut-être tenté de faire tout ce qui n'
est pas
lié aux dégâts, tout ce qui est lié
au fait de jouer un effet. Nous allons
passer à celui d'alors. Donc, j'appuie simplement sur Ctrl X. Et
nous allons les connecter. Nous allons donc d'abord
infliger des dégâts. Ensuite, si des dégâts sont infligés, nous allons jouer
notre effet de particules, et nous allons faire
trembler la caméra, mais uniquement pour le joueur. Ensuite, nous allons
faire la dernière chose. Encore une fois, cela nous donne un
bon ordre de fonctionnement. Nous pouvons voir l'ordre exact dans lequel nos fonctions
vont être appelées. Et comme je l'ai déjà
mentionné, lorsque nous avons examiné les séquences, ce qui
rendrait les choses un peu plus claires, c'est si vous
donniez ces commentaires. Cela pourrait donc être la ligne des dégâts. Cela peut être la ligne des effets, et cela peut être la ligne claire ou
quelque chose comme ça. Et vous pourriez vous rappeler dans les commentaires. Encore une fois, il s'agit d'un changement très simple
et
rapide, et nous savons maintenant que, que cela soit lancé ou non, nous
allons certainement toujours détruire notre acteur, car
une fois que cela aura été vérifié ,
s'
il est appelé, il
reviendra à la partie suivante de
la séquence et reviendra. Si cela n'est pas appelé,
il va quand même
revenir à la partie suivante de la séquence, puis
redescendre. L'important est donc que cela soit
appelé malgré tout. Alors maintenant, nous pouvons entrer et
tester, et simplement vérifier. Cela n'arrive pas
aux ennemis. C'était donc l'explosion.
Donc, l'autre point est que si les projectiles s'
étaient heurtés, cela aurait pu faire trembler
la caméra lorsque projectiles
se sont également heurtés Alors maintenant, je
vais juste me
laisser tenter il ne se passe rien
d'autre. Nous y voilà. Vous pouvez donc en quelque sorte voir si je ne suis pas en train de mourir
en même temps. Vous pouvez voir qu'il est peut-être un peu trop
difficile de vous faire toucher, mais vous pouvez voir la caméra trembler, ce qui est important. Comme je l'ai dit,
c'est peut-être trop subtil. Si c'est le cas, c'est
parfaitement bien, car nous
avons notre shake moyen
que nous pouvons tester. Si nous
voulions vraiment qu'il soit clair, que ce sont les joueurs qui sont
touchés. Nous y voilà. Cela donne donc une indication bien
plus claire du fait d'être touché. Encore une fois, personnellement, je pense que le plus petit
convient parfaitement. Nous devrions peut-être y ajouter un peu plus de
force, gardant
la même fréquence ou quelque chose comme ça, mais juste pour savoir qu'ils ont
perdu la santé, je pense
que c'est assez clair. La prochaine étape consistera à examiner choses comme les matériaux et à fabriquer un matériau clignotant pour
la santé ou quelque chose comme ça si vous
voulez vraiment le visualiser Mais je pense que c'est
déjà un grand pas en avant, car
cela ne fait que rendre les choses un
peu plus visuelles et un
peu plus claires. Le truc, c'est que nous allons
rapidement ajouter un simple contrecoup lorsque les avions entrent en collision Pour celui-ci, nous voulons
gérer cela uniquement dans la classe des joueurs, car c'est la seule qui fait une sorte
de pseudophysique Je vais donc fermer
tous les autres onglets. Je pense que nous en avons fini avec
les tremblements de caméra, et nous allons passer au joueur d'avion BP
Underscore Et à l'intérieur d'ici,
ce que nous voulons faire, c'est
saisir cette sphère. Nous allons passer
à la
section sur les collisions dans le panneau des détails, et nous allons
lier la fonction « on component hit » ici, comme
nous l'avons fait par le passé. Et je vais faire en sorte que cela reste
très simple et agréable. Encore une fois, je pense que
c'est de toute façon
la même chose que l'exemple de projet, où nous pouvons rebondir sur
les ennemis et les murs Ainsi, chaque fois que nous touchons quelque chose, nous n'avons pas besoin de
vérifier de quoi il s'agit. Nous allons simplement prendre
notre vitesse de déplacement actuelle, et nous allons la
multiplier par une valeur négative avec
un petit supplément. Cela rend le jeu amusant et dynamique. Et surtout, encore une fois, il suffit de donner au joueur
le message que vous êtes en train toucher un autre objet dans le monde qui a
une certaine permanence. Nous allons donc obtenir la vitesse
actuelle, comme je l'ai mentionné. Nous allons le multiplier par une valeur négative plus un bit parce que nous ne
voulons pas simplement l'inverser Nous voulons ajouter un petit coup
de pouce. Disons donc -1,5. Et quoi qu'il en
soit, nous allons ensuite rétablir la
vitesse actuelle à cela. Cela est évidemment pris
en compte dans
le larping de toute façon L'interpolation par larping,
qui se produit avec
notre fonction de mouvement générale,
va donc qui se produit avec essayer de prendre notre nouvelle vitesse de déplacement,
puis de
la ramener
à la vitesse normale qu' elle
devrait atteindre et dans la
direction dans laquelle nous appuyons Donc ça ne va pas être
trop désagréable, je pense. une autre chose que
nous pourrions faire ici
, même si nous avons fait beaucoup de ces tremblements de caméra de
toute façon, en y réfléchissant Et encore une fois, complètement optionnel, mais juste quelque chose que
je vais essayer. Je vais aller dans
la base de projectiles. Je vais copier le code
ici, le tremblement de caméra mondial, coller ici, et
peut-être que nous utiliserons le tremblement
de caméra moyen,
donc nous allons le déposer vers le bas. Même rayon, même Apicenter, et nous pouvons simplement entrer
et appuyer sur Play Non, c'est sûrement
trop lourd, je pensais juste qu'il
pourrait trembler un peu quand
le rebond se produira Nous allons essayer de le faire avec les ennemis. Il s'y passe
trop de choses. Donc, encore une fois, essais et erreurs, cela a peut-être fonctionné.
J'avais peut-être l'air plutôt cool, mais ce n'est pas le cas. Peut-être que nous pouvons juste en
faire un petit shake. L'essentiel, c'est
de nous assurer que nous rebondissons également sur
les ennemis . Nous allons donc
simplement vérifier. Ça rebondit si joliment sur le mur. Rebondir sur l'ennemi.
Je pense que les ennemis subissent trop de
dégâts à cause de notre secousse. Ils devraient savoir que c'était un succès, n'est-ce pas
, donc c'est bon. C'est le joueur qui
meurt après deux coups. Donc oui,
ça va parfaitement. Et puis, si vous vous demandez pourquoi cela n'affecte
pas les projectiles nous pouvons toujours être touchés par des projectiles, mais
nous Nous ne faisons que
rebondir sur les murs
et les ennemis, ce qui a l'air plutôt cool, à mon
avis La raison en est que nous
revenons à notre configuration de collision. J'espère donc que cela aidera également
l'ensemble de la structure de collision à
prendre plus de sens. N'oubliez donc pas que notre sphère
sur le joueur est prête à toucher. Il ne fait donc que vérifier
les collisions physiques avec d'autres objets physiques. Il s'agit donc d'un
coup sur coup, d'un check ici, à l'intérieur de notre
joueur et de nos ennemis. Le projectile, bien qu'il
semble relativement similaire, peu pareil. Il
fait un type
de vérification différent, souvenez-vous Il est défini comme un collisionneur à
chevauchement. C'est pourquoi il est
utile de réfléchir à la manière dont vous allez configurer
vos différents collisionneurs Cela signifie que vous pouvez
complètement masquer différents types de configurations de collision afin de réagir et répondre à leurs différents
homologues de manière unique Cela signifie que
nous n'avons pas à nous
soucier des projectiles, car ils peuvent être soucier des projectiles, renversés ou
poussés physiquement sur
d' autres objets Ils volent
littéralement dans l'espace. Ils ne
font aucune physique. Ils n'entrent pas
en collision physique avec des objets. Ils vérifient juste s'il y a autre chose
dans le même espace. Et si un autre objet se
retrouve dans le même espace, il
essaie simplement d'infliger des dégâts, essayer de produire des effets,
puis de se détruire lui-même. C'est pourquoi nous pouvons nous
en tirer comme ça. Et encore une fois, bien sûr,
les limites de niveau sont définies lors de la
même collision, sorte qu'elles sont définies pour bloquer
les ennemis et le joueur Alors c'est tout. Le
projet est peaufiné. Je pense que c'est maintenant beaucoup plus intéressant
d'interagir avec cela. Il offre une
expérience un peu plus vivante et intéressante avec laquelle interagir. Encore une fois, cela dépendra en grande
partie du raffinement. Je ne m'attends pas
à ce que vous quittiez le projet, comme je vous ai indiqué
ces étapes jusqu'à présent. Si vous n'aimez pas du tout le tremblement de l'
appareil photo, ou si vous pensez
pouvoir le faire un
peu plus, c'est parfaitement bien. Ajoutez, supprimez, modifiez toutes ces propriétés
comme bon vous semble. Et c'est encore une fois
quelque chose vous pouvez tester et expérimenter entre les sujets
pour vraiment mettre la main sur
le projet. Et créez de nouvelles
classes de vibrations de caméra si vous pouvez trouver un cas d'utilisation pour
quelque chose qui secoue avec plus
ou moins de fréquence, mais avec plus d'
amplitude, par exemple L'essentiel est que
chaque impact soit
adapté aux commentaires que
le jeu essaie de mettre en valeur. Et c'est ce qui fera passer vos projets d'
un jeu de
type débutant très amateur à
un jeu qui nécessite un
peu plus de réflexion, soin et
d'attention sur tous
les différents éléments avec lesquels le joueur
interagira. Vous pouvez également
essayer
la vague plutôt que la perle
du bruit lorsque la caméra tremble et n'importe quel autre sujet que
j'ai mentionné, mais nous n'aurons pas le temps
d'approfondir toutes
les mises en garde concernant les différents processus Mais une fois cela fait, nous avons notre
truc à secouer, à renverser. Le poids et l'impact
du terrain deviennent maintenant
bien réels, il reste plus qu'à
créer une interface utilisateur capable de gérer
la boucle complète du jeu. Pour le moment, les joueurs
se retrouvent coincés dans un vide infini s'
ils sont détruits, et nous ne
voulons évidemment pas que ce soit le cas.
28. 27 - Interface utilisateur: OK, nous en sommes donc
au dernier sujet. Il s'agira
du jeu à l'écran, l'interface utilisateur, qui fournira un système de redémarrage
et une sortie correcte. Idéalement, nous aurions
quelques boutons sur lesquels appuyer. Mais nous allons garder
cette interface utilisateur simple et agréable. Tu finis. Vous pouvez appuyer sur le bouton I pour redémarrer, puis vous pouvez revenir
directement au jeu. Dans un projet plus vaste,
vous souhaiterez peut-être
ajouter un écran de menu ou
quelque chose comme ça. Mais avec cela, vous aurez un jeu
complet et jouable. La première chose que
nous voulons examiner est le concept des widgets. L'UnrelEngine gère donc les systèmes de
menus et l'interface utilisateur superpose les pressions
sur les boutons, etc., via
ce que l'
on appelle une Donc, à l'intérieur de notre structure de
dossiers, je vais créer
un nouveau dossier, que j'appellerai
widgets ou interface utilisateur. Vous verrez souvent cela
appelé l'un de ces deux lorsque vous parcourez les projets
d'autres personnes. Dans mon dossier Widgets, nous voulons cliquer avec le bouton droit de la souris ici. Nous allons passer
à l'interface utilisateur. Nous pouvons voir ici que nous
avons la possibilité d'utiliser un plan de widget Il existe donc toujours des classes de
blueprint, mais cela
nous permet simplement de créer une sorte d' interface
visuelle avec
du code lié à celle-ci Nous allons sélectionner cette
option ici et créer un widget utilisateur standard. Ensuite, nous allons appuyer sur Sélectionner,
et nous donnerons à
celui-ci le nom de WBP
pour que Widget Blueprint
souligne Game Over. Nous allons double-cliquer pour l'ouvrir, et vous verrez que la
mise en page est légèrement différente. La première chose à noter est de noter que
sur le côté droit, en haut à droite, nous
avons deux onglets différents. Nous avons l'onglet designer,
où nous en sommes actuellement. Cela fournit une mise en page
visuelle et un
système de canevas vraiment agréable pour
glisser-déposer différents éléments afin de
configurer la façon dont cela s'
affichera à l'écran. Nous avons ensuite le graphique, qui est notre éditeur de plans standard, très similaire à ce que vous avez vu auparavant, avec juste
quelques nuances en restant dans l'élément
designer, nous allons passer sur
le côté gauche, et nous voulons ce que l'
on appelle une superposition provenant de ces différentes catégories. Vous pouvez voir qu'il existe
de nombreuses catégories différentes. Je vais
donc simplement
rechercher une superposition Et il s'agit essentiellement
d'un panel dans lequel nous pouvons
placer toutes les autres choses
importantes. Nous allons donc le déposer, et vous pouvez voir ici que c'est notre
superposition à l'écran Nous voulons simplement nous assurer qu'il s'
agit d'un panneau 19 x 20. Nous pouvons donc faire glisser ceci,
et nous allons le mettre. J'ai juste besoin de me donner
un peu plus d'espace. Nous pouvons le laisser tomber et
nous pouvons le voir s' en cliquant
sur les limites ici, enclencher en cliquant
sur les limites ici,
et cela se mettra
en place Nous avons donc un panneau haut de
gamme 19 x 20 par défaut. À présent, ils seront
configurés pour être redimensionnés et modifiés en fonction de l'écran sur
lequel ils sont placés. Mais nous allons simplement utiliser la valeur par défaut, en supposant que
nous sommes sur un écran 19 x 20, et nous pouvons travailler sur cette prémisse. Ensuite, nous pouvons également
y ajouter un joli visuel. Nous pouvons donc rechercher
ce que l'on appelle un panneau de flou ou un flou d'arrière-plan, et
nous allons simplement le supprimer Nous pouvons voir que la
hiérarchie ici, la superposition, est l'endroit où tout sera en quelque sorte déposé, puis le flou d'arrière-plan
est un produit de la superposition Nous pouvons voir si nous zoomons, le flou
d'arrière-plan est
un tout petit peu faible Nous trouverons cela un
peu difficile à voir si nous devions appuyer sur
Play pour l'afficher. Donc, ce que nous voulons faire, c'est
sur le côté droit, nous pouvons l'aligner sur notre superposition Donc, si nous lui disons d'
occuper, de remplir tout l'espace horizontalement
et de remplir tout l'espace verticalement, vous pouvez
voir qu'il
correspond désormais à la taille
du composant parent,
à savoir la superposition Pour ce qui est de l'intensité du flou,
je vais simplement
saisir cette valeur ici
dans le panneau des détails, et nous allons lui attribuer une intensité de
flou de 15, et nous pouvons voir que cela a ajouté
un léger flou à notre panneau,
qui, à mon avis, sera plutôt beau, peu moderne et lui donnera juste un peu d'éclat visuel Ensuite, nous voulons
voir comment nous pourrions formater le texte que nous voulons afficher
à l'écran. Nous allons donc vous montrer
quelque chose comme ça, juste un petit texte
disant que le jeu est terminé, puis une infobulle sur
la façon de redémarrer. Un moyen simple et agréable de gérer
plusieurs éléments dans une seule zone d'un menu
serait d'utiliser quelque chose comme un
achat horizontal si vous voulez que les éléments s' étendent horizontalement sur votre
widget ou une boîte verticale. Dans ce cas, nous
allons passer à la verticale. Donc, si nous recherchons
une case verticale, nous pouvons la déposer et nous assurer
qu'il s'agit d'un élément de la superposition et
non d'un flou d'arrière-plan Pour l'alignement
de celui-ci, vous pouvez voir qu'il
occupe toute la boîte. Au lieu de cela, nous allons le
définir sur la ligne centrale pour les paramètres horizontaux et
verticaux juste ici. C'est parfaitement
bien. Nous pourrons adapter cette échelle aux éléments qui se trouvent à l'intérieur un peu plus tard. Comme je l'ai mentionné,
les éléments seront très,
très simples pour cela. Nous allons simplement lui donner
un élément de texte, nous allons
donc
rechercher un texte, et nous allons déposer notre premier
élément de texte dans la zone verticale. Et vous pouvez voir que c'est
vraiment sorti de la boîte verticale pour y placer
l'élément
ici Pour le
texte initial, je vais le définir comme GameOver Donc, avec le texte sélectionné, nous voulons trouver notre option de
texte ici. Vous pouvez voir qu'il est actuellement
écrit « bloc de texte », et je vais juste
le remplacer par « game over ». Changez la taille de la police. Donc, pour le moment, si nous
déroulons nos
propriétés de police juste ici, la taille est 24,
et je pense qu'une taille d'environ 50
serait idéale pour celle-ci. Nous pouvons changer la police de caractères. Roboto Bold a souvent l'air
un peu désagréable. Nous pouvons simplement le changer en mode normal ou même la lumière peut être très
jolie. Ça a juste l'air un peu plus propre. Cela ne semble
pas vraiment avoir d'impact aujourd'hui. Peut-être voulons-nous changer
la taille de la
police à environ 60 pour améliorer l'apparence et le son. Maintenant que ce texte est
sélectionné, nous pouvons appuyer sur. Nous allons donc le récupérer
ici sur
le côté gauche ou
dupliquer notre texte. Il faut donc contrôler, en effet,
dupliquer. Et vous pouvez voir
que parce qu'il trouve à l'intérieur de cette boîte verticale, il s'assure maintenant qu'
il est aligné verticalement. Et si nous continuons à ajouter des éléments de
texte, nous aurons ce bel alignement
dans un ordre vertical. Cela facilite donc un peu gestion et le travail avec plusieurs éléments lorsque
vous souhaitez qu'ils soient à peu près alignés les uns avec les
autres au même endroit. Maintenant, pour celui-ci, je vais simplement récupérer le nouvel élément de texte, ou modifier le texte pour
dire appuyer sur R pour redémarrer. n'est probablement pas le jeu le
plus
intéressant à l'écran, mais il
fait passer le message. Nous allons en modifier légèrement la
taille. Il n'est pas nécessaire que cela ait un
impact une fois le jeu terminé. Nous allons donc lui donner
une taille de police de 30. Nous pourrions également leur donner
un peu de rembourrage. Donc, si je prends le GameOver, tout d'
abord, dans le panneau de
détails sur la droite, nous pouvons lui donner un
titre par défaut, disons dix, pour qu'il soit un peu
contourné Et nous pouvons faire la même chose
en appuyant sur R pour redémarrer. Nous allons également y donner
un petit coup de pouce. Et le principal est que nous voulons que
cela soit centré. Nous pouvons donc saisir l'alignement
horizontal et nous assurer que les deux
sont alignés au centre. Ils sont donc en quelque sorte placés au milieu de leur boîte
verticale, bien rangés, et nous n'avons pas eu besoin de faire beaucoup de travail Une autre chose que vous
voudrez peut-être faire est
de modifier légèrement les couleurs visuelles. Nous pourrions donc reprendre le jeu. oververs de jeu sont
normalement représentés par un rouge, un orange ou
quelque chose comme ça Nous pourrions
donc changer
la couleur ici pour qu'elle soit un peu plus
négative, en la faisant ressortir de
la saisie ici Cela semble un
peu plus intéressant parce que nous avons
d'autres choses en cours. Quelques étapes plus précises que vous voudrez
peut-être y apporter, vous pouvez ajouter vos
propres polices très facilement à démouler,
puis vous pouvez simplement modifier la police
que vous souhaitez utiliser pour la rendre un
peu plus personnalisée Jouez avec des éléments tels que
l'audace, la taille de police. Vous pouvez même ajouter des
éléments tels que des contours si vous souhaitez
mettre en valeur certaines parties. Donc, si je
zoome un peu. Je pourrais ajouter un
contour de deux pixels et nous obtiendrons un aperçu éléments
de notre menu juste ici. Donc, peu importe ce que vous vouliez
faire pour essayer rendre les choses un peu plus
intéressantes, comme je l'ai dit, nous allons
rester
simples et simples, juste pour montrer
que le jeu est terminé et pour indiquer au joueur ce
qu'il peut faire ensuite. Nous allons donc
revenir très
brièvement sur le système de saisie car nous avons maintenant besoin de
quelque chose de dynamique lorsque cette interface utilisateur
est affichée à l'écran. Donc, si nous retournons dans
notre système de saisie, récapitulons
simplement ce que nous avons Nous avons déjà notre clé de redémarrage. Maintenant, comme je l'ai mentionné, dans un jeu
complet où vous avez un
système de menu
plus complexe et des choses comme ça. Vous pouvez avoir différentes classes de contexte de
mappage d'entrée. Dans ce cas, nous avons simplement
tout lié à un seul gameplay, et je pense que c'est plutôt
bien parce que nous n'avons
pas d' utilisations qui se chevauchent Si vous vouliez
utiliser, par exemple, le bouton de retour d'une manette de jeu, donc B sur la manette de jeu, pour une entrée comme un saut, mais que vous vouliez aussi que ce
soit le bouton de redémarrage, c'est là
que vous
voudrez peut-être partager cela. Donc, si vous étiez dans un menu, alors B serait mappé au redémarrage Vous auriez donc le contexte de mappage de votre
menu. Et puis, lorsque vous êtes dans le
gameplay et qu'il s'agit de sauter, vous avez le contexte de votre cartographie du
jeu. Dans ce cas, je pense que le simple fait utiliser celui-ci
serait parfaitement acceptable. Nous allons donc
revenir à notre GameOver, et nous voulons simplement créer la
liaison que nous avons
faite précédemment C'est donc là qu'intervient le
côté code de notre menu, et c'est là que la flexibilité
vraiment intéressante
du système de saisie amélioré rend les choses beaucoup
plus faciles qu'auparavant. C'était certainement possible
avec l'ancien système, mais il s'agit
certainement d'un pas en avant. Nous allons accéder
au graphique ci-dessous, assez similaire
à ce que nous avons vu auparavant. Nous avons donc une
coche d'événement, et dans ce cas, nous ne ferons
rien de coché dans notre menu, nous pouvons donc nous en
débarrasser. La structure de l'événement
est donc essentiellement la même
que celle du début du jeu. Cela se produira
dès que le jeu commencera et que le menu sera
créé. Ainsi, lorsque nous affichons le
menu à l'écran, ce sera cinq fois. Avant la construction, vous devez être
un peu prudent. Cela est utile pour les modifications apportées à
l'éditeur. Nous pourrions donc coder des
éléments afin pouvoir mettre à jour l'éditeur en direct, mais vous devez faire attention
, car si vous faites référence à d'autres classes ou faites des choses en dehors
du menu, cela peut poser problème si
vous n'êtes pas encore en mode jeu Donc, pour éviter toute confusion, nous allons nous
débarrasser de celui-ci, et nous allons simplement le considérer
comme notre mode de jeu dès le début, ce que nous voulons faire ou
selon la structure de l'événement c'est accéder à nouveau à la manette du
joueur, et nous voulons faire exactement
ce que nous avons fait précédemment. Nous voulons trouver le sous-système de lecteur local
d'entrée amélioré sous-système de lecteur local
d'entrée Celui-ci ici avec l'icône de fonction
violet-rose juste Et encore une fois, comme
nous l'avons fait auparavant, nous allons ajouter
le contexte de mappage. Plusieurs classes peuvent donc avoir
le même contexte de mappage Nous allons
donc
maintenant avoir
le contexte de mappage dans notre classe de joueur, qui gère les entrées
pour se déplacer et tirer. Nous pouvons ajouter le même
contexte de mappage à notre menu. Ainsi, lorsque cela sera généré, il suivra également les pressions sur les boutons
concernés Maintenant, dans ce cas, c'est bon car la pression sur
le bouton correspondant ne servira qu'à redémarrer IA
Underscore Nous pouvons donc cliquer avec le bouton droit
de la souris ici. Nous rechercherons IA Underscore restart Nous voulons que l'événement se reproduise.
Ainsi, lorsque quelque chose se produit, nous obtenons le fichier
PIN d'exécution indiquant le moment où vous appuyez sur cette touche. Nous voulons simplement recharger le niveau dans lequel nous sommes actuellement
et nous ne faisons que
redémarrer le jeu Nous n'avons qu'un seul niveau, donc
c'est simple et agréable. Il existe une fonction que
nous pouvons utiliser pour ce faire, une fonctionnalité intégrée dans Unreal Nous pouvons utiliser le nom du niveau get
current. Donc, cette fonction est juste là,
connectez-la pour démarrer. Encore une fois, lorsque vous appuyez une fois sur
cette touche, cela renvoie le nom
du niveau dans lequel
nous nous trouvons actuellement,
qui, rappelons-le, s'appelle
simplement principal. Nous pourrions donc le faire en
codant en dur et simplement taper le niveau principal du niveau
que nous sommes sur le point de recharger Mais juste au cas où vous
commenceriez à ajouter d'autres niveaux ou à changer
le nom, il s'agit, encore une fois, d'une manière agréable, dynamique et réutilisable
de l'implémenter. Donc, une fois que
nous l'aurons, nous allons tirer à partir de là, et nous allons
rechercher le niveau de charge de la fonction, et nous allons
rechercher la fonction ouverte. Vous pouvez voir l'option ici,
ouvrir le niveau par nom. Nous obtenons maintenant deux variables légèrement
différentes nom du niveau actuel est
donc renvoyé sous forme de chaîne, et le niveau
à charger renvoyé devrait être introduit
sous forme de variable de nom. Parfaitement bien. Encore une fois, nous
pouvons simplement les brancher. Ce sont tous deux un type
de texte, essentiellement, et c'est irréel
qui fera cette conversion pour nous Cela prendra donc le nom actuel du
niveau dans lequel nous sommes principaux, et cela ouvrira le
niveau du même nom. Nous sommes donc en train de
redémarrer notre droite.
L'autre problème dont je
viens de me rendre compte, L'autre problème dont je
viens de me rendre compte c'est que nous n'avons aucun
moyen de quitter le jeu Ce que j'essaie
vraiment de faire c'est de ne pas donner impression d'être un
jeu complet pour débutants à la fin de ce processus. Lorsque je teste et fais des démonstrations de jeux créés par de
nouveaux développeurs, je constate que vous êtes souvent bloqué
dans leur jeu et que vous
devez appuyer sur la touche F pour
fermer le panneau Donc, pendant que nous
examinons l'entrée, nous pouvons aussi bien nous
débarrasser de ce problème. Ce
que je
vais faire, c'est dupliquer le redémarrage du
soulignement IA Je vais renommer
celui-ci pour arrêter. À l'intérieur du trait de
soulignement principal IMC, nous voulons simplement
ajouter un nouveau Nous savons donc que le redémarrage est
un booléen, une entrée binaire. Nous avons donc déjà défini le terme
comme booléen numérique, ce qui est parfait Donc, dans IMC Underscore main, nous allons ajouter
un nouveau Nous allons le faire défiler vers le bas et
sélectionner le bouton Quitter. Donc, pour les tests dans l'éditeur, c'est un peu
compliqué car par défaut, escape est de toute façon mappé pour
terminer la lecture Donc, si nous jouons et
testons, nous ne serions pas en mesure de le faire. Sans désactiver notre
système de menu ou notre bouton rapide. Je vais donc vous donner ceci. Mais si nous devions l'emballer et le donner
à quelqu'un d'autre. Je veux simplement utiliser la touche
d'échappement pour fermer le projet. Il n'y aura pas de menus,
il n' y aura pas de fenêtres contextuelles, juste un moyen rapide de
fermer le projet, qu'au moins je ne sois pas bloqué une fois
le projet créé. Pour les tests sur les éditeurs, je
me donne assez souvent une autre reliure, et je la règle sur
quelque chose de vraiment aléatoire sur lequel je n'aurais pas eu à
appuyer autrement dans mon gameplay. Je pourrais donc
définir cela comme la touche de suppression. Cela signifie
que je peux retourner dans ma classe de joueur. Je vais donc entrer dans
le vif du sujet : le joueur d'avion. Et encore une fois,
nous nous éloignons
un peu des moyens idéaux
de configurer cela maintenant. Dans un vrai projet, vous le
feriez probablement à l'aide d'une manette de joueur
ou d'un autre système de menu, mais nous n'allons pas trop loin pour créer des systèmes de menus complets. Nous allons donc simplement le déposer dans notre système de saisie ici. Nous avons donc notre
graphique d'entrée. Au moins, nous
veillons toujours à ce que
les choses soient bien rangées Cela fait toujours partie de
notre soulignement principal IMC. Cela signifie donc que toutes nos nouvelles liaisons sont
toujours en cours de suivi Et ce que nous pouvons faire, c'est que nous pouvons arrêter
le trait de soulignement de l'IA. Et lorsque ce bouton est enfoncé, nous voulons que l'événement se reproduise. Et lorsque ce bouton est enfoncé, alors que vous démarrez, nous voulons simplement appeler la
fonction intégrée, qui est quittée. Jeu tellement rapide. Et
cela fermera
automatiquement l'
instance du jeu pour vous. Donc, si nous appuyons sur compiler et enregistrer, nous pouvons le tester immédiatement. N'oubliez pas qu'en mode jeu, si j' appuie sur Escape, il
se serait fermé de toute façon. Je vais donc appuyer sur
la touche Supprimer, et la lecture vient de se terminer. Cela fonctionnera donc pour
notre version packagée, ainsi que pour notre version d'
éditeur ici. Nous n'avons donc
rien d'autre à faire ici. Et je voulais juste
vous présenter la fonctionnalité rapide, car comme je l'ai mentionné, elle est vraiment facile à oublier, mais elle est super, super
simple à mettre en œuvre. Et ce n'est qu'une de
ces choses qui prend compte
vos sentiments initiaux
et la notation d'un jeu auquel vous jouez
ne fait
que franchir un pas et
vous donne l'impression jouer à un jeu créé par quelqu'un un peu
plus d'expérience Enfin, nous voulons que
cette interface utilisateur apparaisse lorsque le joueur meurt. Nous savons exactement quand cela
se produit, car notre fonction handle death est
intégrée à la classe des joueurs. Donc, avec ça, nous
allons trouver notre fonction de gestion de la mort. Nous voulons passer à l'override, et nous voulons que Dyna
soit traitée Nous voulons nous assurer
que nous continuons à appeler toutes ces informations importantes pour les
parents,
afin que notre effet et tout ce
qui s'y rapporte soient gérés. Mais juste avant que
cela n'arrive, ou peut-être oui, juste avant que
cela n'arrive parce que nous appelons Destroy dans
la version parent, nous voulons apparaître dans
notre interface utilisateur Et nous pouvons le faire
très simplement, alors nous allons
partir d'ici et nous trouverons une fonction appelée Create Widget. Il s'agit donc d'une fonction permettant de créer l'un de nos widgets de plan Nous pouvons le brancher
ici, et nous voulons
trouver notre jeu de soulignement WBP Encore une fois, je vais
faire une petite remarque simplement parce que vous
seriez surpris de voir
combien de personnes oublient la prochaine étape importante. J'ai l'
impression que cela devrait fonctionner. Mais si j'entre rapidement et autorise la destruction de mon avion, nous appelons cette fonction, nous lui avons donné un
certain widget, mais nous ne le voyons
pas à l'écran. Encore une fois, chose très courante. Même si nous avons l'
impression que c'est tout ce que
nous devons faire. Il y a en fait une étape supplémentaire. Nous voulons tirer parti de
cette épingle de retour. Cela est donc créé
en arrière-plan. Il y a un widget Game Over persiste
en
quelque sorte dans la mémoire Nous voulons prendre cette
référence et cette mémoire et nous voulons dire
ajouter au point de vue. Une fonction spéciale appelée
Need to Make est ici, et ensuite nous allons
simplement les connecter. Et maintenant, cela va
réellement fonctionner. Donc, si nous entrons et
appuyons à nouveau sur Play, il
suffit de
détruire mes avions, et c'est parti. Cela a donc créé ce menu, mais il l'a également ajouté
au point de vue. Si j'appuie sur R, nous avons
cette liaison dans le menu, donc nous pouvons également
redémarrer. Nous pouvons donc entrer et
redémarrer le jeu très, très facilement maintenant. Nous allons nous retrouver
avec la même chose. Et si j'appuie sur Supprimer,
quelque chose que j'ai oublié. J'allais dire que si j'
appuie sur Supprimer, je peux arrêter. Je ne peux pas parce que les
joueurs ont été détruits. Et n'oubliez pas que notre obligation
d'arrêter de fumer est dans le joueur. se peut donc que nous voulions faire un peu de duplication. Nous allons utiliser
notre IA Underscore Quit et la fonction Quit
Game ici Nous n'allons pas
le supprimer ici. Nous le voulons aux deux endroits.
Nous allons revenir au jeu, il suffit
de le coller ici. Ainsi, lorsque le joueur
a été détruit, ils n'existent plus. Nous ne pouvons évidemment pas
quitter le jeu. Nous allons donc déplacer
cette fonctionnalité vers widget
GameOver à la place C'est donc parfaitement bien à faire. Assurez-vous simplement que
le joueur meurt toujours. Et maintenant, si j'appuie sur
Supprimer, nous pouvons fermer le jeu. Donc, même fonctionnalité,
nous devons toujours
tenir compte du fait que si quelque chose est
complètement
supprimé du jeu, complètement supprimé de la mémoire, nous devons nous assurer que toutes les
fonctions
pertinentes sont toujours
disponibles ailleurs. Et encore une fois, si vous trouvez, comme lorsque je regardais cela, j'ai l'impression qu'il y avait
beaucoup d'espace sur
l'écran. Je pense donc que ce que je pourrais faire, c'est juste quelques petites modifications pour faire en sorte
que ce soit vraiment le
double de la taille de notre jeu Et puis doublez la taille
de notre embout ici. Ce n'est donc pas grave, mais encore une fois,
il s'agit simplement de faire le plein d'informations générales et de
faire en
sorte que tout soit
aussi beau que possible, en
essayant de présenter le
jeu de la meilleure façon possible. Donc oui, il y a probablement un bien meilleur style
général là-dedans. Appuyez pour redémarrer, tout fonctionne. C'est tellement parfait. Je pense que pour un projet débutant, une sorte de remake très simple
de quelque chose qui existe, mais essayer de l'
étendre et de l'améliorer, en particulier la
base de code lorsque cela est possible, mais aussi les commentaires généraux remplissage
et les visuels
seront, espérons-le un bon
point d'apprentissage et un pas dans la bonne direction pour
vos futurs Mais c'est à
peu près la fin. Donc, encore quelques points à retenir dans
ces points d'apprentissage. Vous pouvez jouer, tirer sur
des ennemis, être touché, mourir, partie
s'affiche à
l'écran et vous pouvez tout recommencer.
Tout semble très beau. Nous avons une sorte
d'interface
utilisateur semi-floue, moderne et simple. Vous pouvez appuyer sur Escape ou Supprimer et fermer le
jeu où que vous soyez. Encore une fois, nous ne voulons pas
donner l'impression que c' est un projet complet pour débutants dans lequel
vous êtes bloqué et où vous devez modifier F quatre d'un projet de fin de
semaine de quelqu'un J'espère donc que c'est
une belle amélioration ce que vous
auriez pu voir également. Nous avons donc une boucle de jeu
complète. Nous pouvons jouer, mourir,
redémarrer et arrêter. Pendant
tout ce temps,
nous sommes passés d' un
projet vide à un jeu complet, avec des
mouvements
indépendants de l'écriture des images, des projectiles, des matériaux
dynamiques, des
ennemis hérités et un bref aperçu Nous avons des générateurs aléatoires
, ce qui garantit qu'ils ont été
créés de manière générique,
mais génériques de manière à ce que nous puissions
créer
la classe une seule fois et l'utiliser
pour ai examiné les particules, le son, le tremblement de la
caméra, le
retour en arrière et maintenant l'interface utilisateur C'est donc, espérons-le,
une bonne base. Vous pouvez vous appuyer sur cela. Comme je l'ai mentionné,
ce
serait formidable d'ajouter des ennemis uniques, d'
essayer de leur donner des schémas de
mouvement différents, des modèles d'armes
différents, peut-être de les accélérer et de simplement faire des ennemis kamikazes
avec des projectiles connus Tout ce que vous ressentez
pour les étapes supplémentaires que vous avez prises pour rendre ce projet unique. Apportez de nouveaux actifs et partagez vos progrès et vos
mises à jour avec d'autres personnes. Cela pourrait également ajouter des éléments
tels que le score, ce qui serait très facile à faire grâce à la fonction de mort avec
poignée partagée. Nous savons exactement quand
les ennemis meurent Vous pouvez
donc vous appuyer
sur cela et créer une sorte de système de notation. Alors, personnalisez vraiment ce
projet. Prenez des références
provenant d'autres jeux, regardez les exemples de contenu, et je
recommande vivement à
ce stade de regarder
les exemples de contenu. Jetez un œil à la carte
d'entrée du plan et voyez exactement d'où ce projet a été inspiré
et comparez le code que vous avez avec
le code de ce projet Encore une fois, il ne
s'agit pas de porter un jugement, mais simplement de voir
qu'il existe toujours différentes manières d'
aborder un même problème. Et voyez ce que vous
pensez de ce que nous
avons par rapport au projet
original. Mais l'important, c'
est que vous venez créer un jeu, et
ce n'est pas rien. C'est un exploit, autant plus si vous avez
pris ces mesures supplémentaires et que
vous avez vraiment l'impression de commencer à comprendre au moins un peu ce que vous pouvez faire
dans Unreal Certaines de ces étapes nécessiteront un
peu de répétition. Vous devrez peut-être revenir en arrière
et réessayer, mais être capable de modifier et implémenter vous-même ces
fonctionnalités est vraiment le principal obstacle d'
apprentissage lequel beaucoup de
gens se heurtent, je pense. Merci donc de m'avoir
suivi sérieusement. Si vous êtes arrivés jusqu'ici,
j'apprécie vraiment que vous ayez consacré votre temps à
quelque chose que j'ai contribué à créer Mais je continue à fabriquer des choses. C'est là tout
le problème.