Transkripte
1. 00 Intro: Das ist es, was du bauen
wirst sie komplett in
der Unreal Engine zu erschießen . Fünf
komplett Ich bin Rob, und mit
diesen 27 Themen führt euch
diese Serie
von einer leeren Codebasis
zu einem fertigen, spielbaren Wir werden unsere eigene,
vollständig angepasste Spielerbewegung
erstellen , unabhängig von der Framerate, das verbesserte
Eingabesystem
verwenden und Dinge wie
Kollisionserkennung ausführlich
behandeln Wir werden die Bauernklassen für die
Gegner
und die Spielerflugzeuge mit
einem Fokus auf Vererbung implementieren ,
also eine Basisklasse, die jeden Schiffstyp
antreibt, und ein Projektilsystem
hinzufügen, das für beide Seiten funktioniert,
eine einzige Klasse, eine einzige Klasse, Sogar die Spawnklassen, die
wir erstellen, sind mit
einer Architektur ausgestattet, die mit einer Architektur ausgestattet, die Feinden und Hintergründen
umgehen kann,
und ihr könnt sie erweitern, wie ihr
wollt. Wir werden auch einen
kleinen Blick auf Dinge wie Design werfen und das Spiel mit
Partikeleffekten,
Audio, Kameraverwacklungen und sogar Rückschlägen
aufpeppen und sogar Rückschlägen Wir werden einen
kompletten Game-Loop hinzufügen, sodass ihr am Ende ein spielbares
Spiel habt,
einschließlich eurer einschließlich Du kannst spielen, sterben,
neu starten oder beenden. Der Fokus wird
darauf liegen, die Dinge richtig zu machen. Wir werden uns mit einer sauberen Architektur und
wiederverwendbaren Systemen befassen
und herausfinden, warum etwas funktioniert oder nicht,
anstatt nur die Notizen zu kopieren. Jede Entscheidung wird erklärt. Ich werde bewusst
integrierte Funktionen
in Unreal überspringen und dir dann erklären, warum
wir diese Wahl treffen Wenn etwas nicht intuitiv ist, nenne
ich es und alle Ressourcen, die
Sie benötigen, um zu diesen
Endergebnissen zu gelangen, werden bereitgestellt, sodass Sie sich einfach
auf die Programmierung und die Erstellung einer guten Projektstruktur konzentrieren können auf die Programmierung und die Erstellung guten alle Ressourcen, die
Sie benötigen, um zu diesen
Endergebnissen zu gelangen, werden bereitgestellt,
sodass Sie sich einfach
auf die Programmierung und die Erstellung einer guten Projektstruktur konzentrieren können.
Ich habe
die Kunst für Sie erledigt Ihr Klassenprojekt
wird
dieses fertige Spiel sein , das
komplett ausgefeilt und fertig
ist, um es
zu einem Portfoliostück zu erweitern, zusammen mit allen neuen Funktionen
, die Sie hinzufügen möchten Es könnte neue
Feinde, Waffen, ein Punktesystem geben,
was auch immer du willst Die Architektur
wird so gestaltet , dass Sie sie
aufbauen und erweitern können. Zum Beispiel habe ich
das Projekt
über einen Zeitraum von
ein paar Monaten
ungefähr so aussehen lassen über einen Zeitraum von
ein paar Monaten
ungefähr so und einem erweiterten Projekt eine Reihe
neuer Funktionen und Ressourcen
hinzugefügt . Das erste Video
wird sich mit
der Einrichtung des Projekts befassen. Ich
freue mich darauf, Sie dort zu sehen.
2. 01 - Einrichtung: meisten unwirklichen Projekte unmöglich, die meisten unwirklichen Projekte
innerhalb eines Monats zu bewältigen Vermögenswerte werden
überall verstreut sein , es gibt keine
Namenskonventionen, und am Ende verbringen Sie die meiste Zeit damit,
zu suchen,
anstatt etwas zu bauen Ich habe diese Serie mit der Absicht erstellt ,
das von Anfang
an zu korrigieren. Ich helfe Ihnen dabei, ein komplettes
Shooting von Grund auf zu
erstellen , bei dem
sich jedes Thema darauf
konzentriert , die Dinge richtig zu erledigen. Das ist eine gute Struktur,
eine gute Benennung, eine gute Architektur,
Fähigkeiten, die sich jedes Projekt
übertragen lassen
, an dem Sie arbeiten. Wir werden daran arbeiten, das Spiel, das ihr hier im
Hintergrund sehen
könnt,
auf offiziellen Inhalten
aufzubauen , die von Epic in ihrem Paket mit
Inhaltsbeispielen erstellt wurden . Wenn das etwas ist,
das dein Interesse weckt, dann lass uns
loslegen und diese Stiftung gründen Zunächst würde ich empfehlen
, dass Sie
zum Download-Link
in der Beschreibung navigieren zum Download-Link
in der Beschreibung Sie werden hier zwei
Optionen sehen. Wir haben sie
hochgeschossen und ihre Vermögenswerte unterstrichen Dies enthält die Regel
Meshes und Texturen für den Fall dass
Sie etwas
in Blender oder Photoshop ändern möchten Dann haben Sie das
Tutorial „Shoot
them up“, „Underscore und das ist das
komplette Projekt Und dies wird das sein
, dem Sie
zusammen mit den Themen, die wir durchgehen
, folgen möchten . Standardmäßig
wird dieser Ordner
als komprimierter Ordner für Sie bereitgestellt als komprimierter Ordner für Sie Sie müssen also sicherstellen, dass Sie es an einem sinnvollen Ort
extrahieren, und wenn Sie mit demselben Projekt beginnen bedeutet das
einfach,
dass wir
mit identischen Einstellungen ,
denselben Ressourcen, im gleichen Umfang usw. arbeiten,
was die
Fehlerbehebung
etwas einfacher macht, falls
Sie auf was die
Fehlerbehebung
etwas einfacher macht Probleme stoßen Als Erstes müssen Sie sich das
Innere des entpackten Ordners ansehen , indem
Sie in den Tutorial-Ordner Shoot them up
underscore gehen Standardmäßig befindet sich das Projekt
in Unreal Engine 4.27, maximale Kompatibilität zu gewährleisten, falls Sie mit einer etwas
älteren Engine-Version arbeiten Wenn Sie
, wie ich,
dies aktualisieren werden, damit es mit der
Unreal Engine Five funktioniert Das Upgrade dauert
ungefähr 10 Sekunden. Unter Windows können Sie einfach hier mit der rechten Maustaste auf dieses Dot
U-Projekt klicken
und haben die
Möglichkeit, die Unreal Engine-Version
wechseln auszuwählen Unreal Engine-Version
wechseln Wählen Sie aus der Drop-down-Liste
die installierte Version ,
mit der Sie arbeiten möchten, und klicken Sie dann auf Okay Sie sind bereit zu gehen. Ich arbeite
gerade an Linux, daher zeige ich Ihnen einen
alternativen Ansatz. Das ist auf jeden Fall nützlich. Das wird unter Windows funktionieren,
und es ist wirklich nützlich, darüber
Bescheid zu wissen, da es
Ihnen helfen kann , Projekte zu reparieren, die sich sonst
aufgrund fehlender
Plugins oder Plugin-Probleme nicht öffnen
würden . Um das zu tun, klicke ich einfach mit der rechten Maustaste auf das
Dot U-Projekt. Ich öffne W und Sie können einen beliebigen Texteditor auswählen. Das könnte Notepad VS-Code sein. Ich werde mit Zed arbeiten, und wir können hier auf
der linken Seite sehen, wenn wir uns die
Engine-Assoziation ansehen, sagt uns
das, dass
das mit
4.27 gemacht wurde . Wir können das einfach ändern Ich werde mit 5.6
arbeiten, das wahrscheinlich
veraltet ist, wenn Sie sich
das ansehen,
aber es wird nah genug sein. Wenn das erledigt ist, können
wir das, wie
mit jedem Texteditor, einfach speichern. Wir können das Fenster schließen
und schon kann es losgehen. Um das Projekt zu starten, doppelklicken wir einfach auf
das Projekt mit dem Punkt U, und es wird im Hintergrund
geladen Atic unter Linux
, wenn Sie
standardmäßig auf ein U-Projekt
doppelklicken , wird die Unrel-Engine nicht wirklich
gestartet Wenn du
diese Art
von Integration zusammen mit meinem benutzerdefinierten
UnrelEngine-Installer haben
möchtest, mit meinem benutzerdefinierten
UnrelEngine-Installer haben
möchtest, wird
das zum Beispiel alle lokal heruntergeladenen oder
installierten Versionen von Unreal finden , sie hier zu einem
automatischen Launcher
hinzufügen, und wir können einfach Impress Okay aufrufen
, und wir können den
ziemlich normalen Launcher laden , den du normalerweise
mit der Unreal-Engine bekommst. Es ist nicht wirklich das
Hauptthema dessen, was wir durchmachen werden, also werde ich einen
zusätzlichen Link dazu bereitstellen. Sie können das in
der folgenden Beschreibung überprüfen. Ich werde die Skripte
völlig kostenlos zur Verfügung stellen, sodass Sie
die Skripte auch herunterladen können. Und das wird einfach
tiefer gehen als das, was ich tun
musste, um
Linux zum Laufen zu bringen,
bereit zu machen und ziemlich
reibungslos mit
der UnRel-Engine zu arbeiten reibungslos mit
der UnRel-Engine Jetzt, wo wir uns in Unreal befinden, sieht
Ihre Oberfläche möglicherweise
etwas anders aus als meine, je nachdem, mit welcher Version
Sie sich entschieden haben. Epic neigt dazu, die Dinge
ungefähr jedes Mal neu zu organisieren , wenn
sich jemand ein bisschen langweilt Aber wir können uns einfach
auf die Konzepte konzentrieren, nicht auf die genauen Schaltflächen
und die Standorte Sie werden definitiv existieren, und Sie werden schnell genug
einsatzbereit sein. Das erste, was Sie
auschecken sollten, ist
der Inhaltsbrowser oder
die Inhaltsschublade, die sich unten
links befindet. Hier befindet sich alles
in Ihrem Projekt. Wir können darauf klicken und wir können unsere Projektstruktur
sehen. Innerhalb des Inhaltsordners
gibt es einen Unterordner, der dem Projektnamen
entspricht,
also das Shoot them up
underscore-Tutorial Dies ist die von Epic
empfohlene Namenskonvention für Projekte und
Ordnerstrukturen Darin haben wir einen
Assets-Ordner, der
Dinge wie unsere Meshes,
Texturen und Materialien enthält Dinge wie unsere Meshes,
Texturen und Materialien Wir haben einen Blueprint-Ordner
für unseren Code und unsere Logik und wir haben einen
Maps-Ordner für unsere Level Dies ist eine einfache Struktur, jedoch auf
jede Projektgröße skaliert Eine weitere Sache, die Ihnen vielleicht auffällt wenn Sie einige
der Ordner
durchsuchen , sind Dinge wie die ausgewählten Namenskonventionen. Wir haben Dinge wie MM
Underscore Texture, was für
Master Material steht Wir haben dann MI Underscore,
egal wofür das Material bestimmt ist, und das ist Material Wenn wir zu den Texturen gehen, haben
wir Dinge wie unseren T-Underscore Plane Hero,
und das ist T für Ich
vermute, dass all diese Namenskonventionen nicht
zufällig sind Diese basieren alle
auf dem AA-Stil. Du willst das googeln,
du kannst es hier finden, also können wir einfach nach Style Guide
suchen und wir
suchen nach der Github-Seite, die erste hier. Einen Link dazu finden Sie auch in der
Beschreibung unten. Dinge zu benennen ist
angeblich eines der zu schwierigen Probleme
in der Informatik, und das löst eines
dieser Probleme für Sie Ich würde empfehlen,
dies als Referenz mit einem Lesezeichen zu versehen. Und wenn Sie dann einen neuen Asset-Typ
erstellen und sich nicht sicher sind, wie Sie ihn nennen
sollen, schauen Sie hier und durch Wiederholung wird
das automatisiert Es ist jedoch eine wirklich gute
Ressource. Es bietet so ziemlich
alles, was man sich wünschen kann. Sie müssen sich nicht an
alles auf einmal erinnern. Da sind ziemlich
viele Dinge drin. Aber wenn wir uns die
allgemeinen Benennungskonventionen ansehen, haben
wir Dinge wie
Skelettnetze, das wäre SK Bob Das Material für Bob
wäre M nscore Bob, Textur für Bob wäre T
underscore Bob und so weiter Wenn Sie sich die Baupläne ansehen,
haben wir Dinge wie den BP-Unterstrich, und dann können wir
auch Dinge
wie die Datei - und Ordnerstruktur überprüfen wie die Datei Also genau so, wie ich es hier
erwähnt habe, der Name des Projekts und dann alle Ordner in einer einigermaßen logischen,
aussagekräftigen Konfiguration Das ist also wirklich der heilige Punkt wie man seine Projekte strukturiert
, wie man für Ordnung sorgt und
wie man sich im Laufe der Zeit organisiert Um zu beginnen, brauchen wir eine
Hauptebene, um mit ihm zu arbeiten. Bevor ich mich
damit beschäftige, möchte
ich Ihnen etwas vorstellen damit
Sie meinen Bildschirm
etwas leichter sehen Aber es kann auch für
Sie nützlich sein, darüber Bescheid zu wissen. Also gehe ich zu den
Bearbeitungseinstellungen hier oben auf dem Bildschirm und
gehe zu den Editor-Einstellungen. Hier können wir verschiedene Funktionen
zur Darstellung des Editors
ändern zur Darstellung des Editors Die Tastenkombinationen, Tastenkombinationen und ähnliches finden Sie
hier. Was ich hier ändern
möchte, ist die Anwendungsskala. Ich werde das einfach auf 1,25
ändern. Das liegt nur daran, dass
ich
einen ziemlich großen Bildschirm eingerichtet habe , sodass er möglicherweise etwas
gestreckt aussieht und die Tasten möglicherweise etwas klein aussehen,
damit Sie dem folgen Also, wie gesagt,
das ist optional, aber es ist nützlich zu
wissen, dass es das gibt. Und es gibt noch viele weitere
Dinge, die Sie
in den
Editor-Einstellungen tun können , um
das allgemeine Erscheinungsbild
Ihres Editors zu optimieren das allgemeine Erscheinungsbild
Ihres , falls etwas für
Sie
nicht ganz richtig ist Das wird jedoch automatisch gespeichert, also schließe ich einfach
das Fenster und wir können jetzt mit der Erstellung
unseres ersten Levels beginnen Das ist nett und einfach. Wir können zur linken
oberen Seite gehen. Wir haben unsere Dateischaltfläche und wir haben
hier die Möglichkeit, ein neues Level zu erstellen. Eine Sache, auf die Sie
achten sollten, sind die Abkürzungen. Wir können alle Tastenkombinationen sehen. Wir
neigen dazu, ziemlich oft mit neuen Levels zu spielen. Es könnte also
eine sein, an die Sie sich frühzeitig
erinnern sollten, um
Ihnen ein wenig Zeit zu sparen. In dem neuen Fenster wählen
wir nur die Basisstufe aus, nicht die offene Welt. Das wird viel zu
komplex für das sein , was
wir jetzt brauchen. Außerdem dauert es jedes
Mal länger, den Editor zu laden, wenn Sie das Backup starten. Also doppelklicken wir auf Basic und befinden uns jetzt in
unserer neuen Basisstufe. Dann stellen wir sicher, dass wir das auch
korrekt gespeichert haben. Standardmäßig
heißt das Untitled,
was bedeutet, dass wir es noch nicht
gespeichert haben. Das ist nicht gespeichert Wenn wir das Projekt schließen und
zurückkommen , verlieren wir unseren Fortschritt. Also drücken wir hier im Viewport die
Strg-Taste in S und dann
die Taste S,
um zu speichern Wir gehen in den Tutorial-Ordner von Shootm up, gehen zum Maps-Ordner und
nennen diesen einen Hauptordner Wir können den Namen
einfach hier unten angeben. Drücken Sie Speichern oder Enter, und
das wird automatisch gespeichert. In der Inhaltsschublade können
wir zu unserem Maps-Ordner gehen
und sehen, dass sich unsere
Karte gerade hier befindet. Eine Sache, die schnell zur Kenntnis genommen werden kann. UnRel verwendet die Wörter Map und Level
synonym Das Gleiche, zwei verschiedene Namen weil es das natürlich tut Wir können sehen, dass dies hier
tatsächlich als Level bezeichnet wird, aber wenn wir dies später
verwenden, werden wir
von Unreal aufgefordert, eine bestimmte Map festzulegen Eine weitere Sache, die wir beachten und mit der
wir
ziemlich oft arbeiten werden , ist die
Inhaltsschublade Anstatt also ständig
die Taste unten links unten zu drücken, können
wir in
der Leertaste die Strg-Taste drücken, wodurch die
Inhaltsschublade geöffnet und geschlossen wird Und dieser Teil ist
wirklich wichtig. Hier verlieren Anfänger
immer ihre Arbeit, oder zumindest
glauben sie, dass sie es tun, bis sie zurückkommen und Hilfe
holen. Ohne diesen Schritt schließen Sie Ihr Projekt, öffnen es erneut
und Sie werden feststellen, dass Sie auf eine leere,
offene Weltkarte oder etwas anderes
starren, mit dem
Sie nicht gerechnet Ihr Hauptlabel
ist immer noch vorhanden, aber Unreal weiß nicht, dass es standardmäßig geöffnet werden
sollte Um dieses
Verhalten zu ändern,
gehen wir zu den
Projekteinstellungen Wir gehen zur Bearbeitung und
dann zu den Projekteinstellungen. Auf der linken Seite,
in der obersten Kategorie, möchten
wir die Option
Karten und Modi finden. Und dann sehen
Sie auf der rechten Seite die Startkarte des Editors. Ändern Sie dieses Drop-down-Menü von Standardvorlage zu unserer
Hauptmap, die wir gerade erstellt haben. Dadurch wird der
Unrel-Engine mitgeteilt, welches Level geöffnet werden soll, wenn Sie das Projekt zum
ersten Mal starten Wir könnten
hier auch
die Standard-Map des Spiels als Hauptmap festlegen hier auch
die Standard-Map des Spiels als Hauptmap Dies bestimmt, was
der Spieler sieht, wenn Sie das Spiel
tatsächlich
verpacken und es
jemand anderem zum Spielen geben. Diese Einstellungen werden alle automatisch gespeichert,
sodass wir das Ganze schließen können. Wir können das Projekt erneut öffnen, und das
bedeutet, dass
Sie genau
dort zurückkehren , wo Sie aufgehört haben,
solange Sie die
Map, an der Sie gerade arbeiten, speichern Das mag also nach einer Menge zusätzlicher Arbeit und viel Gerede
allein für das erste Thema Aber diese Grundlagen verschärfen sich
wirklich. Ein organisiertes Projekt wird bei
10 Stunden,
100 Stunden oder sogar 1.000 Stunden
überschaubar bleiben bei
10 Stunden,
100 Stunden oder sogar 1.000 Stunden
überschaubar , wohingegen ein chaotisches
Projekt das einfach nicht tut Und das ist wirklich
das Ziel und
der Schwerpunkt dieses gesamten
projektorientierten Dinge können
etwas länger dauern, aber am Ende werden
Sie verstehen, was Sie tun, und hoffentlich
einige bewährte Verfahren
mitnehmen Ihre zukünftigen
Projekte viel intuitiver und
einfacher zu handhaben sind. Aber vor diesem Hintergrund sind die
Grundlagen gut gelegt. Die Projektstruktur, die
Namenskonvention und die Einstellungen sind alle korrekt
konfiguriert. Das nächste Thema wird die
Erstellung unserer Spielfigur sein, die du tatsächlich kontrollieren
kannst Und wie ich schon angedeutet habe,
möchte ich, dass du im Laufe Zeit wirklich lernst, was du
tust Eine der besten
Arten zu lernen besteht nicht einfach Schritt für Schritt
nachzugehen Sobald Sie das Gefühl haben,
etwas zu verstehen , versuchen Sie, es zu erweitern. Selbst für etwas
so Einfaches wie das, was wir jetzt
getan haben , fügen Sie Ihre eigenen Ordner hinzu, benennen Sie einige Dinge um und
beweisen Sie sich selbst dass Sie das
Muster verstehen, nicht nur die Schritte. Ich werde dich sowieso
bei all
dem, was
wir tun, darauf hinweisen, aber ich kann nur
so viel tun, und ein Großteil der Arbeit wird durch Selbstlernen
entstehen. Wenn Sie Änderungen vornehmen
, die gut funktionieren, schreiben Sie diese in den Kommentaren
und Diskussionen unten. Und wenn du glaubst,
etwas zu verstehen und siehst, dass jemand eine
Frage stellt
, von der du denkst, dass du sie beantworten kannst,
versuche, sie zu beantworten. Etwas zu erklären
, das Sie gerade gelernt haben ist eine der schnellsten
und besten Möglichkeiten, die
neuen Informationen zu speichern und sicherzustellen, dass Sie sie in Zukunft nicht
vergessen
3. 02 - PlayerPawn: Die Projekte sind jetzt eingerichtet und wir
brauchen etwas, mit dem wir tatsächlich
anfangen können, sie zu kontrollieren Am Ende dieses
Themas werden wir
eine Spielfigur mit Mahnwachen haben .
Er wird sich noch nicht bewegen Das wird als Nächstes kommen, aber
wir werden genau verstehen wie und warum Unreal beschließt, Dinge
zu spawnen und wo Eines der wichtigsten Dinge bei der
Entwicklung ist es, vorausschauend zu planen und wirklich
darüber nachzudenken, was dein aktuelles Ziel ist und
wie du es erreichen kannst Aus den Videos wissen
wir also ganz einfach, dass wir
diesen kleinen Charakter in
einem kleinen blauen Flugzeug kontrollieren wollen , um sicherzustellen, dass niemand
zurückgelassen wird. Wenn Sie in allem völlig
neu sind, möchte
ich nicht den
kompletten Jargon rauswerfen Also werde ich einige
wirklich grundlegende Dinge zeigen. Die Ebene, die wir betrachten ist
ein sogenanntes statisches Netz. Wenn wir also zu den
Asset-Meshes gehen, können
wir hier sehen, dass
es sich um ein statisches Netz unseres kleinen Charakters
in der blauen Ebene Also wollen wir das
kontrollieren. Wenn wir das
direkt in das Level werfen würden, könnten
wir ein statisches Mesh nicht
kontrollieren. Wir müssen diesen
Code auf der Grundlage von Code erstellen und zumindest
eine Art Blueprint-Klasse
verwenden eine Art Blueprint-Klasse , um das Ganze zum Laufen
zu bringen In Unreal wird das als Schachfigur
bezeichnet,
etwas, das wir
besitzen oder über das wir die Kontrolle übernehmen können,
im Grunde genommen nur einen
speziellen Typ von ,
im Grunde genommen nur einen
speziellen Typ Lassen Sie uns also weitermachen
und unsere Figur mit unserer guten
Ordnerstruktur richtig erstellen mit unserer guten
Ordnerstruktur richtig Also gehe ich in
unseren Blueprints-Ordner. Darin wollen
wir einen neuen Ordner erstellen. Wir können hier mit der rechten Maustaste klicken und
nach der neuen Ordneroption suchen . Ich neige dazu, die
Tastenkombinationen
Strg+Shift und N zu verwenden , um dort einen neuen
Ordner zu erstellen. Also N für neu. Ich werde
diesen Ordner in CR umbenennen. Dies werden unsere wichtigsten
Spielmechaniken oder Gameplay-Features sein. Und innerhalb dieser
großen Ordnerstruktur, wenn wir mit der rechten Maustaste klicken, wollen
wir direkt hier zur Option
Blueprint-Klasse gehen Dadurch können wir einen neuen Blueprint
erstellen, und wir können hier eine Reihe
verschiedener Optionen sehen Und hier
kann es hilfreich sein, die
Klassenhierarchie von Unreal zu
verstehen kann es hilfreich sein, die
Klassenhierarchie von Unreal zu Kurz gesagt, alles in
Unrel erbt von etwas, das als Objekt bezeichnet wird Dies ist nur ein Datencontainer, die einfachste Klasse, auf
die wir Zugriff haben Wir sehen dann ziemlich oft
etwas, das Schauspieler genannt wird. Im Moment ist alles auf dem
Level im Grunde eine Schauspielerklasse. Wir werden statische Netzschauspieler,
Kameraschauspieler und leichte Schauspieler haben , aber sie sind alle
Schauspieler in ihrer Wurzel. Fügt zusätzlich zu den Objektdaten eine physische Präsenz handelt es
sich um eine Position,
Drehung und Skalierung, die
als Transformation bezeichnet werden. Und dann sind die Figuren, mit denen
wir arbeiten werden,
nur Schauspieler mit der
Funktionalität, die man besitzen muss Ihr werdet in einigen Tutorials sehen, sie stattdessen
eine sogenannte Charakterklasse verwenden werden, und das wäre
übertrieben für das, was wir
damit erreichen wollen, sie zu erschießen Zu den Charakteren gehören Dinge wie Gehmechanik, Schwerkraft, Kapselkollision,
Dinge, die wirklich
für humanoide Charaktere entworfen wurden , die
zu Fuß herumlaufen Wir werden
ein Raumschiff bauen, also
brauchen wir nichts davon wirklich Und es ist mit einer
Menge zusätzlicher Kosten , die wir benötigen würden, um aktiv zu arbeiten Vielleicht siehst du andere Tutorials, in denen
du Dinge wie
einen Panzer-Controller mithilfe
einer Charakterklasse
erstellst , und wenn du dir dieser Dinge
bewusst bist,
kannst du dir darüber im Klaren sein
, dass das vielleicht nicht die
beste Lösung für das ist dieser Dinge
bewusst bist,
kannst du dir darüber im Klaren sein
, dass das vielleicht nicht die , was
du zu erschaffen versuchst. Da Bauern ein
ziemlich häufig
verwendeter Akteur oder eine Art von Klasse sind , können
wir sehen, dass das tatsächlich
hier oben im Bereich Allgemein steht, also können wir darauf klicken und
dadurch wird eine neue
Bauernklasse für uns erstellt Und wir wollen diese eine
BP-Unterstrich-Bauernbasis nennen, weil dies
die Basisklasse für
alle bauernbezogenen Klassen sein wird , die
wir in Zukunft erstellen, sodass wir einen
Teil der Logik auch für
unsere Feinde wiederverwenden können und sie nach dem
benennen, was sie im Allgemeinen ist, nicht nur
nach
dem, wofür sie zuerst gedacht ist, was
als Spielerklasse funktionieren wird. Bevor wir weitermachen, hier
noch eine schnelle Beilage, schnelle Lösung für die Lebensqualität. UnrelEngine hat einige
starke
Meinungen zur Fensterverwaltung,
und sie sind größtenteils falsch Um also eines der Dinge zu korrigieren,
die bald passieren werden, wenn wir jetzt doppelklicken, um unseren Blueprint zu
öffnen, wird
so
ziemlich überall
auf dem
Bildschirm ein schwebendes Fenster erzeugt so
ziemlich überall
auf dem Das kann ziemlich nervig sein. Das bedeutet, dass
Windows
hinter anderen Anwendungen
und ähnlichen Dingen verloren gehen kann . Also wenn wir zurück zu Bearbeiten
und dann zu den Editor-Einstellungen gehen. Derselbe Ort, den ich
Ihnen zuvor gezeigt
habe, wo ich die Anwendungsskala geändert habe. Wie ich bereits erwähnt habe, können
wir viele Verbesserungen und Änderungen an
der Lebensqualität vornehmen. Ich möchte im
Asset Editor den offenen Ort finden. Wir möchten
dies von der Standardeinstellung ändern, die überall geöffnet ist, und wir werden
dies auf das Hauptfenster ändern. Sie können verschiedene
Dinge ausprobieren und herausfinden, welche für Sie am besten geeignet sind.
Ich mag das Hauptfenster
sehr. Es ist also so, als würde man
in einem Webbrowser arbeiten, wo jede neue Datei, Blueprint, jedes Asset, was
auch immer Sie gerade bearbeiten wenn Sie ein neues Fenster öffnen, wird ein neuer Tab erstellt , der wie
Lesezeichen oben Auch das wird automatisch
gespeichert. Wir können es schließen, zurück
zur Inhaltsschublade gehen
und dann erneut doppelklicken, um die Pan-Basis zu öffnen. Sie können sehen, dass sich das hier öffnet, was genau das ist, was ich wollte. Wenn Sie dasselbe getan haben wie ich, wo Sie das vielleicht zweimal
geöffnet haben, Sie möglicherweise mit dieser
vereinfachten Datenansicht begrüßt Und das ist völlig in Ordnung.
Wir müssen nicht in Panik geraten. Dies sind alle Klassendetails, die uns im Wesentlichen
in Text- oder Drop-down-Form
präsentiert werden. Um zurück zum
vollständigen Blueprint-Editor zu gelangen, brauchen wir nur diese
blaue Texturlinie, den Blueprint-Editor mit den offenen vier, und das bringt uns wieder dahin
, wo wir sein wollen Okay, es gibt also eine Menge Informationen, die ich dir jetzt gleich
als Erstes geben könnte, aber das meiste davon würdest du wahrscheinlich
vergessen Also werden wir einen etwas und
natürlicheren Weg wählen
, um die Unreal Engine zu erlernen Wir werden einfach mit neuen Funktionen
arbeiten und ich werde sie im Laufe der Zeit vorstellen und sobald
sie relevant werden Das Erste, was wir im Moment
sehen können, ist, dass wir uns im Ereignisdiagramm auf
diesem Tab gerade hier befinden. Hier
platzieren wir unsere Logik und Code. Wir werden später wieder hierher
kommen. Wenn wir vorerst auf
den Aussichtspunkt klicken, ist
das nur eine ähnliche Sache, wo wir uns umschauen
und sehen können , wie unsere
Blueprint-Klasse aussehen wird Blueprint-Klassen bestehen normalerweise aus verschiedenen Komponenten, von jede ihre eigenen
Merkmale und Funktionen hat Auf der linken Seite
sehen wir das Komponenten-Panel, und wir möchten unsere visuelle
Darstellung,
dieses statische Netz, hinzufügen Darstellung,
dieses statische Netz, Wenn wir also auf Anzeige drücken und nach statischem Mesh
suchen , können wir das genau hier
sehen. Das wird
der erste Teil des
Puzzles sein , das wir zu lösen
versuchen. Wenn das statische Netz ausgewählt ist, auf der rechten Seite des Fensters können
wir
auf der rechten Seite des Fensters unser Detailfenster sehen. Dies sagt uns alles über die Komponente, die wir
derzeit ausgewählt haben. Wir können sehen, dass wir
hier unten ein Drop-down-Menü für das statische Netz haben, und das ist die
visuelle Darstellung , die wir festlegen möchten. Wir wissen, dass dies das blaue Flugzeug sein
soll, also suchen wir den Flugzeug-Helden
und wählen ihn aus. diesem Viewpot
benutze ich nur das Mausrad,
um rein und raus zu blättern Wenn wir die Alt-Taste drücken und mit der linken Maustaste klicken, können
wir das Modell bewegen
und es betrachten . Wenn wir mit der rechten Maustaste klicken
und mit der Maus ziehen, können
wir ändern, was
wir sehen Klicken Sie mit der mittleren Maustaste und bewegen Will Dolly oder Pan, ich
glaube, das ist ein Anruf Und das sind die
Grundlagen für Navigation in
diesem Viewpot und auch im World Viewport später
auch im World Viewport, wenn wir zum
Levelbau und
ähnlichen Dingen kommen Levelbau und Es ist auch nützlich
zu wissen: Wenn Sie
F drücken, wenn Sie etwas
ausgewählt haben, konzentrieren Sie Das ist also F für Fokus. Was wir gerade
erstellt haben, ist unser statisches Netz, und wir können im
Komponentenfenster sehen, wir
ein sogenanntes Standard-Szenenstammverzeichnis haben. Dies zeigt die Struktur des
Schauspielers, und jeder Schauspieler benötigt
mindestens einen Standard-Szenenstamm, einen Punkt im Raum, an dem
alles andere angehängt ist. Die Standard-Szenenwurzel, die wir haben, ist nur ein Platzhalter, sodass wir unser statisches Netz und unser statisches Netz
auf das
Standard-Szenenwurzel ziehen und loslassen können auf das
Standard-Szenenwurzel ziehen und loslassen Also linkes Bein und wir haben jetzt
unser statisches Netz zu
dem gemacht , was als Wurzelkomponente bezeichnet
wird, also zum Basiselement unserer
Spielerklasse oder unserer Spielfigur Eine andere Sache: Wenn
wir an einem Punkt angelangt sind, an dem wir denken, dass wir mit dem Fortschritt
zufrieden sind, müssen
wir sicherstellen, dass wir
es uns zur Gewohnheit
machen auf Kompilieren und Speichern Damit stellen wir nur sicher
, dass wir unsere Arbeit
nicht verlieren, wenn etwas abstürzt. Und beim Kompilieren
suchen wir einfach nach Fehlern und
erkennen Dinge frühzeitig Also haben wir jetzt unsere
Spielfigur mit Bildern. Aber wenn wir
auf Play drücken, werden
wir
das natürlich noch nicht sehen, weil wir der
Unreal-Engine nicht gesagt haben, dass sie es benutzen soll Und wir können hier einige Standardeingaben
aus Ego-Spielen verwenden hier einige Standardeingaben
aus Ego-Spielen Also werden WAS und D dich
herumfliegen. Q und E bewegen
dich auf und ab, und natürlich schaut sich die
Maus um. Aber das ist natürlich nicht ganz die Funktionalität, nach der
wir suchen. Im nächsten Thema werden wir dieses Problem beheben, indem
wir uns Gameplay-Framework der Unreal
Engine ansehen Wir werden der
Unreal-Engine genau sagen, was spawnen
soll und
wo sie spawnen soll Auch hier gilt: Wenn ihr auf eigene Faust
experimentiert, was ich immer empfehlen würde, versucht, Bauerklasse weitere Komponenten
hinzuzufügen Etwas so Einfaches
wie ein Punktlicht, ein Standard-Partikelsystem, nur um zu sehen, was
passiert, wenn man
Dinge verschiedenen
Teilen der Hierarchie Durch diese Art von Experimentieren kriegt man das
Zeug wirklich zum Kleben
4. 03 - Spielrahmen: Nachdem der Bauer gebaut ist, haben
wir auf Play gedrückt, und wir haben bereits gesehen,
dass
wir im Spielmodus tatsächlich um
den sogenannten Standardbauern
herumfliegen . Also
müssen wir das ändern Unreal Spawns ist standardmäßig und hat die
Klasse, die wir erstellt haben, komplett ignoriert Um das richtig zu beheben, müssen
wir wirklich verstehen, wie Game-Framework von Unreal
entscheidet, was
wo spawnen soll, und dann können wir ihm sagen
, Lassen Sie mich Ihnen zunächst
noch einmal einen kleinen
Überblick über das Konzept geben . Lassen Sie mich Ihnen zeigen, was tatsächlich hinter den Kulissen passiert Zuallererst
gehe ich zurück in das Hauptfenster und drücke Play. In Playode können wir
hier herumfliegen. Es ist wirklich
nützlich zu wissen, dass Sie
F 8 drücken können , um aus dem Spiel auszusteigen Ich bin also immer noch im Spielmodus. Aber ich kontrolliere
den Standardporno nicht mehr. Ich bin jetzt im Grunde
wieder im Editor-Modus sodass ich WAS und D verwenden kann, linken Maustaste klicken, um mich umzusehen, und ich kann sehen, was während des Spiels
passiert. Wenn wir uns den Outliner
auf der rechten Seite ansehen, können
wir etwas sehen, das
als Default Porn Zero bezeichnet wird Das ist es, was wir in dem Level tatsächlich kontrolliert
haben. Und tatsächlich wurde alles, was hier gelb
markiert
ist, vom
UnrelEngine-Gameplay-Framework Wir haben keine
davon im Level platziert. Wenn wir also auf Play drücken,
folgt UnRel einer bestimmten Kette. Zunächst wird
nach einem Spielmodus gesucht, und wenn Sie keinen festgelegt haben,
wird eine Standardoption verwendet Der Spielmodus
entscheidet dann, welche Figur gespawnt werden soll. Und auch hier gilt: Falls du keinen angegeben
hast,
wird der Standard verwendet,
der wörtlich
als Standardbauern bezeichnet wird Und das kontrollieren
wir derzeit anstelle
unseres Flugzeugs, weil wir Unreal nie
gesagt haben ,
dass es diese Flugzeugklasse benutzen soll Drücken wir also Escape,
um den Spielmodus zu verlassen, und wir können beginnen, die
Kontrolle über unser Projekt zu übernehmen Zurück im Core-Ordner. Falls Sie also nicht wirklich
hier sind, Blueprints Core innerhalb der
Inhaltsschublade, wollen
wir eine
neue Blueprint-Klasse erstellen Auf die gleiche Weise wie zuvor, klicken Sie mit der rechten Maustaste und gehen Sie zur Blueprint-Klasse Und dieses Mal wollen wir eine Basis für
einen ungewöhnlichen Spielmodus erstellen Basis für
einen ungewöhnlichen Spielmodus Ich gebe dieser den Namen BP Underscore Game Mode Base Und ein Spielmodus ist im Grunde etwas, das wir uns als Regelhalter vorstellen
können Es teilt NRLEngine mit, welche
Klassen für alles verwendet werden sollen, welcher Pan erzeugt werden soll, welcher
Controller verwendet werden soll, welcher Hud angezeigt werden soll Wenn wir doppelklicken, um unseren Spielmodus zu
öffnen, können
wir sehen, dass dies ein bisschen
wie ein normaler Plan aussieht Wir könnten in den Bereich
Code-Ereignisdiagramm gehen ,
wenn wir wollten, aber alles, was wir
wollen, befindet sich tatsächlich auf der rechten Seite
im Detailbereich Wir können hier die
Dinge sehen, die ich gerade erwähnt habe Die
Standard-Hud-Controller werden alle
hier Das, wonach wir
suchen, ist unsere
Standard-Pornoklasse genau hier. Wir können das löschen
und es
auf BP Underscore Porn Base ändern auf BP Underscore Porn Base Das ist so ziemlich alles,
was wir hier tun müssen. Wir können auf Kompilieren und
Speichern klicken , um sicherzustellen, dass alles
aktualisiert ist. Und wir können
den Spielmodus vorerst beenden. Ich werde das offen lassen, um gleich ein kleines visuelles Beispiel für
etwas zu geben , aber das ist
so ziemlich alles, was wir in unserem Spielmodus
tun müssen . Wie zu erwarten, reicht es nicht aus, nur den
Spielmodus zu
erstellen. Wir müssen
dem Projekt jetzt sagen , dass es es tatsächlich
nutzen soll. Wenn wir also
zur Bearbeitungsoption
oben links zurückkehren , gehen
wir wieder zu den
Projekteinstellungen. Und wir schauen tatsächlich
zurück zu dem, wo wir
zuvor waren , im Bereich Karten
und Modi. Sie können auf der
rechten Seite
sehen, dass der Standard-Spielmodus nur einer
ist, der als
Spielmodus-Basis bezeichnet wird. Und wenn wir das hier ablegen, können
wir tatsächlich sehen,
was es benutzt hat. Es wurde also eine
Standard-Hod-Klasse verwendet, die Standard-Bauernklasse, das Ding, mit dem wir uns buchstäblich herumfliegen
sahen, standardmäßig
den Spieler-Controller und so weiter Wir können
diese nicht ändern, weshalb wir eine benutzerdefinierte
Klasse brauchten, mit der wir arbeiten konnten Wenn wir diese Option weglassen, können
wir sie auf BP
Underscore Game Mode Base ändern Wir können sehen, dass das jetzt freigegeben ist. Und das Wichtigste
ist, dass es jetzt unsere BP-Untergrundpfandbasis ist. Die eine Sache, die ich dir ganz schnell
zeigen wollte
, ist , dass, wenn ich das hier ändere,
ich das hier rauswerfen könnte Ich werde es in etwas
völlig Einzigartiges ändern. Wir haben das auf
den Charakter Arc Vz geändert. Wir können tatsächlich sehen, dass
die Spielmodusklasse , die wir
im Hintergrund erstellt haben,
also haben wir unsere Basis
für den BP
Underscore-Spielmodus im Hintergrund aktualisiert, sodass
sie auch Arc Vz Wenn wir das
hier anklicken und dieses
wieder auf BP
Underscore Pawn Base ändern , wollte
ich nur
hervorheben, dass diese jetzt sind Wenn wir
hier also etwas ändern, wird das in unserer Blueprint-Klasse
aktualisiert Und wenn wir etwas
in unserer Blueprint-Klasse ändern, ändert sich
das auch in
unseren Projekteinstellungen wenn wir es nur hier angeschlossen
haben Wenn das erledigt ist, können wir die Projekteinstellungen
schließen und
sicherstellen, dass wir den Spielmodus kompilieren
und speichern Wenn du mit Dingen
herumspielst, gehe zurück zur Hauptebene und
drücke Play, also O und P, die Abkürzung, um in
den Spielmodus zu gelangen. Und wir sind jetzt
quasi im Flugzeug. Tatsächlich sind wir
buchstäblich im Flugzeug. Also noch ein Problem, das gelöst werden muss,
aber wir kommen näher. Wenn du früher Dinge
manuell dazwischen platziert hast , wenn du mit Dingen
herumspielst, hast du vielleicht andere Flugzeuge
im Level als. Achte darauf, dass du sie loswirst ,
nur damit es
keine Verwirrung gibt, aber wir können irgendwie
sehen, was passiert. Wir drücken die Play-Taste, um in den Wiedergabemodus zu wechseln, und wenn ich dann F
8 drücke, um wieder herauszuspringen, können
Sie sehen, dass jetzt tatsächlich
ein Flugzeug
entstanden ist , das wir kontrollieren Das Hauptproblem ist, dass
wir uns darin befinden. Ich wollte nur
eine weitere Sache hervorheben, die mit dem
Gameplay-Framework
passiert, und das ist die Verwendung
unseres Spielerstarts. Das kannst du also
einfach hier im Level sehen. Und im Outliner können wir sehen, dass es hier
der Spieler Start heißt Das ist es, wonach das Framework suchen
wird, um zu
bestätigen, wo Sie die Figur, die
Sie kontrollieren
möchten, tatsächlich spawnen möchten Wenn ich das also
irgendwo weit hinten verschiebe, verschiebe
ich es bis in
den offenen Raum hier drüben Wenn ich auf Play drücke, spawnen wir das Flugzeug
immer noch, aber jetzt spawnen wir
raus ins Freie Also nochmal, etwas
Nützliches, worüber man Bescheid wissen sollte. Wenn wir keine
davon haben, können wir sie löschen, aber Unreal muss jetzt raten, wo wir unser Ding spawnen
wollen Und es geht nicht wirklich um
Vermutungen, nur um zu zeigen, was
mit diesem Szenario passiert Wenn ich mich im Viewpot bewege, benutze
ich einfach wieder die rechte
Maustaste, um mich umzusehen, und
dann W, AS und D, um zu fliegen,
je nachdem, wo ich hinschaue Wenn ich die Play-Taste drücke, können wir sehen, dass
das Flugzeug jetzt gerade an der letzten Position
erscheint, an der sich meine
Kamera im Viewpot befand Also nochmal, etwas, das
ich gerade gesehen habe, hat
neue Entwickler zum Stolpern gebracht, weil es vielleicht nicht ganz klar ist, was der
Spielerstart gemacht hat, besonders wenn du in
einem Projekt arbeitest , in dem du vielleicht
so etwas wie einen Charakter aus der dritten Person oder einen
Charakter aus der ersten Person mit Schwerkraft
hast, du wirst
im Level arbeiten, du wirst ein paar Dinge
entwerfen,
du drückst Play, und dann
fällst du plötzlich durch den Weltraum, vermeidest das Level
komplett und bist ein bisschen verwirrt. Und das nur, weil
du wahrscheinlich deinen Spielerstart
losgeworden bist. Unreal wusste nicht, wo es deinen Standardcharakter
spawnen sollte, also hat es den letzten Ort ausgewählt, an dem
du im Editor warst Wenn du hier
mitgemacht hast, können wir oben zu dieser
Schaltfläche „Hinzufügen“
gehen Wir können einfach hier nach einem
Spieler suchen und einen
davon einfach wieder im Level ablegen. Schön und einfach, wir sind
wieder da, wo wir waren. Das einzige Problem ist, dass wir an der
falschen Stelle suchen. Das bedeutet nur, dass
wir eine Kamera brauchen und Unreal sagen müssen
, welche
wir verwenden sollen Um das zu tun, müssen wir zurück
zur
BP-Basis-Porno-Basis gehen BP-Basis-Porno-Basis gehen Wenn du das nicht wirklich geöffnet
hast, merke das
in
der Inhaltsleiste, also kontrolliere es im Leerraum und
doppelklicke auf die Porno-Basisklasse Wie ich bereits erwähnt habe, bestehen die meisten
Klassen einfach aus zahlreichen Komponenten,
wobei jede Komponente versucht, eine bestimmte Rolle oder einen bestimmten Anwendungsfall zu erfüllen . In diesem Fall möchten wir, dass sich
eine Kamerakomponente unser statisches Match ansieht. Bevor wir eine Kamera hinzufügen, füge
ich etwas hinzu als Federarm
bezeichnet wird
, nur um diese vorzustellen. Wenn wir also hier auf Anzeige drücken, können
wir nach Spring Arm suchen.
Wir klicken, um das hinzuzufügen. Und das ist im Grunde
ein Stick, der die Kamera in
einem festen Abstand
hält. Er kann auch
Dinge wie Kollisionen bewältigen, die Kamera
näher
heranschieben, wenn wir gegen Wände stoßen, und versuchen
, Dingen auszuweichen. Wir werden diese
Komplexität für unser Spiel nicht benötigen, aber es ist nützlich zu wissen
, dass diese Funktionen existieren. Eine weitere sehr praktische Verwendung
des Federarms besteht darin, dass wir den Offset, die Position und
die
Drehung der Kamera nicht direkt
beeinflussen Position und
die
Drehung der Kamera Also werden wir es
nur aus diesen Gründen behalten. der Federarm
noch ausgewählt ist, kehren
wir
zur Schaltfläche Hinzufügen zurück. Wir werden nach einer Kamera
suchen. Und wir wollen hier oben die
Standardkamera auswählen. Man kann sehen, dass sie
gerade am Ende
des Frühlings vor der Kamera platziert ist, ähm. Dies gibt uns ein
wenig Zeit, um uns auf die
Unreal Engine und die Art und Weise zu konzentrieren , wie sie mit Hierarchien umgeht Wir haben uns bereits mit
der Tatsache befasst, dass das statische Netz jetzt als
Nahtwurzel eingestuft wird Wo auch immer die Nahtwurzel hinführt, alles andere
folgt, einschließlich Rotation, Lage und Maßstab Die Feder um wird dann als untergeordnetes
Element des statischen Netzes eingestuft , und die Kamera ist ein
untergeordnetes Element der Feder um Das heißt also, wenn ich die Federkomponente um nehme und dann etwas
an der Drehung ändere, weiß ich, dass die
Kamera um
90 Grad nach unten auf
das statische Netz schauen soll 90 Grad nach unten auf
das statische Netz Das werden -90 Grad sein. Wir können sehen, dass die
Kamera die Drehung erbt , die ich der Feder
gegeben habe Ich mache die Feder größer, also
sperre ich die Position
und mache sie auf
die Größe zehn,
wir können sehen, dass die Kamera
auch zehnmal größer wird Nun, wir skalieren die Kamera nicht
und springen auf diese Weise, aber ich wollte nur
zeigen, wie die Hierarchie innerhalb von Unreal
mit den Komponenten
funktioniert Wir wollen aber die
Kameradrehung, also würde ich eine
Drehung um etwa -90 empfehlen, sodass die Kamera direkt auf den
Spieler
schaut Wenn wir auf Play drücken, können wir sehen, wie das
aussehen wird. Also vielleicht ein bisschen zu nah, das könnte etwas
schwierig sein, zu sehen was
mit den Feinden
und Projektilen während des Spiels passiert und Projektilen während des Spiels Das Spring Hum hat
noch eine weitere Funktion, die uns dabei helfen wird Es wird als
Zielarmlänge bezeichnet, und das können Sie
im Detailbereich erneut sehen Wie ich bereits erwähnt habe,
enthält das Detailfenster
beim statischen Netz, wenn wir
etwas ausgewählt haben, nur alle Informationen zu
den
Komponenten, die Sie derzeit ausgewählt
haben. Das Federbrummen hat
diesen Wert, der als
Zielarmlänge bezeichnet wird,
das ist diese rote Linie, und wir können ihn auf
etwa 1.200 setzen, und das wäre ungefähr der Wert
, den wir haben wollen Wir können also auf
Play drücken und sehen, dass wir etwas
mehr vom Bildschirm sehen können Wir werden sowieso
etwas später
zurückkommen und solche
Dinge verfeinern sowieso
etwas später
zurückkommen und solche
Dinge Aber vorerst wird das völlig in Ordnung
sein. Nochmals, wenn Sie
Änderungen vorgenommen haben, mit denen Sie zufrieden sind, stellen Sie sicher, dass wir
auf
Speichern klicken, damit das Ganze etwas mehr
wie ein Top-Down-Shooter aussieht. Wenn Sie also
mitgemacht und aufgepasst haben, haben
wir jetzt gesehen, dass,
wenn wir
der Unreal-Engine nicht sagen ,
welche Map sie verwenden soll, sie eine etwas zufällige Map verwendet Wenn wir ihr nicht sagen
, welchen Spielmodus sie verwenden soll, verwendet
sie einen Standard-Spielmodus Und wenn Sie dem Bauern nicht sagen
, welcher Bauer verwendet werden soll, verwendet er einen Standardbauern Aber du hast wahrscheinlich
bemerkt, dass wir ihm nicht gesagt haben, welche Kamera er benutzen soll,
aber er weiß, dass er die
Kamera benutzen muss, die wir gerade hinzugefügt haben Es verstößt also gewissermaßen gegen die Regel, die ich hervorgehoben
habe. In diesem
Fall
kommt es jedoch immer noch auf das Verhalten des
Gameplay-Frameworks an. Wenn das Framework
zum ersten Mal eine Figur besitzt, schaut
es innerhalb
dieser Klasse und sucht nach
Kamerakomponenten Ich vereinfache
das ein wenig, aber es ist im Wesentlichen der
Prozess, der durchgeführt wird Wenn es eine Kamera findet, wird
es sie standardmäßig verwenden. Wenn es keine
Kamera in Ihrer Hierarchie findet, erstellt es
eine Standardkamera,
und die Position
, an der es sie platziert,
ist
zufällig Null,
was in unserem Fall direkt innerhalb
des Ebenennetzes liegt, weshalb wir uns das Innere des Körpers angesehen haben. Also können wir jetzt wieder sehen, warum wir auf das Innere des Flugzeugs gestarrt haben und wie
wir
das außer Kraft gesetzt haben , um jetzt nach
unten auf das Flugzeug zu schauen Aber das gleiche Muster wie
alles andere. Das Framework hat seine
Standardprozesse, und das Wichtigste ist, dass wir uns jetzt bewusster sind, dass wir entweder die
Möglichkeit haben,
sie zu überschreiben oder mit ihnen zu leben. das erledigt ist,
kontrollieren wir jetzt, was spawnt, wo es spawnt und durch welche
Kamera wir schauen Das Framework arbeitet für
uns statt gegen uns. Und auch hier werden Sie vielleicht
überrascht sein, wie viele Leute am
Ende ziemlich
lange gegen das Framework arbeiten. Etwas anderes, mit dem ich
ziemlich vertraut geworden bin, wenn Studenten einfach
kopfüber in Projekte eintauchen ich das Projekt
zu Gesicht bekomme,
nachdem sie eine Weile daran
gearbeitet haben, werden sie Abhilfemaßnahmen haben, indem sie es sich durch
bestimmte Kameras
ansehen,
wodurch Spielfiguren an bestimmten Stellen
ausgelöst werden müssen, wodurch das Framework
im Grunde genommen
auseinandergenommen und bekämpft wird
, anstatt zu arbeiten durch
bestimmte Kameras
ansehen,
wodurch Spielfiguren an bestimmten Stellen
ausgelöst werden müssen, wodurch das Framework
im Grunde genommen
auseinandergenommen und bekämpft wird
, das Framework
im Grunde genommen auseinandergenommen und bekämpft wird Wo immer möglich, können wir viele dieser Framework-Grundlagen nutzen ,
und sie helfen uns tatsächlich
mehr, als dass sie uns behindern Natürlich haben wir immer noch
keine Bewegung. Wir haben derzeit nur eine Spielfigur , die da sitzt, und eine
Kamera, um sie uns anzusehen Das wäre also der nächste Schritt
, Bewegung hinzuzufügen. Ich werde
dir zuerst den
falschen Weg zeigen , Bewegung hinzuzufügen , weil du das
in vielen verschiedenen Tutorials sehen wirst . Nachdem wir das gesehen haben,
werde ich Ihnen zeigen, wie Sie diese Probleme
beheben können, damit Sie
wissen, worauf Sie achten müssen. Wenn Sie noch
einmal experimentieren möchten , wäre die kleine Empfehlung, obwohl wir noch recht früh
mit den Themen zu versuchen, die
Kameraentfernung oder den Kamerawinkel anzupassen.
Vielleicht sollten Sie
für den Winkel, aus dem Sie auf das Flugzeug
schauen, ein etwas
anderes Setup wählen. Sie können eine zweite Kamera hinzufügen und sehen , was passiert. Welche
wählt es aus? Und wenn Sie
solche Dinge tun, versuchen Sie
zu beschreiben, was Ihnen auffällt,
was
das Framework tut, was
Sie nicht erwarten, oder was Sie davon irgendwie
verstehen
5. 04 – LegacyInput: Bevor sich der Spieler bewegen
kann,
muss Unreal wissen, worauf
der Das können Tastaturtasten,
Controller-Sticks, Trigger sein. All das fließt durch
das Eingabesystem. Unre nimmt diese Bindungen und wandelt sie in Eingabewerte um, und das lesen wir für
unser Bewegungssystem Der erste Schritt
wird also darin bestehen, zu verstehen wie diese Werte tatsächlich funktionieren Zunächst
werden wir das mit
dem alten Eingabesystem
machen, das irgendwie altmodisch ist. Um diese zu finden,
wollen wir
zu unseren Projekteinstellungen zurückkehren . Also gehen wir zu den
Bearbeitungs- und Projekteinstellungen. Wir werden nur ein
bisschen weiter nach unten gehen als zuvor. Und wir können hier sehen,
dass wir den Eingabebereich haben. Wie ich bereits erwähnt habe,
ist das ein bisschen altmodisch, und es gibt hier sogar eine
Warnung das veraltete Eingabesystem dass
das veraltete Eingabesystem
jetzt veraltet ist.
Das ist in Ordnung Es ist immer noch nützlich zu wissen
, da Sie wahrscheinlich auf Projekte stoßen werden
, die dies immer noch verwenden. Viele Beispiele und Projekte verwenden dieses System immer noch. Verwenden Sie hier zwei verschiedene
Arten von Eingaben. Wir haben unsere
Action-Mappings, die binär sind. werden entweder
gedrückt oder nicht gedrückt. Sie eignen perfekt für Dinge wie Feuer, Interaktion, Springen usw. Dann haben wir unsere Achsenzuordnungen, und diese konvertieren
die Spielereingaben in kontinuierliche
Fließkommawerte Perfekt für Bewegung.
Aus diesem Grund werden
wir gleich hier ein
neues Achsen-Mapping hinzufügen
und dieses
eine Bewegung nach rechts nennen. Da wir
hier
diesen Skalierungswert haben , den wir
für die verschiedenen von uns
bereitgestellten Eingaben ändern können für die verschiedenen von uns
bereitgestellten Eingaben , nennen wir
das eine Bewegung nach rechts. Es steuert auch die
Bewegung nach links,
indem die andere Eingabe auf
einen negativen Wert gesetzt wird. In diesem Drop-down-Menü können wir jede Eingabe
finden, die wir wollen. Dies können Ihre
Tastatureingaben, Ihre
Maus, Ihr Gamepad sein, was auch immer
der Fall Etwas, das ich viel zu viele Jahre lang nicht
wusste als ich die
Unrel-Engine verwendete Ist eigentlich ein Knopf.
Wenn wir darauf klicken und
zum Beispiel die D-Taste drücken , wird die nächste Eingabe als D
verfolgt, und das wäre perfekt, um
nach rechts zu gehen. Wenn wir die Plus-Taste drücken, können
wir eine weitere Bindung hinzufügen. Ich drücke
erneut darauf und dann A, sodass wir uns jetzt nach
links bewegen können. Das einzige, was ich
bereits erwähnt habe, ist, dass dies
standardmäßig ein positiver Wert ist Wenn wir dies auf einen
negativen Wert ändern, also minus eins
, kann uns die Eingabe nach links
bewegen. Wenn Sie verschiedene Schlüssel an dieselbe Eingabebindung
binden möchten, können
wir als Beispiel einfach zwei
weitere hinzufügen Wir können einen für
den Rechtspfeil
und einen für den Linkspfeil hinzufügen . Auch hier möchten wir, wenn wir uns
nach links bewegen, nur sicherstellen, dass wir den
negativen Wert zu diesem Wert hinzufügen. Einfaches System und flexibel genug für das, was wir gerade tun
müssen. Wie bei allem
zuvor wird dies automatisch
gespeichert, sodass wir
die Projekteinstellungen schließen, zur Inhaltsleiste zurückkehren, die Steuerung im Leerzeichen
erneut
verwenden können, um
die Verknüpfung zusammenzufassen und zur Porno-Basis zurückzukehren Wenn du dich immer noch im
Viewpot befindest, wollen
wir jetzt zur Registerkarte „Event-Graph“ übergehen Registerkarte „Event-Graph“ Das, was
ich erwähnt habe, ist der Punkt, an dem sich
unsere Logik bewegen wird, und genau das
werden wir sofort tun. Hier sehen wir bereits
einige verschiedene Knoten im Diagramm,
und ich klicke mit der rechten Maustaste
und ziehe, um mich zu bewegen Zuerst können wir sehen, dass wir
unseren Startknoten haben,
und das geht nur einmal,
wenn wir Start drücken Unten befindet sich unser
Event-Häkchen ganz unten, und dieses Ereignis wird
kontinuierlich ausgelöst , während
das Spiel läuft Vielleicht hört ihr Leute Dinge
sagen wie, dass wir Event-Tick um jeden Preis
vermeiden, aber das
vereinfacht die Sache etwas zu stark Für Funktionen wie Bewegung, bei denen wir wollen, dass das
flüssig und reaktionsschnell abläuft, oder
Kamerabewegungen , Physik und solche Dinge, genau hier muss die
Logik liegen Wir müssen nur
sicherstellen, dass es
sauber und effizient ist. Dann haben wir endlich den
Event-Act, der anfängt, sich zu überschneiden. Das ist eine Überlappungsprüfung, eine Kollisionsprüfung für
die gesamte Klasse. In unserem Fall könnte das
alles sein, was das statische Netz, die Federkomponente
oder die Kamerakomponente sein. Es ist ein bisschen vage, also
neige ich dazu, es nicht zu verwenden, und wir werden später Kollisionen pro
Komponente
behandeln. Also können wir uns diesen schnappen, auf Löschen drücken und das werden
wir loswerden Um zu demonstrieren, was das
Achsen-Mapping bewirkt, bewegen
wir uns ein wenig
nach unten, also klicke ich mit der rechten Maustaste und
ziehe, um das Diagramm zu verschieben Wenn Sie nach rechts klicken, klicken Sie hier
und wir
suchen nach der Eingabebindung, die wir gerade
erstellt haben. Ich habe meinen Move Right genannt. Wir haben hier zwei verschiedene
Optionen. Wir haben das Achsereignis
und den Achsenwert. Das Ereignis würde etwas erzeugen , das dem Eventic sehr
ähnlich sieht, das diesen Ausführungspin
bereitstellt sodass wir daraus die zukünftige
Logik ableiten können Der Unterschied zum Achsenwert dass wir auf diesen klicken Dies bietet nur
diesen grünen Stift. Dieser grüne Stift ist ein Gleitkommawert
oder ein Dezimalkommawert, und dieser gibt einen Wert an, der davon abhängt,
was wir drücken. Wenn wir
nichts drücken, erhalten wir Null. Wenn wir nach links drücken, erhalten
wir minus eins, und wenn wir nach
rechts drücken, erhalten wir plus eins. Ich kann Ihnen das in
einer wirklich einfachen Demonstration zeigen , und ich kann sie jedem empfehlen, neue Teile
der Unreal-Engine
lernt Wir ziehen hier von
diesem Ausführungs-Pin, ziehen ihn in das
Diagramm und lassen los, und dann
suchen wir nach dem Wort print string Das wird also nur eine Debug-Nachricht auf unserem Bildschirm anzeigen, auf der linken Seite,
wenn wir auf Play drücken Wir können also sehen,
dass hier gerade das Fenster
mit dem
Wort Hallo spammt Um zu verhindern, dass das
Spam gesendet wird, weil es 120 Mal pro Sekunde
läuft, wollen
wir das reduzieren die Dauer
auf 2 Sekunden
ändern Dieser Vorgang dauert
derzeit 2 Sekunden, und wir setzen den Wert auf Null Das wird dann hier eher zu einem
Dauerdruck, also wird jetzt nur noch das Wort Hallo
gedruckt. Natürlich
wollen wir damit nicht Hallo sagen. Wir wollen, dass uns das zeigt
, worauf Druck ausgeübt wird. Also nehme ich hier
den Float-Wert, ziehe von diesem Pin und lege ihn in den Instring Die Unreal-Engine
ist intelligent genug , um
unseren Float automatisch in eine Textfolge umzuwandeln ,
sodass es sich um eine Lesbarkeit handelt. Wenn wir also erneut auf Kompilieren
und Abspielen klicken, können
Sie sehen,
dass jetzt Null ausgegeben wird, was daran liegt, dass ich überhaupt nichts
drücke Wenn ich den Linkspfeil drücke, wird minus eins gedruckt,
der Rechtspfeil, ich erhalte ein positives Ergebnis und
dasselbe für A und D. Wir können also sehen, dass das funktioniert. Es passiert hier
etwas. Beim Drucken des Werts werden die Daten
angezeigt, aber für uns ist es immer noch nur eine Zahl
. Also lasst uns einfach ganz
schnell etwas tun , um diesen
Effekt sichtbar zu machen Wir werden noch keine
Bewegung hinzufügen. Wir werden zu einem anderen
Thema darauf eingehen. Wenn wir jedoch aus unserer
Druckzeichenfolge ziehen, also diese Ausführung hier anstecken und nach Set Act
Scale Three D suchen. Wir wollen diesen Knoten genau hier haben
und alles, was wir tun werden,
ist,
die Gesamtskala
unseres Schauspielers zu beeinflussen die Gesamtskala
unseres , basierend auf der
Richtung, in die wir drücken. Um das zu tun, brauchen wir
nur ein kleines bisschen Platz dazwischen. Also verschiebe ich hier nur ein paar
Knoten. Wir werden die
Mathematik wirklich, wirklich einfach halten. Das ist völlig
wegwerfend und dient nur dazu, Teile
des Konzepts hier zu visualisieren Wir können
aber unseren
Setdarsteller im Maßstab 3 D nehmen und
das durch die Richtung steuern, in die
wir drücken Also können wir die Skala
des Schauspielers auf Null minus eins oder eins setzen . Und wenn wir einen analogen Eingang hinzufügen, könnten
wir
diesen Wert so einstellen, dass das wirklich einfach ist. Wir machen hier unseren
Abruf-Zug, den wir schätzen,
also nehme ich diesen und drücke die
Strg-Taste in D, um ihn zu duplizieren. Und wir werden das
einfach hier einstecken. Also wie gesagt, wirklich,
wirklich einfach. Dies wird
für kein reales
Anwendungsszenario nützlich sein . Ich wollte Sie
nur
ein wenig mit dem Entwurf vertraut machen ,
bevor wir uns mit der Bewegung befassen Aber wenn wir auf Kompilieren klicken, wird nur
sichergestellt, dass alles auf Fehler überprüft
wurde und funktioniert.
Drücken Sie auf Speichern, damit wir
nichts vom Fortschritt verlieren Und ich denke,
ich werde wieder zur Bearbeitung und dann
zu den
Projekteinstellungen zurückkehren. Ich habe mein Gamepad angeschlossen, und wenn wir zurück
zum Eingabebereich scrollen, fügen wir hier
einfach
einen neuen Eingang hinzu, klicken Sie auf diese Schaltfläche und ich
bewege den
Analogstick einfach nach links Also habe
ich den linken Analogstick auf der X-Achse bewegt,
die links und rechts ist Wir können dies als
positive Zahl belassen, wenn wir die
analoge Bewegung umkehren
wollen Wenn ich also zum Beispiel
nach links ziehe, würde ich mich nach rechts bewegen. Deshalb möchten
wir vielleicht einen negativen Wert hinzufügen. Aber weil das Analoge den
vollen Bewegungsbereich hat
und wirklich intelligent genug ist, um zu
wissen die richtige
Richtung als positiv angesehen
werden muss, wird der linken Richtung automatisch wird der linken Richtung automatisch dieser negative Wert zugewiesen. Also können wir das schließen. Wir
können in den Spielmodus gehen Wir haben das
Flugzeug momentan irgendwie kaputt gemacht. Im Moment
drucken wir oben Null. Das heißt, wir übertragen
die Zahl Null in die X-, Y- und Z-Skala unseres Flugzeugs,
weshalb wir sie nicht sehen können. Wenn ich A drücke,
kehren wir die Größe um, wir sehen
also den
Boden, weil wir jetzt Ebene
auf die Skala
dieser negativen Und wenn ich D drücke,
machen wir die Skala der
Ebene positiv Der Grund, warum ich den Analogstick
verwenden möchte ,
ist, dass wir das ein
bisschen besser visualisieren können , sodass ich
einige sanfte Bewegungen erzielen kann , indem ich einfach den Analogstick
bewege. Wenn du die Zahl oben siehst, bewegt sie sich zwischen Null und minus Eins, weil ich mich nach links
bewege. Und wenn ich sie nach rechts verschiebe, bewegen wir uns zwischen
Null und Plus Eins. Also nur eine
Art Visualisierung, wie wir diese Werte
nutzen und sie in
eine
wirklich einfache Logik integrieren können diese Werte
nutzen und . Auch hier bekommen wir
eine weitere Konvertierung. Das entspricht unserer
Bewegungsrichtung, also minus Eins,
Null oder Eins , und multipliziert
das mit all
diesen Skaleneigenschaften Also die
Skaleneigenschaften sind unwirklich. Sie haben X, Y und Z. Nur um das für
etwas Einfaches wie einen Würfel zu visualisieren Ich werde nur herkommen
, um dir das zu zeigen. Wenn wir die Eigenschaften
oder den Maßstab dieses Objekts
ändern wollten , könnten
wir nur die X-Achse nehmen, und Sie können sehen, dass
sie länger wird. Wir könnten auf der
Y-Achse skalieren, um sie breiter zu machen. Und wieder können wir die
Z-Achse ändern, um sie zu vergrößern. So nett und einfach, und das ist
wirklich alles, was wir
hier im Code gemacht haben, aber wir normalisieren das
gerade Also alle sind entweder Null,
entweder minus eins oder eins,
basierend auf der Eingabe Also wie gesagt, völlig nutzloser Code,
kompletter Müll, aber hoffentlich macht das
die Eingabe und wie wir diesen Wert nutzen
können, ein
bisschen verständlicher. Damit haben wir bestätigt, dass unser Input funktioniert. Der Porno selbst bewegt sich immer noch nicht. Dieser Teil wird
als Nächstes kommen. Und im nächsten
Video werden wir diese Eingabe in eine
tatsächliche Spielerbewegung umwandeln.
6. 05 - SpielerBewegung: Aber eingerichtet und getestet, ist es an der Zeit, das
Flugzeug tatsächlich in Bewegung zu bringen Nochmals eine faire Warnung,
wir werden
die Dinge immer noch falsch machen, zuerst rahmenabhängige
Bewegung mit einer Art bissiger Bewegung,
füllen, aber es wird funktionieren Und Sie fragen sich vielleicht, warum ich wissentlich
das Falsche unterrichte Dies liegt daran, dass genau dieser Code an vielen Stellen angezeigt
wird Dies stammt aus den epischen
offiziellen Inhaltsbeispielen, was bedeutet, dass Sie ihn
in anderen Tutorials sehen werden ältere
Projekte
verweisen, die Sie möglicherweise erben, und ich bin mir sicher, an
vielen anderen Stellen Als mir das klar wurde,
entschied ich, dass dies die perfekte Gelegenheit wäre , Sie am Ende
dieses Videos an
einen Punkt
zu bringen am Ende
dieses Videos an
einen Punkt , an dem
Sie den Fehler sehen, verstehen werden, warum er auftritt, und
wissen, wie Sie ihn beheben Wir müssen uns also immer noch innerhalb unserer BP-Unterstrich-Bauernbasis befinden. Wir können tatsächlich den
gesamten Code, den
wir im Moment haben, loswerden gesamten Code, den
wir im Moment haben, Wir werden diese
Skalierung loswerden und die Zeichenfolge drucken. Das war nur zur
Demonstration und zum Debuggen. Für die Bewegung
ist das wirklich einfach. Wir müssen das nur als
Richtschnur betrachten . fügen wir eine Art Etwas später fügen wir eine Art
variable Geschwindigkeit hinzu, und wir wollen
die Position unseres Flugzeugs bei jedem einzelnen Tick ändern. Wir können das tun, indem wir aus dem Eventi
ziehen, dem Exekution Pin genau hier. Wir werden nach einem Ort
suchen, der
als Drehbuchautor bezeichnet wird Und das wird
unser Knotenpunkt sein, der direkt steuert und
kontrolliert, wohin wir uns bewegen. Damit das funktioniert,
müssen wir einen Offset berechnen und
dabei den aktuellen Standort des
Flugzeugs
und den Ort, an dem es sich befinden soll, berücksichtigen . Das können wir mit
einer anderen eingebauten Funktion tun. Wir können mit der rechten Maustaste
in das Ereignisdiagramm klicken und ich
suche nach Standort des Schauspielers ermitteln. Wenn wir mit der Maus darüber fahren, wenn
wir sie auch finden, Ihnen, falls Sie das nicht
wussten,
Tooltips zur Funktionsweise
dieser Funktionen angezeigt Tooltips zur Funktionsweise
dieser Funktionen Damit kehren wir zur Position der Wurzelkomponenten zurück,
von
denen wir wissen, dass es sich um
unser statisches Netz
handelt, das uns im Wesentlichen sagt, wo
wir uns in einem bestimmten Frame befinden ziehen
wir von
diesem Vektor-Pin den
gelben Stift genau hier und
suchen nach dem Plus-Symbol, oder Sie können add eingeben und
wir wollen den AD-Knoten. Wir können ein paar wirklich
einfache Vektormathematiken machen. Was wir
hier haben, ist unsere aktuelle Position plus ein Offset das der Stelle entspricht, an der wir
sein wollen, sodass wir
das direkt einstecken können Ein Problem,
mit dem wir derzeit konfrontiert sind, ist dass
wir die Y-Achse direkt
steuern wollen. Wenn du also mit Unreal
arbeitest, werde
ich auf
das Level zurückkommen, nur um hier ein
kurzes Beispiel Wenn es um
Richtungen und Bewegungen geht und du dir nicht sicher bist, in
welche Richtung du dich bewegen willst, können
wir einfach so etwas tun, wie zum Beispiel nach unserem Mesh greifen das im Level fallen und
wir bekommen hier dieses Widget, das uns die
Richtungen zeigt, in die du dich innerhalb von Unreal bewegen
kannst Die Hauptsache, an die man sich schon früh
erinnern sollte, ist, dass Rot, die X-Achse, in der Welt
nach vorne Y, das grün ist, steht rechts und links in der
Welt oder seitwärts, und Z, das blau ist,
steht für oben und unten Das ist sehr praktisch, weil Unreal Engine diese
farblich codiert Wenn wir also
im Detailbereich
nach rechts schauen , können wir hier
sehen, dass wir X,
Y und Z haben , und das
hat ein kleines Pillensymbol Rot, Grün und Blau
anzeigt Wir haben dasselbe für
Rotation und Skalierung. Und wie ich bereits kurz
erwähnt habe , sind diese drei Variablen, die Ortsrotation und die Ortsrotation und der
Maßstab, nur eine
Struktur, aus
der sich die Trans und jede dieser
Variablen wie der Ort zusammensetzt, und es ist nur eine Struktur aus einzelnen
Fließkommawerten. In dem Beispiel, auf dem ich
gezeigt habe und auf dem dieses
Projekt basiert, bewegt sich
das Flugzeug offensichtlich von einer Seite zur anderen und nur von einer Seite zur anderen, so wie bei alten Space Invaders, und wir versuchen, das
nachzubilden, damit wir wissen dass wir uns auf der Y-Achse
bewegen müssen. Also zurück in unserem Code,
das bedeutet, dass wir diese Variable hier irgendwie
verfügbar machen müssen Super einfach zu machen. Wir können mit der
rechten Maustaste auf den gelben Stift klicken, und wir haben diese Option
, um den Strukturpin zu teilen. Und deshalb habe ich
erwähnt, dass diese als Strukturen bezeichnet
werden. Sie kommen in vielen
verschiedenen Formen vor, aber normalerweise sind sie nur eine Kombination
verschiedener Variablen, wodurch ein
bestimmter Variablentyp mit einem
anderen Anwendungsfall entsteht. In diesem Fall ist es der Ort für die
dreidimensionale Bewegung. Wenn wir den Strukturstift teilen, können
Sie sehen, dass er dann
in seine einzelnen
Fließkommawerte X,
Y und Z zurückgesetzt in seine einzelnen
Fließkommawerte X, wird, und wir haben unsere
Bewegung bereits eingerichtet Das ist unsere Bewegung nach rechts, die wir einfach mit der Y-Achse verbinden
können Was wir
jetzt tun ist, dass wir
unseren aktuellen Standort nehmen und bei jedem Frame entweder eins, null
oder minus eins zur Richtung hinzufügen . Wenn wir also auf Play drücken, können wir sehen, dass wir jetzt
irgendeine Bewegung haben. Also werden A und D mich dazu bringen, mich nach links und rechts zu
bewegen, genau wie die linken und rechten Arokis. Also sind wir
dem, was wir wollen, einen Schritt näher gekommen. Das bringt uns
hier in eine
kleine Situation, in der wir jetzt ein Problem
haben, bei dem es sich um ein Spiel handelt
, das von der Framerate abhängt Also werde ich
Ihnen ein paar Dinge über
die Auswirkungen
zeigen und wie
Sie das testen und sich selbst davon überzeugen können also im Moment
daran, dass wir
eine Einheit pro Bild bewegen , wenn
wir eine Taste drücken Wenn ich also mit
120 Bildern pro Sekunde arbeite, das 120 Einheiten pro Sekunde. Ein rL-Motor berechnet
Einheiten in Zentimetern. Das
bewegt sich derzeit also um
etwa 120 Zentimeter/Sekunde Wenn ich jetzt wieder
in den Spielmodus gehe, gehe
ich hier in
das Hauptfenster
und werde
Ihnen etwas vorstellen, das als Konsolenbefehle
bezeichnet wird, mit
denen wir einfache
Befehle ausführen können, um Konsolenbefehle
bezeichnet wird, mit
denen wir einfache
Befehle ausführen können, Dinge zu testen Ich werde dieses Testflugzeug hier auch schnell
loswerden . also wieder in einem Playmode sind, klicken Sie in den
Viewpot, um sicherzustellen, dass Sie die volle
Kontrolle über den Playmode haben Und du willst den Tilda-Schlüssel
finden. Auf den meisten Tastaturen befindet sich diese
neben der Zahlenreihe. Wenn Sie die Tilda-Taste drücken, können
Sie sehen, dass hier unten auf
dem Bildschirm eine kleine Konsole erscheint. Ich werde einen wirklich
einfachen Konsolenbefehl aktivieren
, der Space FPS heißt Wenn ich die Eingabetaste drücke, können wir
auf die rechte
Seite des Bildschirms schauen . Ich zeige jetzt die Anzahl der
Frames an , die ich pro Sekunde abspiele. Ich drücke erneut die
Tilda-Taste und gebe T dot max FPS oder One Word und dann die Leertaste und setze diesen
Wert dann auf 30. Wir können jetzt auf der
rechten Seite sehen, dass
meine Frames auf 30 Bilder pro
Sekunde begrenzt wurden meine Frames auf 30 Bilder pro
Sekunde nur bedenke, was
ich vorhin erwähnt habe Wenn
ich bei 120 Bildern pro Sekunde 120
Einheiten pro Sekunde bewegt habe, bedeutet das jetzt, dass ich mich
offensichtlich mit 30 Einheiten pro Sekunde bewege 30 Einheiten pro Sekunde Wir spielen also dasselbe Spiel, wir haben den gleichen
Bewegungscode, aber die Bewegung unterscheidet
sich drastisch. Wenn ich das wieder hochlege, werde
ich die Obergrenze auf 300 erhöhen. Ich laufe mit etwa 300 FPS. Wir können sehen, dass wir uns jetzt
tatsächlich erheblich
schneller bewegen , weil ich jetzt 300 Einheiten pro Sekunde
bewege. Ich setze den Wert wieder auf 30 und
Sie können den Kontrast sehen. Jetzt können Sie wahrscheinlich anfangen zu verstehen
, warum das nicht ideal ist. Und das bezeichnen wir als Abhängigkeit von der
Bildrate, wenn ein Spiel speziell auf der Hardware
basiert. Spieler mit schnelleren
Systemen werden sich also
schneller bewegen und Spieler mit langsameren
Systemen werden sich langsamer bewegen. Es ist ein Bug, der in viel mehr Spielen enthalten ist,
als Sie erwarten würden. Bevor wir also
weitermachen und versuchen
, die so genannte
Framerate-Unabhängigkeit zu erreichen , werden
wir vorerst den Rest
unseres Bewegungscodes anpassen vorerst den Rest
unseres Bewegungscodes ,
damit wir mit
allem arbeiten können Im Moment ist es offensichtlich
nicht besonders wichtig,
nur eine Einheit pro
Bild zu bewegen , also werden wir unsere Geschwindigkeit mit einem Wert
multiplizieren wollen können wir ganz
einfach machen. Auch hier ist die Arbeit mit Mathematik innerhalb von Bauplänen
relativ einfach Wir können hier aus unserem Float
ziehen, womit wir multiplizieren
wollen . Ziehe
das in die Grafik. Suchen Sie nach dem Stern, dem Multiplikationssymbol
oder geben Sie Multiplizieren ein, und wir können das
Ergebnis in das Y eingeben. Das bedeutet, dass wir jetzt unsere Bewegungsrichtung
multipliziert mit einer Bewegungsgeschwindigkeit
nehmen , die wir zunächst auf einen
zufälligen Wert wie zehn setzen können,
und das ist unser neuer Offset
, der für und das ist unser neuer Offset jeden einzelnen Frame gilt Wir bewegen uns jetzt also schneller,
aber wir werden immer noch dieses Problem mit der
Unabhängigkeit der Bildrate haben dieses Problem mit der
Unabhängigkeit der Bildrate Wenn ich die
Bildrate ändere, mit der
ich laufe, bewege ich mich jetzt viel schneller. Das macht sich also
noch deutlicher bemerkbar. Ich wollte mich auch hier konzentrieren
. Was ich hier gerade geschaffen habe, ist das, was wir
als magische Zahl bezeichnen. Diese Zahl in diesem Kontext, wenn ich
in ein oder zwei Monaten darauf zurückkomme, werden
Sie wahrscheinlich
vergessen, wofür
diese Zahl genau stand,
ohne den Code noch einmal Sie wahrscheinlich
vergessen, wofür
diese Zahl genau stand,
ohne durchzusehen. Ich stelle dir die Frage,
warum waren es zehn? Warum waren es nicht 100? Warum waren
es nicht 1.000 und so weiter. Um das ein
wenig zu mildern, und noch einmal, indem wir uns auf diese gute
Programmierpraxis konzentrieren und versuchen, unseren Code
von Anfang an sauber zu halten Wir ziehen hier von
dieser grünen Stecknadel ab, und ich mache
etwas, das man in eine Variable hochstufen nennt , und Sie können
hier die Option sehen ,
dies zu einer Variablen heraufzustufen Also werden wir darauf klicken. Auf der linken Seite befinden
sich die Variablen. Wir können uns diesen Namen schnappen und ich werde ihn in
Bewegungsgeschwindigkeit umbenennen. jetzt
zumindest auf einen Blick eine Vorstellung davon, gibt uns jetzt
zumindest auf einen Blick eine Vorstellung davon,
was dieser Wert bewirkt. Das ist also die Geschwindigkeit, mit der
wir uns voraussichtlich bewegen werden, multipliziert mit einer Richtung, die zu unserem aktiven Standort
hinzugefügt wird zu unserem aktiven Standort
hinzugefügt Es fängt an, sich ein
bisschen mehr wie ein Roman auf einer Seite zu lesen , und man bekommt eine Vorstellung davon, was
der Code bewirken wird, auch ohne ihn vollständig zu
untersuchen. Das ist es, was wir mit unserem Code erreichen
wollen , dass er für Menschen lesbar wird Wir haben also unsere
Bewegungsgeschwindigkeit variabel. Wir können hier oben auf Kompilieren klicken, nur um zu
überprüfen, ob hier
die Zahl Zehn
eingetragen ist, weil wir diesen die Zahl Zehn
eingetragen ist, weil wir Wert
bereits
als magische Zahl hatten. Dann zurück zum Fehler mit der
Bildrate. Wir müssen sicherstellen
, dass wir unabhängig von der Geschwindigkeit, mit der unser
System läuft
, von der Geschwindigkeit, mit der unser
System läuft
, dieselbe
Art von Bewegung erhalten. Dabei geht es nicht nur um
das Spielergebnis, sondern als Designer
passen wir bei Entwicklung
unseres Spiels alles
genau an. Wir möchten, dass sich alles so flüssig,
reaktiv und reaktionsschnell
anfühlt ,
wie wir es erwarten würden. Wir stimmen das gesamte Spiel so ab
, dass es auf eine bestimmte Art und Weise gespielt wird. Und das
wird natürlich völlig
ruiniert, wenn
jemand, der es
auf einem System spielt , das doppelt so
schnell ist wie unseres, ein
anderes Ergebnis erzielt Was wir dafür benötigen, sind
sogenannte Delta-Sekunden, manchmal auch Delta genannt einfach die Anzahl
der Sekunden, die seit
dem letzten Frame
vergangen sind Anstatt
diesen Pin hier für
unsere Berechnung zu verwenden ,
weil
er natürlich überlappende Drähte hätte
und damit beginnen würde, er natürlich überlappende Drähte hätte
und damit beginnen würde Spaghetti-Code einzuführen Wir
klicken mit der rechten Maustaste in das Diagramm und
suchen nach Delta-Sekunden Sie können hier sehen,
dass wir die Option
bekommen, Welt-Delta-Sekunden zu bekommen, und wir können das einstecken und nutzen. Ganz einfach, wir
wollen alle
Werte, die
wir hier haben, nehmen und unseren
Delta-Sekunden
multiplizieren. Also nochmal dasselbe. Wir suchen nach
Multiplikation, setzen das ein, setzen die Berechnung
in das Ergebnis ein
und wir kommen dem, was wir wollen,
näher. Erlauben Sie mir nun, schnell zu
demonstrieren, was Delta-Sekunden tatsächlich bewirken und wofür der
Wert steht. Ein wirklich schneller Weg,
das zu tun. Ich möchte eine gedruckte Zeichenfolge einfügen,
wie wir sie schon einmal gesehen haben. Ich setze das
für die Dauer auf Null, schnappe mir den Delta-Sekunden-Knoten, dupliziere das, schließe das an, damit wir
sehen können, was gedruckt wird. Bei meinen 300 FPS
werden wir diese Zahl nicht verwenden, also werde ich sie wieder auf 120 begrenzen
. Bei 120 FPS erhalten wir
zwischen den einzelnen Frames
einen Wert von etwa 0,008 Sekunden Wenn ich den Wert wieder auf 60 herabsetze, werden
wir sehen, dass er auf
0,016 sinkt Und wenn wir den Wert weiter
auf 30 senken, erhalten
wir
eine Zahl von 0,033. Also ungefähr, nicht genau,
aber jedes Mal, wenn wir die Bildrate um die Hälfte reduzieren, ungefähr die Hälfte der
Zahl Und hier erfahren Sie, wie das
nützlich ist und wie unsere Probleme
behebt, die von der Bildrate
abhängen. Wenn du mit 30 FPS arbeitest, bewegt dich
jeder Frame weiter, aber das sind größere Schritte, aber du machst weniger
Schritte pro Sekunde. Bei 120 FPS hingegen bewegt dich
jeder Frame weniger. Das sind kleinere
Schritte, aber du machst dabei viermal so
viele Schritte. Und am Ende
bleibt die Gesamtdistanz pro Sekunde
ungefähr gleich. Und das unabhängig davon, ob Sie mit 30 FPS oder 120 FPS
laufen. Wir sind unabhängig von der Bildrate, und das ist der Unterschied
zwischen einem Spiel, das sich auf jeder Hardware fair anfühlt, Spielern, die auf Systemen der
höheren oder niedrigeren Preisklasse
unterschiedliche Erfahrungen machen. Eines ist zu beachten: Da
wir jetzt
unsere Werte mit dieser
unglaublich kleinen Zahl multiplizieren , wird
sich
die Geschwindigkeit,
mit der wir uns bewegen, offensichtlich viel langsamer,
sehr träge und fast
nicht spürbar anfühlen sehr träge und fast Also müssen wir reinkommen und das bei
der Bewegungsgeschwindigkeit
berücksichtigen Ich werde das auf etwa 500 statt auf zehn erhöhen , auf Kompilieren und Abspielen
klicken, Kompilieren und Abspielen
klicken, und es wird sich
ungefähr genauso anfühlen. Die Hauptsache ist wiederum, dass wir es hier mit einem
I Jump von 30-120 FBS zu
tun haben I Jump von 30-120 FBS Es sieht flüssiger aus, aber wir werden nicht merklich schneller Der einzige Unterschied, den
wir sehen, ist wie geschmeidig sich die Bewegung aufgrund der
Bildrate
anfühlt, die wir uns
ansehen . Das ist also
wirklich das Ziel hier. Damit funktioniert die
Bewegung also. Wir haben das
Framework-Problem behoben, aber es ist wirklich nicht
ganz ausgefeilt. Wir können feststellen, dass es ziemlich
bissig ist, wenn wir es bewegen. Wenn wir eine Richtung drücken, sind wir
sofort auf voller Geschwindigkeit. Sobald wir loslassen,
werden wir sofort gestoppt. Es gibt keine Beschleunigung,
kein Momentum. Echte Fahrzeuge
funktionieren so nicht. Sogar unsere gutmütigen Fahrzeuge werden ein gewisses Gewicht
haben, also müssen wir darüber nachdenken, eine sanfte Beschleunigung hinzuzufügen sanfte Beschleunigung Und dieser ganze Ansatz, den
wir im Moment verfolgen, der Standort des
Drehbuchauspielers Dabei hat jedes Bild
keine physikalische Integration, keine richtige Kollisionsreaktion,
und das ist völlig in Ordnung. Aus diesem Grund wird es
in den Inhaltsbeispielen von Epics bereitgestellt. Das Muster funktioniert
, weil es einfach ist, nicht weil es sich dabei um eine bewährte Methode handelt Wir haben also Bewegungen.
Wir verstehen den Framework-Bug, den wir
hatten, und wissen, wie wir ihn beheben können, und wir wissen, warum dieser Ansatz
weit verbreitet ist und warum er nicht ideal ist. Als Nächstes werden wir die Websites verschieben. Wir fügen etwas Beschleunigung und
Rotation-Banking-Funktion hinzu, wobei wir generell
auf etwas abzielen , das sich eher
wie ein Flugzeug anfühlt. Wenn Sie experimentieren möchten
, können Sie jederzeit versuchen, vertikale Bewegungen
hinzuzufügen Es ist das gleiche Muster. Verwenden Sie einfach die andere Achse, die X-Achse anstelle
der Y-Achse, oder fügen Sie sie hinzu. Wahrscheinlich müssen Sie auch eine neue Eingabebindung
einführen , ein kleiner Tipp dazu.
7. 06 - Sanfte Bewegung: Moment, unsere Bewegung funktioniert
technisch, fühlt sich
aber sehr roboterhaft Sofortiger Start, sofortiger Stopp. Wir werden uns in
diesem Video damit befassen, indem etwas Beschleunigung und
Drehung hinzufügen, sodass es sich anfühlt, als ob Sie tatsächlich ein
Arcade-Flugzeug
fliegen. Wir werden eine
sogenannte Interpolation verwenden, die Glättung
zwischen zwei Punkten im Laufe der Zeit handelt Dies wird auch der
nächste Schritt sein, um die Fehler in
den epischen
offiziellen Lerninhalten zu übernehmen Fehler in
den epischen
offiziellen Lerninhalten Wir werden es finden, wir werden es
bestätigen und wir werden es
etwas später beheben Im Moment besteht das Problem also
darin, dass unsere Geschwindigkeit direkt aus der Eingabe
übernommen wird. Genau hier haben wir die Bewegung nach rechts
multipliziert mit der Bewegungsgeschwindigkeit Wenn wir also nach rechts drücken, ist
das eins multipliziert mit 500. Wir gehen direkt zur
Geschwindigkeit von 500 Einheiten pro Bild über. Wenn wir
nach links drücken, ist das minus eins multipliziert mit 500, also bekommen wir minus 500 direkt
auf unsere Bewegungsgeschwindigkeit angewendet
wird Deshalb bekommen wir den
Sofortstart und den sofortigen Stopp. Sobald wir eine Taste loslassen, multiplizieren wir
den Wert natürlich mit Null,
sodass wir eine Bewegungsgeschwindigkeit von 500 bis 0 erreichen Für eine reibungslose Bewegung benötigen wir zwei verschiedene Werte Wir wollen eine Zielgeschwindigkeit
, wo wir sein
wollen, und wir brauchen unsere aktuelle Geschwindigkeit,
in der wir uns gerade befinden. Oder sie nutzen diese, um
schrittweise zwischen unserer aktuellen Geschwindigkeit und
unserer Zielgeschwindigkeit zu wechseln. Zu Beginn können wir
ganz einfach
einen neuen Float oder die aktuelle
Geschwindigkeit, die wir verfolgen
werden, erstellen einen neuen Float oder die aktuelle . Wir können unsere
Bewegungsgeschwindigkeit hier abrufen, mit der rechten Maustaste darauf klicken oder die
Strg-Taste in D drücken, um sie zu duplizieren. Wir nennen das
aktuelle Geschwindigkeit. Und wir nehmen diesen Wert
, den
wir gerade hier berechnen, also im Wesentlichen unsere Bewegungsgeschwindigkeit, und das wird das Ziel sein, das wir etwas später verwenden werden. Wenn wir das aufräumen wollten, könnten
wir es definitiv visuell lesbarer
machen Wenn ich das verschiebe, können wir diese Berechnung einfach hier
abrufen Ich drücke die
Strg-Taste in X, um das auszuschneiden, Strg-Taste in V, um es oben einzufügen Wir ziehen daraus hier und wir werden es
zu einer neuen Variablen heraufstufen. Wir werden diesen Wert
auf etwas
heraufstufen , das wir Zielgeschwindigkeit nennen. Und wir können
das einfach hier anschließen. Sie werden gleich sehen, warum das momentan nicht wirklich
etwas ändert, aber es wird die Dinge nur
ein bisschen lesbarer machen. nicht nur daran, Dinge zu
verstecken, damit
wir etwas
mehr Platz zum Arbeiten haben, sondern denken
Sie auch daran, dass wir unsere Zielgeschwindigkeit, die
wir gerade berechnen,
neu einstellen müssen unsere Zielgeschwindigkeit, die
wir gerade berechnen,
neu Der einzige Unterschied besteht darin
, dass wir diesem Pin im Grunde einen Namen
gegeben haben diesem Pin im Grunde einen Namen
gegeben Also nochmal, es ist nur ein
bisschen besser lesbar. Wir werden
unsere Zielgeschwindigkeit erreichen. Und wenn wir
das einfach direkt auf
den Y-Flow-Pin fallen lassen , der jetzt freigelegt
ist , wird er automatisch
für uns angeschlossen. Etwas,
das Sie
mich auch ziemlich oft tun sehen werden , ist das, was ich gerade dort
getan habe. Also diese Pins, wir
, die Drähte schwebten
ein bisschen herum. Wenn Sie sich ein paar Knoten schnappen, drücken Sie auf einen Hinweis,
der die Drähte
automatisch für Sie ausrichtet. So können wir die Dinge unterwegs
etwas aufgeräumter halten. Eine weitere Sache, die nützlich
ist, ist, dass, wenn Sie zum Beispiel den
Mauszeiger gerade
hier über den Stift bewegen
und einen Cue drücken, ohne die Noten
tatsächlich zu erfassen, der Knoten, der verbunden ist
, genommen und
diese ebenfalls in einer Reihe angeordnet Also nichts, was Sie
unbedingt tun müssen, aber ich erwähne
es nur, weil ich weiß, dass ich das mit dem Muskelgedächtnis mache, also mache ich das manchmal, während
ich rede Und ich wollte nur,
dass du weißt, welche Abkürzungen ich verwende. Okay, also zurück
zum Hauptthema. Wir wollen diese Bewegung mit einer
Float-Interpolation
glätten Wenn wir hier mit der rechten Maustaste in das
Ereignisdiagramm klicken, suchen
wir nach F-Interp Dies ist eine Float-basierte
Interpolation auf einen bestimmten Wert. Wir können hier ein paar
Dinge sehen, die gegeben wurden. Wir beginnen also mit
unserem aktuellen Wert, der
, wie ich bereits erwähnt habe, dort ist,
wo wir uns jetzt befinden. Das Ziel ist, wo wir
sein wollen , um diese direkt auszufüllen. Wir haben diese Werte bereits und sie sind entsprechend benannt. Also können wir unsere aktuelle Geschwindigkeit und sie
hier auf den aktuellen Stand bringen. Wir werden also
von unserer aktuellen Geschwindigkeit ausgehen und unsere Zielgeschwindigkeit erreichen. Also ziehen wir das auch einfach per
Drag-and-Drop rein. Sie können sehen, dass wir dann
die Delta-Zeit einstecken müssen. Wir haben hier also die
Delta-Sekunden. Ich wähle diese aus, drücke die
Strg-Taste, ja, duplizieren mit der
Maus hier unten, und wir können das
in die Delta-Sekunden einstecken. Die Delta-Zeit hier hält die Bildrate der E-Interpolation unabhängig,
mit einigen Macken Aber noch einmal, wir werden darauf
zurückkommen, wenn wir das Problem sehen , und wir werden es später
angehen Und dann
haben wir endlich das Interp, das steuert, wie
schnell wir
auf die Zielgeschwindigkeit beschleunigen , die uns gegeben wurde Höhere Werte bedeuten hier
eine schnellere Reaktion. Niedrigere Werte bedeuten, dass es sich
etwas flüssiger anfühlt. Ich werde mit
dem Wert von vier beginnen, was beim Testen
einwandfrei funktioniert hat Und dann wollen wir natürlich
keine magischen Zahlen in unserem Code haben. Also
werden wir von hier aus weitermachen. Wir werden
das zu einer Variablen heraufstufen. Ich gebe diesem
einen vernünftigen Namen etwa Bewegung,
Interpretation, Geschwindigkeit. Wir haben jetzt also die
vier F-Interp zwei. Das Ergebnis dieser
Interpollation
wird unser neuer
aktueller Sehr wichtig hier.
Wir müssen uns
etwas mehr Platz einräumen. Ich werde die
Druckzeichenfolge hier entfernen. werden wir nicht mehr
brauchen, und wir werden das gleich
hier drüben für neun weitermachen. Wir werden
jeden Spaghetticode vermeiden
und für
Ordnung sorgen, während wir gehen Das muss hier oben
berechnet werden. Wir brauchen zuerst unsere Zielgeschwindigkeit, also den Wert, von dem wir wissen, dass
wir ihn erreichen werden. Und das müssen wir jetzt auch festlegen. Verwenden Sie also einen Knoten
wie diesen,
der den Wert unserer aktuellen Geschwindigkeit festlegt . Ich glaube, dass ich noch nicht
behandelt habe , ist, dass wir
alternative Möglichkeiten haben , unsere
Variablen in das Diagramm einzubeziehen. Wenn wir die Steuertaste
auf der Tastatur gedrückt halten und
zum Beispiel die
aktuelle Geschwindigkeit erfassen und
diese in das Diagramm ziehen ,
entsteht ein Knoten. Dieser schlanke Knoten wird Getter
genannt. Er bietet im Grunde den
Wert. Wir können das lesen. Es macht sich für uns bezahlt. Wenn wir Alt gedrückt halten und
das Gleiche noch einmal machen, nehmen wir die aktuelle Geschwindigkeit und ziehen sie in
das Diagramm, halten
aber jetzt Alt gedrückt. Dadurch wird ein
sogenannter Setter bereitgestellt . Das
ist also das Gegenteil Dadurch können wir in
den Wert schreiben, den wir hier haben. Das ermöglicht uns also, den Wert
zu lesen. Dadurch können wir in den Wert
schreiben. Wir wollen die beschreibbare Version hier
auf der aktuellen Geschwindigkeit
belassen, also werde ich die Getter
loswerden Und wir wollen
unseren Wert hier einbringen. Wie ich gerade gesagt
habe, wird unsere aktuelle
Geschwindigkeit so gemessen. Also werden wir das an die aktuelle Geschwindigkeit anpassen
und müssen nur
sicherstellen, dass wir die Execution-Pins genau hier anschließen . Und nur um zu versuchen, das
zusammenzufassen und sicherzustellen, dass es Sinn macht, denn ich weiß, dass das ein
bisschen verwirrend aussehen
könnte. Wir müssen
zuallererst wissen, worauf wir drücken und welche Geschwindigkeit
wir erreichen wollen, weshalb wir derzeit zuerst die Zielgeschwindigkeit
festlegen. Wenn wir uns dann vorstellen, dass wir das vom allerersten Bild an
berechnen, wissen
wir jetzt schon, dass unsere
Zielgeschwindigkeit Bewegung multipliziert mit oder genauer gesagt unsere
Richtung mit Bewegungsgeschwindigkeit, multipliziert mit Delta, also erhalten
wir einen Wert von 500 multipliziert mit dem, was auch immer unser kleiner Wert
auf der Bildrate basiert. Wir müssen also ein klares
Ziel erreichen. wir das zum ersten Mal
ausführen, wird die
aktuelle Geschwindigkeit
wahrscheinlich Null sein. Wir gehen also von
unserer aktuellen Geschwindigkeit von Null aus, also bewegen wir uns
überhaupt nicht, also
sagen wir einfach 100 Bewegungseinheiten, um
eine schöne, klare Zahl zu erhalten. Wir werden wieder die
Zeit von Dw berücksichtigen ,
um diesen Frame quasi
unabhängig zu halten,
und wir haben unsere Bewegungsgeschwindigkeit, die
Interplationsbewegungsgeschwindigkeit, um hier ein unterschiedliches Maß an
Glättung zu erzielen Dann wäre die
aktuelle Geschwindigkeit im nächsten Frame natürlich auf dieser Grundlage berechnet
worden , um etwas höher
zu sein Also gehen wir von
dieser etwas höheren Geschwindigkeit aus. Sagen wir einfach zwei oder drei, und dann gehen wir
von diesen zwei oder drei Werten aus und versuchen
immer noch, die 100
Geschwindigkeitseinheiten zu erreichen , die
wir erreichen müssen. Und wir werden das im Laufe der Zeit kontinuierlich tun,
was für
diese Glättung
sorgen wird Die letzte Sache ist also, dass wir die
Zielgeschwindigkeit nicht direkt verwenden
wollen Das ist nur unsere, wir wollen die
Geschwindigkeit verwenden, die gerade ist. Also werden wir diesen löschen. Wir nehmen
unser aktuelles Tempo an. Und wieder ziehen wir das einfach auf unseren grünen Stift hier, und das wird uns automatisch
verbinden. Und das war's. Das ist so
ziemlich bereit, um die reibungslose Bewegung zu testen. Sie können hier also sehen, wie ich mich hin und her
bewege, in dem Moment, in dem ich die Taste
loslasse, ein
wenig Glättung stattfindet, während wir
auf gar keine Geschwindigkeit herunterfahren Hier kommen also etwas Verlangsamung und Beschleunigung rein Da wir das im Laufe der Zeit
tun, fühlt sich
die Bewegung vielleicht
etwas langsamer Eines der anderen wirklich
nützlichen Dinge bei der Umwandlung
unserer magischen Zahlen in Variablen
ist, dass ich einfach
die Bewegungsgeschwindigkeit erfassen kann Ich kann das vielleicht verdoppeln, also setzen
wir es einfach auf 1.000 , weil es sich
ein bisschen langsam anfühlt. Ich musste den Code nicht
durchgehen. Ich musste nicht herausfinden,
wo das passiert ist. Das ist wirklich gut benannt,
also weiß ich, dass es die Geschwindigkeit
kontrolliert
, mit der ich mich bewegen werde. Ich kann Play drücken. Ich
kann das noch einmal testen und wir haben ein völlig anderes
Gefühl als das Flugzeug. Das fühlt sich also viel
besser an. Das übertreibt die Beschleunigung und Verzögerung wirklich ein bisschen mehr Und wieder wurde all das getan, eine komplette Eigenschaft
des gesamten
Bewegungssystems zu
ändern ,
indem einfach die Bewegungsgeschwindigkeit erfasst
und hier eingegeben wurde. Natürlich haben wir
die reibungslose Bewegung hinzugefügt, weshalb wir diese Änderung vornehmen
mussten Wenn Sie
mit Dingen herumspielen möchten , könnten Sie etwas Ähnliches
tun, sich die
Interpolationsgeschwindigkeit der Bewegung ansehen und schauen, ob Sie möchten , dass es mehr oder weniger Zeit braucht,
bis der endgültige Wert erreicht ist, die aktuelle Geschwindigkeit,
die wir Es handelt sich
hier also nur
um variable Anpassungen , die darauf basieren, wie
Ihr Spiel, Ihr Flugzeug gefüllt werden soll Ein Designprinzip, von dem ich
schon sehr früh gehört habe und das mir
immer in Erinnerung geblieben ist, ist der
Versuch, die Variablen immer zu übertreiben Wenn Sie sich also nicht sicher sind, was
sie tun, oder wenn Sie sich
nicht sicher sind , ob Sie möchten,
dass es viel
schneller oder viel langsamer ist, ist das Doppelte oder Dreifache des
Werts, an dem Sie arbeiten Ich könnte diesen Wert auf 4-12 setzen weil Sie zuerst
ein Extrem erreichen möchten, herausfinden möchten, ob das funktioniert,
ob es zu hoch oder zu
niedrig ist, und es dann zwischendurch
verfeinern Ich kann also sehen, dass sich das fast wieder ziemlich bissig
anfühlt. Es gibt eine gewisse Beschleunigung und Verzögerung, aber nicht Also vielleicht möchte
ich das wieder sechs
reduzieren, weil 12 definitiv zu hoch
ist und wir uns hier ein
bisschen besser fühlen Nun, wie gesagt, mir gefällt das Gefühl
bei vier sehr gut, aber ein allgemeines
Designprinzip
besteht darin, den Wert
auf ein Extrem zu bringen, das
Doppelte, Dreifache, Halbe,
was auch immer der Fall sein mag, und Sie werden ziemlich schnell in der Lage
sein, sich
darauf zu konzentrieren , wie sich Ihre
Immobilie anfühlen soll. Für meine Zwecke werde ich Interp-Geschwindigkeit der Bewegung bei vier belassen,
damit wir mit dem nächsten Feature
weitermachen können Fügen wir nun die
Bankrotation hinzu. Das wird eigentlich sehr
einfach sein. Es ist im Wesentlichen eine Wiederholung
dessen, was wir gerade mit einigen leicht
unterschiedlichen Funktionen
gemacht haben. Im Grunde wollen wir, dass das Flugzeug, wenn
wir uns von Seite zu Seite
bewegen ,
ein wenig geneigt wird, damit es sich ein bisschen mehr
wie ein echtes Flugzeug anfühlt. Eine kurze
Auffrischung der Achse hier. Ich glaube nicht, dass ich
das im Herbst noch angefasst habe. Ich werde mir ganz schnell ein
statisches Netz schnappen. Ich muss nicht mitmachen. Das ist nur, um zu visualisieren
, was wir tun. Ich drücke E innerhalb des Ansichtspunkts, um
in
den Rotationsmodus zu wechseln,
und wir können unsere Achsen hier Ansichtspunkts, um
in
den Rotationsmodus zu wechseln, sehen Ich habe bereits erwähnt, wir diese Transformation haben,
die Position, Rotation und Skalierung, die
die Position unseres Schauspielers
im Weltraum ausmachen.
Die Standorte sind sehr einfach Wir haben X, Y und Z, was vorwärts, seitwärts und rauf
und runter bedeutet Rotation, das ist
relativ einfach. Das Gleiche. Wir
haben drei Farben. Wir haben das Rot, das Grün und das Blau, also das
X, das Y und das Z. Aber wenn wir mit der Maus darüber
fahren, können wir
hier sehen, dass sie tatsächlich
ihre eigenen eindeutigen Namen haben Wir haben das Roll, das
Pitch und das Le. Nun, das ist nicht allzu
wichtig, aber wenn Sie jemals versuchen, diese Funktionen
zu optimieren, fügen Sie Ihre eigene Funktionalität hinzu
und Sie sind sich nicht einmal
sicher, welche Achsen ich
drehen oder um welche Achse ich drehen soll Ich wollte
dir
hier nur ein kleines Bild zeigen , das
eigentlich ganz einfach herauszufinden In diesem Fall
möchte ich also, dass sich das Flugzeug in eine Richtung
neigt, die davon
abhängt, wie es sich bewegt. Wenn ich also nur ein
paar Dinge nach dem Zufallsprinzip ausprobiere, wenn ich das grüne Modell ausprobiere
und sehe, was das bewirkt, können
wir den grünen
Wert hier drüben nehmen und ich schiebe ihn einfach
, damit er sich dreht. Und wir können sehen, dass wir
dadurch eine Art - und Abwärtsdrehung
des Flugzeugs haben. Das wäre wahrscheinlich gut, wenn Sie sich
vorwärts und rückwärts bewegen Sie könnten vielleicht ein
bisschen davon hinzufügen, um die Bewegung des Vorwärts- und
Rückwärtsgehens zu übertreiben Wenn ich das Z nehme und dasselbe
mache,
ich schnappe mir nur die, von
denen ich weiß, dass sie nicht funktionieren, und sie aus dem Weg
räumen Wir können sehen, dass es sich
um die Achsen des Flugzeugs dreht. Also nochmal, es wird
nicht sehr nützlich sein es sei denn, wir machen vier
Töne oder so. Also die, die
wir verwenden wollen,
wird hier die X-Achse sein. Wenn wir uns also
nach links und rechts bewegen, werden
wir je nach der Richtung, in die wir uns bewegen, leicht neigen
und einfach so
rollen wollen . So können Sie also
ganz einfach reinkommen, den
verschiedenen Widgets hier
herumspielen, in eine bestimmte
Richtung
drehen und sehen, welche Achse Sie die Drehung
anwenden möchten. Wie gesagt, das war nur
zur visuellen Demonstration. Ich lösche das statische Netz. Wir gehen zurück in den Pfannenboden. das ein
bisschen verschieben, können wir mit der Rotation
weitermachen. Für die Rotation haben wir hier ein paar sehr ähnliche
Funktionen, die wir bereits verwendet haben. Wir werden vom Standort
des Drehbuchauspielers abfragen, und Sie können sich wahrscheinlich vorstellen, dass wir nach etwas
suchen werden, Drehbuchstaben-Rotation
bezeichnet wird. Das ist eine sehr ähnliche Sache,
Aktualisierungen der Rotation, und das wird
jedes einzelne Bild sein weil wir
es auf die Eventi werfen Nun wollen wir auch
eine sehr ähnliche Funktion verwenden , wir wollen dafür eine
Interpolation verwenden Für die Rotation
verwenden wir nicht den F-Interpret, sondern
etwas, das als
Interpret Two bezeichnet wird . Also klicken wir hier mit der
rechten Maustaste. Suchen Sie nach Interp zwei, y nach Rotation, und wir
nehmen das hier. Der andere Grund, warum wir es auf diese Weise
machen, dass
wir möglicherweise
nur einen einzigen
Gleitkommawert verwenden könnten , weil wir das nur auf dem X
machen wollen. Wir könnten
hier etwas sehr Ähnliches tun und einen F-Interpret verwenden Ich werde das nun Zeile für
Zeile mit
dem Unreal Engine-Projekt mit den
Inhaltsbeispielen vergleichen Also genau
so haben sie es gemacht. Sie haben einen F-Interpret für
die Position und einen
R-Interpret für die Rotation verwendet . Also wollte ich noch einmal zeigen,
welchen Code es gibt
und wie wir ihn reparieren können, nur für den
Fall, dass und wie wir ihn reparieren können, nur Fragen auftauchen, warum wir das
etwas anders machen. Aber das Wichtigste dabei ist, dies
immer noch sehr nützlich ist, weil wir sehen können, dass wir
dieselben Eigenschaften erhalten , die
wir einspeisen müssen. Wir haben eine aktuelle Rotation, also wo wir uns gerade befinden, haben
wir eine Zielrotation zu der wir rotieren wollen. Und wir haben die Delta-Zeit,
um diese
Bildrate
wieder gewissermaßen unabhängig zu machen. Und dann haben wir
die Interp-Geschwindigkeit, die Glättung zwischen den beiden Aktuell ist also
eigentlich ganz einfach. Wir haben einen weiteren
sehr ähnlichen Helfer wie den, den wir zuvor verwendet haben. Wenn wir mit der rechten Maustaste
in das Event-Diagramm klicken und nach Get
actor Rotation suchen. Dadurch wird, wie bei der von uns verwendeten Option zum Abrufen des
Schauspielers, die Rotation des Schauspielers
in diesem bestimmten Frame angezeigt. Das Ziel ist eine
zufällige, willkürliche Zahl, und ich sage das nur, weil
das epische Beispiel genommen
hat,
also werde ich
die aktuelle Geschwindigkeit kontrollieren und die
aktuelle Geschwindigkeit in das Diagramm ziehen, um die aktuelle Geschwindigkeit zu der wir uns
bewegen, und
diese mit einem Wert multiplizieren. Also ziehen wir von
hier aus und wählen Multiplizieren. Und ich glaube, ihre waren
etwa 1,5. Also nehmen
wir die Geschwindigkeit, mit der wir uns bewegen, egal ob das ein positiver
oder ein negativer Wert ist, multiplizieren das mit 1,5 Und das wird das
Ziel sein, zu dem wir uns auf der X-Achse
drehen wollen . Etwas, das ich
dir vorstellen wollte. Das haben wir hier schon gesehen. Die Verwendung des
Split-Struktur-Pins, um unseren Drei-Punkt-Vektor in
seine einzelnen Fließkommazahlen umzuwandeln . Der Rotator ist genau derselbe. Wir könnten einfach mit der rechten Maustaste auf den
Split-Struktur-Pin klicken und
diesen in X, Y und Z übernehmen. Das kann etwas
chaotisch werden, wenn
man insgesamt so viele verschiedene
Floats Eine Sache, die sehr nützlich sein
kann, und vor allem, das dient wirklich nur der
Ordnung im Code, ist, dass wir hier vom Ziel ziehen und nach
etwas suchen,
das Make-Rotator genannt
wird etwas Wir wollen diese unterste
Option genau hier haben, und sie tut genau das, was
der Name schon Es macht aus einem einzelnen X, Y und Z
einen Rotator. Es hält diese beiden Floats quasi von selbst,
sodass sie leichter zu lesen sind,
und es ermöglicht uns, unseren Wert hier einfach in das X einzufügen,
nur auf eine andere Art und Weise, zum gleichen Ziel zu
gelangen , wie
wir es zuvor getan haben Keiner von ihnen ist
weniger oder effizienter, und es kann tatsächlich darauf ankommen,
was
in einem bestimmten Fall besser lesbar ist Ich würde nicht sagen, dass
das zu unlesbar ist, denn es ist nur ein Vektor , den wir aufgeteilt haben. Wo ist das? Es gibt bereits
ein paar Floats, und das Aufteilen weiterer
Floats in diese wurde
nur ein bisschen Wie wir
bereits gesehen haben, wollen wir, dass unser Endergebnis die
neue Rotation ist, die wir hier haben, also nehme ich
diese Interpolation
und setze sie in das neue Ergebnis ein. Und dann müssen wir nur noch
ein paar Dinge erledigen. Also wir wollen unsere Delta-Zeit, also werde
ich herkommen eine
Welt-Delta-Sekunde holen, Control ID hier drüben
drücken, um das zu duplizieren, und das einstecken. Und dann brauchen wir nur noch
unsere Interpolationsgeschwindigkeit. Also nochmal, das
bewegt sich dazwischen. Ich teste, ich denke, ein Wert von etwa zehn
hat sehr gut funktioniert, und das ist einer dieser Werte, die
Sie einfach
anpassen werden , damit sich die Rotation genau so
anfühlt, wie Sie es möchten Auch hier gibt es keine magischen Zahlen, also ziehen wir von hier aus und
bewerben eine Variable Geben Sie diesem den Namen
Rotation Interp Speed. Und damit sind wir so
gut wie bereit , das testen zu lassen Obwohl mir eine Sache
einfach aufgefallen ist. Das ist im Grunde genommen ein Tilt-Faktor oder eine Tilt-Stärke, anstatt auch noch diese
magische Zahl zu haben. Wir ziehen von hier aus, von der
Ferne zur Variablen. Ich nehme einfach den Tilt-Faktor, und der ist jetzt
tatsächlich bereit zum Testen. Also können wir auf
Kompilieren klicken, Play drücken und wir können sehen,
dass wir etwas Bankgeschäfte haben. Jetzt haben wir ein weiteres
Problem, von dem ich völlig vergessen
habe, dass es passieren würde. Wir werden das gleich beheben, aber das Bankwesen, die
Rotation funktioniert in der Tat. Jetzt, wo ich möglicherweise allen Reisekrankheit
gegeben habe , sich
die Kamera
mit dem Flugzeug Zumindest das haben
wir bestätigt. Der Grund für
Kameraprobleme ist, dass die Kamera die
Drehung vom Elternteil erbt Wir haben das wirklich
in der Hierarchie gesehen. Die Kameras sind
an der Feder befestigt, der Federarm am statischen Netz,
und diese verfolgen
die der Federarm am statischen Netz,
und diese verfolgen
die gesamte
Rotation und Position, die auf die statische Maische
angewendet wird.
Das ist wirklich einfach zu beheben Und einer der Gründe, warum ich die Feder verwenden
wollte, ist, ich vergessen habe, dies mit der im Detailbereich
auf der rechten Seite
ausgewählten Feder um anzukreuzen im Detailbereich
auf der rechten Seite
ausgewählten Diese einzigartige Komponente
bietet uns eine Lösung. Epic wusste, dass so etwas ein potenzielles Problem sein
würde. Also haben sie uns hier
einige Kästchen angekreuzt. Wir können die Option „
Tonhöhe“, „U“ und „Rotation übernehmen“ deaktivieren. Merken Sie sich die Namen für
X, Y und Z der Rotation. Wenn wir diese Häkchen entfernen,
bedeutet das im Grunde, dass der
Federarm
nicht der Drehung
der
übergeordneten Komponente folgen darf Drehung
der
übergeordneten Komponente Und weil die Kamera ein
untergeordnetes Element des Federarms ist, gilt
das auch für die untergeordnete Komponente
der Kamera Wenn wir also auf
Compile klicken und Play drücken, können
wir reingehen und sehen, dass wir die Rotation gut sehen
können. Und wir bekommen nicht diese
potenziell ekelerregende
Kamerabewegung , die wir noch vor einem Moment
hatten eine Sache, die mir gerade klar wurde die Quelle ausgewählt hatte, als
ich die Quelle ausgewählt hatte,
ich hatte sie auch immer noch angekreuzt. Führen Sie einen Kollisionstest Wenn Sie ein Problem damit hatten, dass
sich die Kamera zu bewegen
scheint oder in den
Boden
geschoben wurde oder so, liegt das möglicherweise
daran, dass der Kollisionstest gerade stattfindet Was passiert hier,
nur um das zu visualisieren? Wenn etwas
zwischen der Kamera und dem Objekt,
das sie hier betrachtet, erkannt wird , also etwas mit einer
Kollision
an dieser Stelle
im roten Federarm
, dann an dieser Stelle
im roten Federarm
, findet dort der
Kollisionstest statt. Wenn etwas durch diesen Bereich hindurchgeht
, wird die
Kamera
versuchen, automatisch aus
dem Weg zu gehen oder sich hinter etwas zurückzuziehen ,
um diese Kollision zu vermeiden. Wirklich nützlich für Dinge wie Spiele in der
dritten Person, bei denen die Kamera möglicherweise gegen eine Wand fährt und sie
dem Spieler ein
bisschen näher kommt . Das ist also ein
ziemlich nettes Feature In einem Spiel wie einem Shooting them up, wie wir es gerade erstellen, können
wir allerdings Probleme haben,
bei denen die Kamera aussieht, wenn Projektile
oder Spuren und
ähnliches durch die
Kamera, die Kameralinie oder Spuren und
ähnliches , hindurchgehen Und wieder ist das
etwas anderes, das man bei
Anfängerprojekten sieht ,
bei denen die Kamera
irgendwie zuckt oder flackert Das
liegt wahrscheinlich daran, dass der Kamera
und dem, was Sie gerade sehen, ein Kollisionstest zwischen der Kamera
und dem, was Sie gerade sehen, ein Kollisionstest
stattfindet Also werden wir das ausschalten. Das werden wir für
diese Art von Spiel nicht brauchen. Wenn das erledigt ist, bleibt die
Kamera waagerecht. Das Flugzeug landet natürlich,
fühlt sich viel besser an. Jetzt können wir uns
endlich ansehen, wo das Beispiel von
Epic ein wenig
zusammenbricht. Ich wollte nur erwähnen, dass
dies kein Schatten
auf das Beispielprojekt oder
Epic oder ähnliches geworfen wird . Ich spreche das nur an
, weil ich weiß, dass dies eine perfekte
Unterrichtsmöglichkeit ist,
etwas, das
so umfassend behandelt wird von so vielen verschiedenen
Tutorial-Kanälen
genutzt
wird, ich eingeschlossen, dass Sie Code sehen werden, selbst aus
offiziellen Quellen kaputt
ist. Das zu wissen und
darauf
achten zu können, wird also sehr wertvoll
sein. Das Problem, das wir
im Moment haben, ist also , ob wir in den Spielmodus
gehen. Bei hoher Bildrate werde ich meine Framerate-Statistiken wieder Also 120 FPS, das
sieht irgendwie okay aus. Wenn ich das aber wieder
auf 30 FPS
reduziere, konzentriere dich darauf, wie stark die
Rotation angewendet wird. Auch hier können Sie sehen, dass es nicht nur darum geht, dass einer von
ihnen aufgrund
der Bildrate etwas glatter und einer von
ihnen
etwas weniger glatt aussieht glatter und einer von
ihnen
etwas weniger glatt Das ist buchstäblich ein
Unterschied in der Mechanik,
derselbe Code, gleiche Eingabe,
völlig unterschiedliche Bei 30 FPS
drehen wir den Flügel fast durch den Boden,
je nachdem, wie weit
das Flugzeug vom Boden entfernt ist Und das ist eines dieser Dinge. Es macht nicht einmal das Gameplay kaputt. Aber wenn Sie ein
System so eingerichtet haben, dass es super flüssig aussieht und es genau so aussieht, wie Sie es
möchten, um für
den Spieler am ansprechendsten zu sein , aber
dann spielt jemand mit
einem System mit niedrigeren Spezifikationen und wird mit
dem zweiten Ergebnis begrüßt Sie werden offensichtlich enttäuscht sein
, denn sie bekommen nicht das
Spielerlebnis, das Sie Und deshalb ist es
wirklich wichtig, sich darauf zu konzentrieren. Und das
meinte ich damit, dass dieser Fehler in den offiziellen
Inhaltsbeispielen von Epics
existiert, derselbe Code, dasselbe Problem, der
in der eigentlichen Dokumentation Und aus diesem Grund kann es Fehler haben,
selbst offiziellen Beispielen blind zu vertrauen,
selbst wenn man der ersten
Frömmigkeitsdokumentation Testen Sie also immer Grenzfälle und achten Sie auf solche
Dinge Das
versuche ich wirklich zu vermitteln. Ich habe bereits erwähnt, dass
es
für dieses eine Thema
etwas zu lang sein wird. Wir werden das also etwas später
korrigieren
und das Bewegungssystem komplett neu aufbauen Aber vorerst werden wir nur
anerkennen, dass der Fehler existiert Es ist immer noch völlig
in Ordnung, damit zu arbeiten. Es ist eine perfekte Grundlage
für den weiteren Aufbau. Wir kommen zurück und
werden
das Bewegungssystem komplett überarbeiten,
und wir werden alle
Fehler beheben, wenn wir damit das Bewegungssystem komplett überarbeiten, fertig Und jetzt, wo wir gesehen
haben, wie es sich lohnt, keine
magischen Zahlen zu verwenden , haben wir
unsere Bewegungsgeschwindigkeit, steuert, wie schnell Sie fliegen können, die
Bewegungsinterp-Geschwindigkeit, die angibt,
wie schnell Sie diese Geschwindigkeit
erreichen, unseren Neigungsfaktor, der angibt, wie stark das
Flugzeug bei den
verschiedenen Geschwindigkeiten die
steuert, wie schnell Sie fliegen können, die
Bewegungsinterp-Geschwindigkeit, die angibt,
wie schnell Sie diese Geschwindigkeit
erreichen,
unseren Neigungsfaktor, der angibt, wie stark das
Flugzeug bei den
verschiedenen Geschwindigkeiten abstürzt,
und dann sogar
die
Rotationsinterpolationsgeschwindigkeit, mit der wir
zu diesen Neigungswerten gelangen. All dies ist einstellbar,
ohne die Logik zu berühren. Wenn du schnelle
Arcade-Action willst, können
wir
die Interp-Geschwindigkeit erhöhen Wenn du einen langsamen und fließenden
Raum willst, kannst du ihn verringern. Das Gefühl des Spiels kommt
dann ausschließlich von den Zahlen. Also
können wir das dabei belassen. Wir haben einen reibungslosen, einigermaßen zufriedenstellenden Ablauf
mit einigen netten Bankgeschäften. Und ja, da ist der
Framerate-Bug ,
auf den wir noch zurückkommen werden, aber zumindest wissen wir
davon und werden ihn später beheben. Als Nächstes können wir auf
das erweiterte Eingabesystem aufrüsten. Dies ist Unreals
moderner Ersatz für das ältere Eingabesystem
, das wir derzeit verwenden Wenn Sie, wie gesagt,
experimentieren wollten, haben Sie jetzt all diese
Werte bereit, mit denen Sie spielen können Versuchen Sie, der Rotation etwas mehr
Tonhöhe hinzuzufügen und diese
möglicherweise
mit den Vorwärtsbewegungen hinzuzufügen. Das gleiche Muster,
unterschiedliche Achsen
sowohl für die Rotation
als auch für die Bewegung,
falls das immer noch nur in eine Richtung
geht.
8. 07 - Erweiterte Eingabe: Bewegung einrichten und
bis zu einem testbaren Punkt arbeiten. Denken Sie daran, dass das alte
Eingabesystem, das wir
verwendet haben und das, wie ich
bereits erwähnt habe, veraltet ist Die verbesserte Eingabe ist
der moderne Ersatz. Einrichtung ist im Vorfeld etwas
umfangreicher, aber sie ist deutlich
flexibler Wir bekommen Dinge wie
Hot-Swap-fähige Kontrollschemata, eingebaute tote Zonen,
Laufzeit-Rebinding, all die
Dinge, die Sie mit
dem Legacy-System selbst
programmieren müssten mit
dem Legacy-System selbst
programmieren Lassen Sie uns also mit der Migration beginnen. Der erste Hauptunterschied besteht darin, dass
das erweiterte Eingabesystem tatsächlich über
eigene Klassen verfügt Gehen Sie also zurück
zum Blueprints-Ordner, klicken Sie mit der
rechten Maustaste hier hinein oder drücken
Sie Strg+Shift in n, um einen neuen Ordner zu
erstellen, und wir nennen diesen einen Input Die verbesserte Eingabe teilt die
Dinge in zwei Teile auf. Wir haben unsere Eingabeaktionen, die definieren, was passieren kann Dinge wie Feuer, Bewegung, Neustart Und dann haben wir so
genannte Eingabe-Mapping-Kontexte, die definieren, welche Schaltflächen die zuvor
genannten Aktionen
auslösen, für eine Trennung
von Belangen sorgt. Und der Grund, warum sich diese
Trennung als nützlich erweist,
ist, dass sie es ermöglicht, die
Kontrollschemata zu ändern, ohne dass
die gesamte Spiellogik neu verkabelt Im Code können wir einfach
das Eingabesystem aufrufen, um
zwischen Menüsteuerung,
Gameplay-Steuerung und
Fahrzeugsteuerung zu wechseln , was auch immer es sein mag Sie können
dieselben Aktionszuordnungen für die jeweiligen Schaltflächen
verwenden, sie können
jedoch in
unterschiedlichen Kontexten ausgeführt werden Eine Codezeile und wir
haben alles geändert. Innerhalb des Eingabeordners klicken
wir mit der rechten Maustaste und ich gehe hier zur
Eingabekategorie. Wir können sehen, dass wir den Bereich
Eingabeaktionen haben, also werden wir einen davon erstellen. Geben Sie dem den Namen
IA Underscore Fire. Wir wählen diese
Brustkontrolle aus, um sie zu duplizieren Wir benötigen noch zwei davon, also duplizieren
wir das zweimal und nennen das eine
IA Underscore Move und das andere IA
Underscore Als Nächstes wollen wir unsere Klasse
IA Underscore Move öffnen. Wir doppelklicken, um das zu öffnen
. Und das Wichtigste, was wir uns ansehen wollen, ist, dass
wir hier den Wertetyp haben. Standardmäßig ist dies auf
digital boolean oder Ball eingestellt,
und das ist dem, was wir in
den Projekteinstellungen mit
den Action-Mappings eingerichtet haben, sehr ähnlich Projekteinstellungen mit
den Action-Mappings Wir müssen sie trotzdem löschen. Wir gehen zurück zu
Bearbeiten, Projekteinstellungen. Wir gehen wieder zur Eingabe zurück. Und nur für den Kontext, der
digitale boolesche Wert, der entweder - oder ausgeschaltet gewesen wäre, wenn
wir hier ein
Action-Mapping erstellt Wir hätten zum Beispiel etwas namens Feuer
erzeugen können, an einen Knopf
binden und es jedes Mal abfeuern
lassen können, wenn wir ein
Projektil aufrufen wollten Solange wir hier drin sind,
werde ich auch
die Action-Mappings loswerden , nur damit nichts übrig bleibt Das wird auch zu einem kleinen
Bug in unserem Code führen, aber das wird es einfacher machen,
Dinge zu finden
und zu verbessern, wenn wir unser Code-Update
durchführen Also drücken wir einfach auf Löschen,
um auch unsere
Zugriffszuordnungen zu Auch das
speichert automatisch, wir können
das schließen und zum IA-Unterstrich
zurückkehren Sowohl unsere Eingabeaktionen „Auslösen“ als auch „
Neu starten“. Beide brauchen
digitale Goldbarren, weshalb ich sie nicht geöffnet
habe Sie sind standardmäßig völlig
in Ordnung. Entweder drücken wir den
Feuerknopf oder nicht. Das Gleiche gilt für
den Neustart-Knopf. Für die Bewegung wollen
wir das allerdings reduzieren
und wir wollen
diese Achse mit einem D-Float verwenden, im Grunde
dasselbe bietet wie ein Achsen-Mapping, einen Wert
von minus Eins bis positiv Eins oder Null, wenn
nichts gedrückt wird. Das ist also die einzige Änderung
, die wir
innerhalb unserer Eingabeaktion vornehmen müssen . Wir können auf Speichern klicken. Wir
können diesen schließen und
in unseren Eingabeordner zurückkehren. Jetzt wollen wir
zu unserem Mapping-Kontext kommen. Das wird sein, welche
Buttons auslösen, welche Aktionen. Wenn wir hier mit
der rechten Maustaste auf den Ordner klicken, kehren
wir
zum Eingabebereich zurück und erstellen dieses Mal
einen Eingabe-Mapping-Kontext. Die Benennungskonvention
wird IMC sein. Unterstreichen Sie und dann den Namen
der Sache, für die das verantwortlich
sein wird haben diesem
einfacheren Projekt werden wir nur eine Art von
Eingabe Also nenne ich diesen einen
Haupteingang für unsere Haupteingabe. Doppelklicken Sie, um das zu öffnen, und wir können sehen, wie es funktioniert. Nun, diese Art von
repräsentiert die Projekteinstellungen, die
wir zuvor bearbeitet haben. In der oberen linken
Seite möchten wir auf
diese Plus-Schaltfläche klicken und sie nach unten ziehen. Wir müssen jeden
dieser Einträge einzigartig machen, weshalb dieser Eintrag
derzeit abgestuft wird, sodass wir
keine weiteren Zuordnungen hinzufügen können bis wir einige einzigartige
Eigenschaften in diesem Eintrag haben Wenn wir das runterlassen, können wir es auf Ia
underscore fire setzen Ia
underscore fire Und wenn wir dann
die Kategorie hier herunterklappen,
können wir hier mit
der gleichen Art von Mapping beginnen , die wir zuvor gesehen haben Wenn ich also möchte, dass die
Feuerfunktion über die Leertaste aufgerufen wird, kann
ich hier die Taste drücken, die
Leertaste drücken und schon haben wir Wenn ich auch möchte, dass es
auf den linken Mausklick reagiert, kann
ich hier klicken und
dann mit der linken Maustaste klicken Ich werde dasselbe auch ein letztes Mal für das Gamepad Ich drücke die Taste
erneut und drücke dann die untere Gesichtstaste, die A-Taste auf
dem Gamepad,
und wir haben Wir haben jetzt also drei verschiedene Tasten oder
drei verschiedene Eingänge, die alle
die Feuerfunktion aufrufen können , wenn wir
das implementieren Wir wollen
dasselbe noch einmal für unsere anderen Eingabeaktionen tun. Also drücken wir das Plus. Wir wollen etwas
an den Neustart binden. Das wird nett und einfach sein,
also mache ich das zuerst. Noch einmal, wir könnten
möglicherweise R für den Neustart haben , und vielleicht füge ich auch
eins für das Gamepad hinzu und mache
das zur Starttaste Das ist also die spezielle
rechte Taste. Nur zur Erinnerung, ich verwende die linke Umschalttaste und drücke die Pfeiltasten, wodurch
alles wieder zusammengeklappt wird. Wenn Sie hier einige
Tastenkombinationen benötigen, halten Sie die Umschalttaste gedrückt drücken Sie die linke Maustaste,
und Sie können sehen, wie sich jedes
einzelne Element entfaltet Das ist eine nette und schnelle Methode, um die
Dinge entweder aufzuklappen oder zu reduzieren, wenn wir diese
verschiedenen Zuordnungen durchgehen letzte Mapping, das ich
erstellen wollte, wird die Bewegung sein Also werden wir noch eins
davon hinzufügen. Wir binden das an einen I A-Unterstrichzug Wir lassen das fallen. Und wieder werden
wir hier einige Schlüssel
hinzufügen wollen. Wenn wir
genauso beginnen wie zuvor, klicken wir hier auf
die Schaltfläche, drücken D, um eine
Standardbewegung nach rechts zu haben,
und klicken dann auf eine andere und drücken A, um unsere Bewegung nach links zu erhalten. Jetzt
ändern sich die Dinge ein wenig, und das ist nur bei den
erweiterten Eingabeeinstellungen der Fall. Obwohl wir diese als einseitige Achse festgelegt haben, also
als Fließkommawert für die Bewegung
unseres IA-Unterstrichs, können
Sie sehen, dass wir
hier eigentlich
keine Gleitkommawerte haben , die geändert werden müssen, um das A umzukehren, sodass sich die Dinge nach
links bewegen Stattdessen
kommen hier Modifikatoren mit dem erweiterten Eingabesystem ins Wenn wir also auf das
Plus-Zeichen auf dem Modifikator klicken, können wir ihn herunterklappen
und Sie sehen
eine Reihe nützlicher
Funktionen, die bereits eingebaut sind Wir können Dinge wie tote
Zonen für Analogsticks,
automatische Skalare und
ähnliches hinzufügen ,
die auf den Eingang angewendet
werden können Der Eine, den wir wollen, ist einfach da, also wollen
wir den Wert negieren Es wird standardmäßig auf
eins gesetzt. Wenn wir das negieren Das gibt
uns einen negativen Wert. Es ist so nett und einfach,
nur einen etwas
anderen Ansatz zu verwenden . Ich werde das
Gleiche noch einmal tun. Ich werde nur zwei weitere hinzufügen. Eins für den Rechtspfeil.
Einer für den Linkspfeil. Wir werden denselben Modifikator
zum Linkspfeil hinzufügen. Und dann
füge ich endlich eine letzte Eingabe pro Zug hinzu
und bewege den linken
Analogstick erneut Jetzt
passiert hier das Gleiche. Wir müssen
hier keine Negationen hinzufügen , weil Unreal weiß, dass ein Analogstick ein linkes und
ein rechtes Potenzial auf der X-Achse hat .
Er gibt automatisch ein
negatives zurück, Er gibt automatisch ein
negatives zurück wenn ich ihn nach links
drücke Damit ist alles
eingerichtet und bereit,
innerhalb des
IMC-Underscore-Moves loszulegen innerhalb des
IMC-Underscore-Moves Also klicken wir auf Speichern und
wir können diesen schließen. Wir müssen dort
nichts mehr bearbeiten. Also, das hat vielleicht
ein bisschen langweilig ausgesehen. Wie ich bereits erwähnt habe, ist
die Einrichtung im Vorfeld etwas umfangreicher,
aber Sie müssen
dies nur einmal einrichten, aber Sie müssen
dies nur einmal einrichten, und diese Assets können
dann sehr
einfach in
zwei andere Projekte kopiert werden sehr
einfach in
zwei andere Projekte , wenn Sie feststellen, dass Sie ähnliche Muster
verwenden Und die Hauptsache ist
, dass Sie dadurch bei größeren Projekten
viel mehr Zeit sparen können, da es
viel flexibler ist als
das herkömmliche Eingabesystem Jetzt wollen wir wieder
in unseren Pornounterricht zurückkehren. Dies ist ein
weiterer Schritt, auf den Sie sich wirklich konzentrieren
müssen , denn
das ist der Schritt , den jeder
mit dem verbesserten Eingabesystem oft vergisst mit dem verbesserten Eingabesystem Der Mapping-Kontext ist vorhanden, aber noch wird er
von niemandem verwendet Und im Gegensatz zum
alten Eingabesystem muss
unser erweitertes
Eingabesystem explizit an eine Klasse gebunden
werden. Wir können das wirklich
einfach machen, und das ist der Schritt , den jeder
oft vergisst Zu Beginn des Spiels
können wir mit der rechten Maustaste
irgendwo in der Nähe klicken und nach der
integrierten
G-Player-Controller-Funktion
suchen integrierten
G-Player-Controller-Funktion Der Player-Controller empfängt
die Eingaben
direkt von unseren
physischen Geräten,
speist direkt von unseren
physischen Geräten, sie in Unreal ein
und entscheidet, wie das auf der anderen Seite
handhaben
, die er möglicherweise steuert Das kann auch für KI gelten, also das wäre
der Input, den die KI der
kontrollierten KI-Spielfigur gibt Vom Controller
aus nehmen
wir hier die Stecknadel und
suchen nach sogenannten G-Enhanced
Input Local Player Subsystem Wirklich bissiger Name
da. Wir wollen diesen hier
mit dem rosafarbenen F haben, das bedeutet
also, dass es sich um eine Funktion
handelt Es wird nur ein bestimmter Wert
zurückgegeben, nämlich das erweiterte Eingabe-Subsystem für
lokale Spieler Und von hier aus ist das die
Funktion, die wir wirklich brauchen. Wir werden den
Ad-Mapping-Kontext aufrufen. Nett und klar. Wir können genau sehen, was
das bewirken wird. Dadurch wird ein
bestimmter Mapping-Kontext hinzugefügt, den wir
gerade erstellt haben, um die Klasse gebunden zu
sein
, in der wir uns gerade befinden. Also stellen wir sicher, dass wir
diese mit dem Ausführungs-Pin verbinden, geben hier
den Mapping-Kontext ein
, den wir verwenden möchten, und wir haben nur den IMC-Underscore Man Die Art und Weise, wie Sie das verwenden
können
,
ist, dass Sie, wie ich bereits erwähnt habe , möglicherweise einen
fortschrittlicheren spezifischen Controller haben, verfolgt, was Sie während des Spiels
möglicherweise tun In Gameplay-Momenten
würde dies sicherstellen, dass der Mapping-Kontext die Gameplay-IMC
verwendet, und vielleicht hast du auch so etwas
wie eine IMC im Hauptmenü , sodass du mit
der Tastatur in deinem Hauptmenü navigieren
kannst der Tastatur in deinem Hauptmenü Wenn der Spieler
Pause oder Escape drückt, der Player-Controller dafür verantwortlich,
den Mapping-Kontext
so zu ändern, dass er
vom Gameplay zum Menü Und das ist der Punkt, an dem
das wirklich, wirklich flexibel wird. Wie ich bereits erwähnt habe, ein
bisschen übertrieben für die Art von Projekt, das
wir erstellen, aber es ist nützlich zu wissen,
und Sie können wirklich in
jedem Ihrer Projekte darauf
aufbauen Und was ich wirklich
noch einmal mit nach Hause nehmen
möchte , dieser Schritt ist entscheidend Ich habe so viele Leute gesehen, die alles perfekt
konfiguriert haben. Sie haben alle
ihre Eingaben eingerichtet. Alle
Bewegungsfunktionen würden korrekt funktionieren. Sie drücken auf Play und
nichts passiert. Sie verbringen eine Stunde mit dem Debuggen
und dann stellen Sie endlich
fest, dass Sie vergessen haben, den
Mapping-Kontext zu binden Also sei nicht diese Person.
Also das Letzte, was wir hier tun wollen, ist die alten
Eingaben, die wir hatten, zu
ersetzen. Wenn wir auf Kompilieren klicken, weil wir die Legacy-Eingabe
aus den Projekteinstellungen
entfernt haben , meinte ich damit
, dass wir hier unten tatsächlich
einen sehr nützlichen Fehler
oder eine Warnung erhalten . Es sagt uns jetzt
, dass es versucht, auf etwas zu verweisen, das eine unbekannte Achse
ist. Wenn wir hier auf diesen
unterstrichenen Text klicken
, werden
wir direkt dorthin weitergeleitet ,
wo die Probleme
auftreten. So nett und einfach Und alles, was wir tun müssen,
ist, uns diesen Knoten zu schnappen ,
der in den Projekteinstellungen nicht mehr existiert. Drücken Sie Löschen. Wir können hier mit der
rechten Maustaste klicken und wollen nach
unserem IA-Underscore-Move suchen Das Gleiche, der Legacy-Eingabe sehr ähnlich .
Wir haben zwei Möglichkeiten. Wir erhalten die Aktionsereignisse, die einen Knoten
wie diesen erzeugen würden, in dem wir
einen Ausführungs-Pin und
die Float-Variable haben , oder wir können
hier die Achsenaktion verwenden, den Aktionswert. Das Gleiche wie
der Achsenwert, den wir zuvor
hatten. Also wählen
wir diesen aus. Dadurch erhalten wir nur
den Fließkommawert und wir können ihn wieder eingeben. Der Code selbst ist also
ziemlich identisch. Nichts hat sich
wirklich geändert. Es ist einfach die Art und Weise, wie
wir
den erweiterten Eingang einrichten werden , um uns
diese Informationen zuzuführen. Das macht den Übergang
relativ reibungslos, und unsere gesamte Bewegungslogik
wird exakt gleich bleiben. Wenn wir auf Play drücken, können
wir das testen. A und D machen also
dasselbe, links und rechts, und das
ist wieder der Analogstick. Also alles funktioniert genau so
, wie wir es erwarten würden. Wir mussten lediglich die Eingabeschicht
unter unserem
Kerncode
aktualisieren . Und das ist es. Wir haben jetzt das
erweiterte Eingabesystem in unserem Projekt,
das vollständig eingerichtet ist. Das hat zwar etwas mehr Zeit in Anspruch genommen als das alte Eingabe-Setup, aber es ist viel flexibler
und lohnt sich auf jeden Fall. Später werden wir weitere Funktionen verwenden,
wie z. B.
die Feuerereignisse zum Schießen, Auslösen von gehaltenen
Eingängen in einer Schleife und dann auch die einzige
Feuerstarttaste Das nächste Thema, mit dem wir uns befassen
wollen, werden
jedoch
unsere Gameplay-Grenzen sein Im Moment können wir
bis zur Affinität hochfliegen, was nicht wirklich gut
für ein Shooting ist Und wenn Sie experimentieren möchten, können
Sie
natürlich versuchen, Dinge wie
Totzonen-Modifikatoren für
die Thumbstick-Eingabe hinzuzufügen
, um können
Sie
natürlich versuchen, Dinge wie
Totzonen-Modifikatoren für
die Thumbstick-Eingabe hinzuzufügen zu
sehen, wie Timer oder Impulse mithilfe der integrierten Funktionalität funktionieren könnten Es ist kein Code erforderlich und nur
etwas zum Herumspielen.
9. 08 - Grenzen: Neues Eingabesystem, wir haben immer noch dieses Problem, bei dem wir
derzeit in die Unendlichkeit fliegen können. Irgendwann würdest du auf irgendein Problem mit
der
Gleitkomma-Präzision stoßen , aber schon lange davor wurde
das Spiel unspielbar und,
was noch wichtiger ist, ziemlich langweilig Für diese Art von Spiel benötigen
wir
eine fest installierte Kamera und einige Grenzmauern,
einige unsichtbare Wände Die Kamera, die wir haben, ist momentan
an der Spielfigur befestigt, und um sie zu erschießen, wäre
eine waagerechte Kamera
einfach sinnvoller Wenn wir also zurück zur Basis des
BP-Unterstrichs gehen, können
wir die
Federarm-Steuerung auswählen, die Kamera nehmen und diese
einfach löschen Wenn wir auf Play drücken, sind wir jetzt
wieder im Schiff, also haben wir das Problem
wieder, aber wir sind dabei, es
so gut wie sofort zu beheben Die Hauptsache ist
, dass ihr jetzt das Gameplay-Framework kennt das Gameplay-Framework und wisst, warum wir uns das Innere unseres Schiffes ansehen. Wenn nicht, dann geh ein paar Themen
zurück. Wenn wir zurück in
die Hauptebene gehen, wollen
wir nur eine Kamera hinzufügen. Oben, direkt
über dem Viewpot befindet sich ein kleiner Würfel
, der unsere Schaltfläche zum Hinzufügen ist Wenn wir das runterlassen, wollen wir nach der Option Kamera
suchen Viele der Optionen
hier neigen dazu, die
Kategorien alle paar
unwirklichen Versionen zu verschieben , sodass die Suche
etwas schneller sein kann weil das Leben einfach zu kurz ist
, um nach Kameras zu suchen Einer, den wir wollen, ist
unser Kamera-Schauspieler. Dieser wird direkt
in die Welt geworfen , wenn
wir ihn auswählen. Die Kamera
muss schauen wo der Spieler spawnen
wird, und wir wissen bereits aus
dem Gameplay-Framework , wie wir damit umgehen und
wo das sein wird Also eine nette, schnelle
Abkürzung für dich. Wenn du dir den Spielerstart schnappst
, wo der
Spieler spawnt, gehen
wir zum Detailbereich auf
der rechten Seite, klicken mit der
rechten Maustaste auf die
Ortseigenschaft und wir können den tatsächlichen
Standort des Spielerstarts kopieren Wenn wir die Kamera nehmen, machen
wir dasselbe, aber wir
klicken hier mit der rechten Maustaste und fügen die Eigenschaft ein
, die wir gerade bereitgestellt haben Wir haben die
Kamera jetzt also direkt am Startpunkt
des Players. Wir wollen dem auch eine gewisse Rotation geben
. Im Viewpot können wir also F
drücken, um auf die Kamera
zu fokussieren Wenn Sie möchten, können Sie in den Rotationsmodus wechseln und die Widgets einfach hier
verwenden Jetzt weiß ich für unsere Bedürfnisse,
wir wollen
die Kamera nur um -90 Grad
auf der Y-Achse drehen die Kamera nur um -90 Grad
auf der Y-Achse Also mache ich
das vom Detailbereich aus, und wir schauen jetzt
direkt auf den Boden Das ist vielleicht ein
bisschen zu nah dran. Als Nächstes wollen
wir also die Kamera auf der Z-Achse nach
oben
bewegen. Also nochmal, wenn wir hier
den Z-Wert nehmen, gebe
ich einen Wert von 2.400 Ich denke, das ist dem,
was wir zuvor hatten, ähnlich. Wir können jetzt sehen, dass wir direkt
nach unten auf den
Spielerstart schauen und darauf, wo das
Flugzeug spawnen wird. Ihr seid vielleicht nicht versucht, die
Play-Taste zu drücken und zu sehen, was passiert Der Grund dafür ist ganz einfach:
Was wäre, wenn wir fünf, sieben,
20 Kameras in der Szene hätten Woher sollte sie wissen
, welche sie wählen soll? Wie bei den anderen Regeln
, die wir festlegen, wollen
wir die Kontrolle darüber haben und das manuell festlegen. also der
Kameradarsteller ausgewählt ist, wollen
wir nur
in diesem Bereich suchen, genau hier, im Detailbereich, wollen
wir nach
etwas suchen , das
Autoplayer-Aktivierung genannt wird Wir können sehen, dass wir
diese Option hier haben. Die automatische Aktivierung für den Spieler ist
derzeit deaktiviert. Wenn wir diese Option herunterlassen
und Spieler Null auswählen, ist dies der
erste und einzige Spieler in unserem Einzelspieler-Spiel. Jetzt weiß das Framework, dass es die Kamera
verwenden soll , die
wir gerade ausgewählt haben. Wenn wir auf Play drücken, können
wir das sehen. Wir müssen
einige Anpassungen vornehmen, damit alles
richtig
zentriert ist, aber wir schauen jetzt
ungefähr, wo wir sein wollen. Bei der
Kameraplatzierung
wollen wir also, dass sich der Spieler näher
am unteren Bildschirmrand befindet, quasi wie Space
Invaders und wieder, indem wir das Setup
in den Inhaltsbeispielen, von denen wir ausgehen,
etwas nachbilden denen wir ausgehen, Das Problem mit dem
Editor und der Benutzerfreundlichkeit besteht
darin, dass der Player-Start über
keine Visualisierung verfügt Es wird also
etwas schwierig sein zu erkennen, wo die
Spielerschiffe
tatsächlich spawnen werden, und die Kamera entsprechend zu positionieren Ein schneller Trick, den
ich vorstellen wollte:
Wir können eine temporäre
Kugel oder Form hinzufügen, etwa
so, um zu zeigen,
wo der Spieler anfängt Wenn wir hier oben auf die
Schaltfläche Hinzufügen klicken, können
wir zu unserer Option Formen gehen. Ich weiß, dass ich
den Ort immer noch
vom Player-Start gespeichert habe , als ich ihn kopiert habe. Ich mache die
Suche nach Autoplayer hier rückgängig, klicke mit der
rechten Maustaste und füge den Startort des
Players ein Und ich schaue mir diese Sphäre an, die sich direkt am Start
des Spielers Wenn wir uns noch einmal den
Kamera-Darsteller schnappen, hat
das geholfen,
weil wir jetzt
genau sehen können , worauf die Kamera schauen
wird. F drücke, mache ich
wieder einen Schnappschuss, um genau
in die Kamera zu schauen , und wir können
das Ganze an die richtige Stelle ziehen. Wenn wir also die
Kamera nach vorne bewegen oder wir könnten den Start der
Spieler nach vorne bringen, ist
beides
völlig in Ordnung. Die Hauptsache ist, dass
wir wollen, dass das Spielerschiff ungefähr hier unten ist. Das ist also eine nette,
einfache Art,
die Dinge schnell in Position
zu bringen. Wenn ich mir die Kugel schnappe, kann
ich sie löschen. Natürlich wollen wir nicht
, dass das im Labor bleibt. wir auf Play drücken, kommen die Spieler näher an die Stelle, an der wir es haben
wollten. Ein weiterer Tipp der Kamera
, den ich nur ganz schnell
zeigen wollte , ist, ob
wir die Kamera wieder nehmen, während du mit den Dingen
herumspielst. Wenn Sie nicht möchten, dass sich dieses
Demonstrationsfenster automatisch ausschaltet, wenn
Sie etwas anderes auswählen, können
wir dieses kleine
Pin-Symbol hier unten auswählen,
wodurch dieses
Fenster an Ihren Viewpot angeheftet wird Wenn Sie also reinkommen müssen, bewegen Sie den
Startpunkt des Spielers zu um durch die
Kameraansicht zu sehen, was passiert.
Noch ein kleiner Tipp, dass wir das vorübergehend auf
dem Bildschirm belassen
können Wenn Sie möchten, dass das
verschwindet,
können wir einfach erneut auf die Stecknadel drücken und schon wird die Fixierung
aus dem Viewpot gelöst Nur ein paar Dinge
, mit denen Sie sich und mit denen Sie sich vertraut machen sollten Ich hole mir gleich eine andere
Form. Ich glaube, ich habe
es schon ein paar Mal erwähnt, aber wenn Sie F drücken und
ein Objekt ausgewählt ist, konzentrieren
Sie sich auf das
Objekt, das Sie betrachten möchten. Sie können klicken, um es dann
direkt um das Objekt zu drehen. Und eine weitere Sache
, die sehr
nützlich sein kann , ist, wenn wir so
etwas platzieren, wir die Shift-Taste gedrückt halten, mit der linken Maustaste
auf die Richtung des Widgets klicken und es dann ziehen können. Wenn wir also anfangen,
ein Objekt
hierher zu
ziehen und dann die Umschalttaste drücken , kann die Kamera im Viewpot
tatsächlich
das
Objekt verfolgen, das wir bewegen Viewpot
tatsächlich
das
Objekt verfolgen, das wir Sehr praktisch, wenn Sie
versuchen,
etwas abzuspielen und es nicht ständig bewegen
möchten, die Kamera
bewegen,
es erneut bewegen und so weiter Also nur ein paar schnelle Tipps, um sich
mit dem Viewpot vertraut zu machen Jetzt wollen wir anfangen, uns die Grenzen
anzusehen Auch hier
suchen
wir über die Schaltfläche Hinzufügen nach etwas
, suchen
wir über die Schaltfläche Hinzufügen nach etwas als Sperrvolumen bezeichnet wird. Wir können sehen, wie wir die
Möglichkeit haben, das Volumen zu blockieren. Wir wählen diesen
aus, und was wir
bekommen , ist dieser unsichtbare Würfel. Das wird
unsere unsichtbare Mauer darstellen, und wir wollen ihn einfach über
das gesamte Level verteilen , um zu blockieren, wo der Spieler oder die Feinde treffen könnten. Um das in Ordnung zu bringen, werde
ich
dasselbe noch einmal tun. Ich
klicke mit der rechten Maustaste und füge die Position des
Player-Starts ein . Das wird uns hierher
bringen. In diesem Fall können wir
das auf der linken Seite unserer Spielzone platzieren ,
was, wie ich aus
Tests weiß,
ein guter Punkt mit negativen 1.240 wäre ein guter Punkt mit negativen 1.240 Dadurch wird es knapp vorbei sein. Auf der Z-Achse völlig in
Ordnung. Das ist hoch genug, dass das Flugzeug tatsächlich damit
kollidieren wird Wenn wir das auf die
X-Position Null setzen, wird
diese
Art von Mitte des Levels auf
der Ford-Achse platziert Und dann
wollen wir hier die Box so skalieren , dass sie
die gesamte Ausdehnung abdeckt. Eine Möglichkeit, dies zu tun
, besteht darin, die X-Achse
hier viel länger zu machen. Das wird die Box ändern. Das überfordert
den eigentlichen Schauspieler irgendwie. Wenn wir mit
Dingen wie Volumen arbeiten, haben
wir eine andere Option. Also werde ich das auf die ideale Art und Weise, wie wir damit
arbeiten werden,
zurückstellen die ideale Art und Weise, wie wir damit
arbeiten werden , nämlich die
Pinseleinstellungen hier zu
ändern. Das ist also die Größe der Box, die wir derzeit
haben
, sie beträgt etwa 200 Zentimeter. Wenn wir das also stattdessen auf etwas
viel Größeres setzen, füge
ich hier einfach ein
paar Nullen Wir werden also eine
Box mit 20.000 Einheiten haben, nur um sicherzustellen, dass wir die
gesamte Spielzone
kapseln und ein bisschen mehr,
wahrscheinlich noch viel mehr Aber das ist völlig in Ordnung. Der Grund, warum wir das tun
wollen, ist, dass dadurch der Maßstab
der eigentlichen Komponente im Inneren,
dieser Brushbox-Komponente, verändert wird der eigentlichen Komponente im Inneren,
dieser Brushbox-Komponente, . Wobei dieser Wert hier oben
die Skala des
tatsächlichen gesamten Schauspielers ist . Wenn wir das also
einheitlich und sauber halten können, dann ist
es etwas
einfacher, damit
zu arbeiten, falls wir mal Dinge im Code überprüfen mussten . Und nochmal, hält unsere
Struktur einfach ein bisschen aufgeräumter. Und wenn wir schon
hier unten sind, mache ich
die Höhe einfach ein
bisschen größer. Also sollten wir das auf dem Z
auf
etwa 1.000 setzen , nur um
sicherzugehen, dass wir definitiv
absolut alles blockieren Etwas anderes, das
etwas verwirrend sein könnte, ist, dass
wir, wenn es
etwas schwer zu erkennen ist, wenn es
etwas schwer zu erkennen ist, Optionen zum
Ändern der Deckkraft haben, wir können ein
schattiertes Displayvolumen hinzufügen
und dann sehen, wo sich der Würfel tatsächlich Auch dies wird im Spielmodus nicht
angezeigt, aber es wird
durch die Kamera sichtbar, wodurch es
etwas einfacher zu Und die Hauptsache
ist,
abschätzen zu können, wo die
Sperrlautstärke tatsächlich auftreten wird. das erledigt ist, drücke ich einfach die
Strg-Taste in D nachdem ich die von uns eingestellte
Sperrlautstärke ausgewählt habe. Ich setze das auf 1.240, also haben wir das auf der rechten
Seite des Spielfeldes Also auf der YX ist es da. Und nur um es sichtbar zu machen,
wie die linke Seite, werde
ich einfach wieder
nach unten scrollen. das Display mit der
schattierten Lautstärke einschalten, sehen beide
gleich aus . Seien Sie sich dessen auch bewusst Ich denke, wenn wir Dinge
duplizieren, versucht
Unreal, den
duplizierten Akteur so
oder so um mehrere Einheiten zu verschieben , damit sie sich
nicht vollständig Sie können also sehen, dass
wir auf
der rechten Seite Lautstärke einige Offsets auf dem X haben.
Das würde eigentlich kein Aber nur um die
Stimmen und mein Gehirn zu beruhigen, werde
ich das wieder auf
Null setzen und alles wieder, schön aufgeräumt und
gut Nachdem Sie eine Reihe solcher
Änderungen vorgenommen haben, möchten Sie vielleicht Strg+Shift
und S
drücken, um alles zu speichern
, woran wir gearbeitet haben Jetzt können wir also ins Playode gehen. Wir werden
durch unsere Kamera schauen. Es wird
etwas schwierig sein, das zu erkennen, weil wir das
tatsächliche Bindungsvolumen hier nicht sehen können. Wenn wir also
Dinge testen und sichergehen wollten, dass wir genau wissen, wann wir durch eine Wand gehen könnten,
wäre eine
weitere,
etwas langwierige Option, wir könnten wieder in Formen zurückkehren.
Wir könnten einen Würfel hinzufügen. Um zu den
Kollisionseinstellungen
im Detailbereich auf
der rechten Seite zu gehen und nur sicherzugehen, dass
wir nur nach unserem Blockvolumen suchen, können
wir das
Kollisions-Preset einfach
hier auswählen und es
auf „Keine Kollision“ setzen. Wir werden uns etwas später genauer mit der Kollision
befassen, aber das ist nur, um etwas Visuelles zu
bekommen. Dann gehe ich wieder zurück
zu den Details, füge das in die Position ein
und gebe das -1.240 Aus Gründen der Geschwindigkeit und
Einfachheit
behalte ich die Größe einfach ungefähr Es muss nicht exakt sein, also schnappen wir uns den Würfel. Auf der Y-Achse müssen wir
diese beiden Einheiten auf der Y-Achse zusammenfügen, um ungefähr die Größe unseres
Blockvolumens zu erhalten, und wieder werden
wir es auf dem X viel
größer machen, sodass es alles
umfasst, und wieder
größer auf dem Z. Wir müssen nicht
ganz so vorsichtig sein Hier. Hauptsache,
es ist nur etwas Visuelles, damit wir sehen können, ob und wann der Spieler
durch die Wand gehen würde , also können
wir das hier sehen. Der Hauptgrund ist
, dass ich wusste, dass die Kollision nicht funktionieren
würde, und ich wollte nur
sofort
die Tatsache beseitigen , dass wir tatsächlich durch
den Verbindungsbereich gehen
, der eigentlich mit uns
kollidieren sollte Der Grund, warum ich das vorstellen
wollte, ich wusste, dass das passieren
würde, gibt uns
das ein kleines
Beispiel dafür,
wie wir beim Debuggen vorgehen könnten Das ist wirklich wichtig für
die Entwicklung, um zu verstehen,
wie man Probleme löst, Dinge repariert und
herausfindet, was vor sich geht Ich habe
eines der Probleme schon irgendwie beantwortet. Die erste Sache ist, dass wir nicht gewusst
hätten,
wenn wir nur herumfliegen würden, ob wir tatsächlich durch
die Mauer gegangen sind oder nicht. Wir haben also bereits
die Tatsache verworfen , dass wir die Mauer
nicht erreichen Wir können bis zur
Spitze der Mauer
gehen und weiter gehen, ohne dass es zu einer
Kollision kommt Das ist also eine Option aus der Checkliste, die
komplett abgehakt ist Wenn ich mir das Blockierungsvolumen auf
der linken Seite schnappe , versuchen
wir zuerst, dieses Problem zu beheben Der erste Verdacht könnten die
Kollisionseigenschaften sein , die
ich Ihnen gerade gezeigt habe. Auf der rechten Seite
im Detailbereich gehen
wir also zurück zu
den Kollisionseigenschaften. Bei Kollision können wir sehen, dass diese Voreinstellung
auf unsichtbare Wand eingestellt ist. Wenn wir das runterlassen, können
wir uns
ansehen, was das bedeutet. Und das wird ein sehr kurzer Überblick über
Kollisionen sein. Auch hier
wird es in den kommenden Themen noch viel ausführlicher darauf eingehen. Aber vorerst müssen wir nur
wissen, dass es drei
verschiedene Typen gibt. Wir haben Ignorieren,
Überlappen und Blockieren. Ignorieren macht das
, was Sie denken würden. Es ignoriert alle anderen
Collider und Interaktionen. Overlap
sucht nach zwei Dingen , die sich im
selben physischen Raum befinden, aber nicht physisch
mit Dingen wie Physik berühren und sich gegenseitig blockieren Und dann haben wir
Block, zwei physische Objekte, die
aufeinander treffen und versuchen, sich
gegenseitig wegzustoßen, sodass sie nicht
denselben physischen Raum bewohnen Kurz gesagt, die unsichtbare Wand ist genau so
aufgebaut, wie wir es wollen. Sie ist darauf ausgelegt, absolut
alles auf der Welt zu blockieren. Das ist übrigens unser zweiter
Verdächtiger. Wir wissen, dass wir die Mauer
erreichen und wir wissen, dass die
Mauer kollidiert. Als Nächstes
schauen wir uns die Kollision der Pfannen an Wenn wir also
zur Bauernklasse gehen, gehen
wir zum statischen Netz,
und die Kollision wird im
Moment auf dem statischen Netz
behandelt auf dem statischen Netz
behandelt Im Detailbereich wollen
wir also wieder nach unten
scrollen und die Kollision finden Wir werden die
Kollisionsvoreinstellungen herunterklappen
und sehen, dass sie so
eingestellt sind, dass alle Dynamiken blockiert Nun, das
spielt eigentlich keine Rolle. Nochmals, das Wichtige
an diesen Kästchen hier. Dies ist angekreuzt, um auch
absolut alles zu blockieren. Und wenn wir sehr schnell zurück in
die Welt gehen, bekommen
wir hier einen sehr schnellen
Crashkurs zum Thema Kollision.
Wir können sehen, dass der Objekttyp der
unsichtbaren Wand auf weltstatisch
gesetzt ist Pornos selbst sind
auf Weltdynamik eingestellt. Das versucht also, statische
Weltobjekte zu blockieren, und das versucht,
weltliche dynamische Objekte zu blockieren. Solange diese beiden
also interagieren wollen, sollten
wir eine gewisse
physische Blockierung sehen. Also das ist übrigens der dritte
Verdächtige. Die Pornokollision ist
tatsächlich korrekt eingerichtet. Und das
Einzige, was wirklich übrig bleibt, ist, dass wir in unserem Code
wahrscheinlich etwas
falsch gemacht haben. Und Spoiler-Alarm, ich
weiß bereits, dass das das Problem ist. Wenn wir also in das
Ereignisdiagramm des Ereignisses gehen, werden
wir hier zu
unserer
Funktion „Standort für Schauspieler festlegen“ übergehen hier zu
unserer
Funktion „Standort für Schauspieler festlegen Und das ist eines der
Dinge, bei denen es ziemlich schwierig
wäre , das Debuggen wieder durchzuführen
und zu wissen
, dass das Problem tatsächlich ist,
ohne das wirklich
erlebt zu haben Zwei Dinge, auf die Sie hier achten
sollten, sind der Sweep
und der Teleport-Boolesche Wert beim Funktionsaufruf. Wenn wir den Mauszeiger über den Sweep bewegen, können
wir hier die Beschreibung sehen , ob wir den Zielort
durchsuchen und dabei Überlappungen auslösen können
wir hier die Beschreibung sehen
, ob wir den Zielort
durchsuchen und dabei Überlappungen
auslösen.
Das ist wirklich wichtig. Außerdem kontrollieren wir
, ob wir hinter
dem Ziel anhalten , wenn etwas durch etwas blockiert
wird. Der wirklich wichtige Teil
dabei ist, dass, wenn wir dieses Häkchen nicht aktiviert
haben, wir auch nicht überprüfen unsere Position blockiert ist, was bedeutet, dass
wir nichts treffen Kurz gesagt, wenn wir das
Häkchen nicht gesetzt haben, teleportiert uns das technisch gesehen quasi an den
Ort, an dem Wenn wir das also ankreuzen, auf Kompilieren und Speichern
klicken, gehen
wir zurück Wir können jetzt sehen, wann wir überfliegen, wir werden
jetzt blockiert. Wir mussten also keine der
Kollisionsvoreinstellungen
ändern Wir werden uns
etwas später damit befassen. Das bedeutet
auch, dass die Wand auf der rechten
Seite funktionieren wird weil sie
genauso aufgebaut ist,
also ist das völlig in Ordnung. Es war einfach eine wirklich
einfache Sache, in unserem Code
sehr leicht übersehen Also wollte ich
das nur aufnehmen, weil, wie ich bereits erwähnt habe, die Dinge
nicht immer perfekt laufen
und Sie sich wohl fühlen müssen
, wenn Sie nur ein bisschen debuggen und versuchen müssen die Dinge, von denen Sie
logischerweise denken, dass sie Teil des Problems
sein könnten, wieder
durchzuarbeiten logischerweise denken, dass sie Teil des Problems
sein könnten Das ist eines dieser Dinge, die am Ende ein
sehr häufiges Es ist wirklich leicht zu
übersehen. Wirklich schwer zu debuggen, wenn Sie nicht wissen,
wonach Sie suchen Aber wenn das gescheitert wäre, hätte
ich selbst als erfahrener Entwickler als erfahrener Entwickler irgendwie möglichen Gedankenwege mehr gehabt, die ich
hätte durchmachen können, und ich hätte einfach
zu Google oder RDI oder
ähnlichem zu Google oder RDI oder und versuchen müssen,
dort zu suchen, falls jemand
ein ähnliches Problem hatte Also jetzt nur ein kurzes Aufräumen
mit den Grenzen. Ich gehe wieder rein.
Ich werde diesen weißen Würfel hier loswerden. Das
war nur zur Veranschaulichung. Wir wissen jetzt, dass wir an der richtigen Stelle
spawnen, und wir werden hier von
beiden Wänden
blockiert .
Jetzt, wo das erledigt ist Die Kamera ist repariert. Sie ist jetzt da
, wo wir sie haben wollen. Die Grenzen sind festgelegt, und
wenn wir anfangen, Feinde hinzuzufügen, erkennen
sie die Wände
und springen zwischen ihnen Offensichtlich, sobald wir diesen Code
implementiert haben. Vorher werden
wir uns jedoch mit Materialien befassen, den eher visuellen
Elementen unseres Projekts. Wir werden in der Lage sein,
das Aussehen unserer Schiffe so anzupassen , dass nicht alle Gegner den Spieler identisch
aussehen. Wie immer gilt: Wenn ihr
im Moment experimentieren
wollt ,
probiert einfach etwas Einfaches aus. Versuche, eine obere und eine
untere Grenze hinzuzufügen,
vor allem, wenn du
bereits eine gewisse
Vorwärts- und Rückwärtsbewegung hast Vorwärts- und Rückwärtsbewegung Noch einmal, derselbe
Prozess, verschiedene Achsen, nur um dich vertraut zu machen und verschiedene Dinge
auszuprobieren
10. 09 - Materialinstanzen: Moment, wenn wir
direkt anfangen würden, unsere Feinde zu erschaffen, würden
sie genauso
aussehen wie unser Spieler. Das gleiche blaue Flugzeug, keine Möglichkeit, sie
wirklich voneinander zu unterscheiden. Aus diesem Grund sind unsere
Materialien erhältlich, die
es uns ermöglichen, unsere drei D-Modelle mit unterschiedlichen
Farben und Bildern zu versehen, um sie
zu unterscheiden und für Abwechslung zu sorgen. Wir werden keine
Materialien von Grund auf neu erstellen, da das ein
eigenes Kaninchenloch wäre. Und wie ich bereits erwähnt habe, konzentrieren
wir uns hauptsächlich auf Programmierung, Praktiken und Projekte,
die drei Ps. Aber ich werde Ihnen zeigen,
wie wir
Farbvariationen von dem erstellen können , was
ich wirklich zur Verfügung gestellt habe. Wir werden zwar keine
neuen Materialien von Grund auf neu erstellen, ich möchte Ihnen die
Materialien zeigen, die wir bereits haben. Wenn wir in den
Assets-Ordner „Materialien“ gehen, wie ich
bereits bei den
Namenskonventionen angesprochen habe , müssen
wir uns
hier einige Dinge ansehen. Wir haben zwei MM-Unterstriche,
das Wasser und die Textur, und wir haben vier MI-Unterstriche, die die
materiellen Instanzen sind Mm, das ist ein Präfix
für Mastermaterial. Hier findet die eigentliche
Shader-Logik statt. Wir öffnen die Texturbasis, wir werden hier
nichts bearbeiten, aber ich
wollte Ihnen nur einige
der Begriffe und Details zeigen , mit denen
Sie vertraut sein sollten Wenn wir hier zur
linken Seite des Diagramms wechseln, ist
das dem
Blueprint-Diagramm sehr ähnlich. Wir können einfach mit der rechten Maustaste klicken und es ziehen, um es zu
bewegen Die Hauptsache, die wir haben, sind drei Texturmustereingaben Wir haben die Grundfarbe,
das ist unsere Farbkarte, das Blau, die
Holzmaserung, die Farbe. Und das alles ist der
Ubi-Map auf dem Drei-D-Modell entnommen Ubi-Map auf dem Drei-D-Modell Wir haben dann unsere
normale Textur oder die normale Map, die
Oberflächendetails ohne Geometrie,
diese Unebenheiten, Rippen,
Plattenlinien usw. hinzufügt Oberflächendetails ohne Geometrie,
diese Unebenheiten, ,
alles vorgetäuscht, indem manipuliert wird, wie Die letzte wichtige ist die ORM-Textur. In diesem Fall habe
ich das persönlich erstellt, und ich habe einen etwas
anderen Arbeitsablauf. Ich habe das diesmal
speziell als ORME erstellt. Dies sind im Wesentlichen
vier
Graustufenbilder , die in einer
Texturdatei zusammengefasst sind, Der Hauptgrund dafür ist , dass alle darin enthaltenen Daten mithilfe von extrapoliert
werden
können Das spart Speicherplatz und es ist nur ein bisschen
einfacher, damit zu arbeiten In diesem Fall
steht der rote Kanal für die Umgebungsokklusion. Das ist der Punkt, an den das Licht
nur schwer gelangen kann. Der grüne Kanal steht für Rauheit, wodurch in
verschiedenen Bereichen eine spiegelglatte oder matte Oberfläche Der blaue Kanal ist
metallisch. Das ist binär. Das ist entweder metallisch
oder nicht metallisch, und der
Alphakanal ist emittierend und
zeigt an, welche Teile leuchten würden , sollten Sie
sich dessen bewusst sein Wenn Sie mit Materialien
arbeiten, sollten Sie
sich dessen bewusst sein
, dass wir nicht nur
diese sphärische
Darstellung hier haben, sondern dass diese sphärische
Darstellung hier haben, wir
mit einem praktischen Editor-Trick ändern können, was in diesem Viewpot
angezeigt mit einem praktischen Editor-Trick Wenn wir die Inhaltszeichnung öffnen
und in den Ordner Meshes gehen, schnappen wir uns ein Mesh, das Sie mit Ihrem Material
visualisieren möchten mit Ihrem Material
visualisieren In diesem Fall wird
es der einfache Held sein. Damit müssen wir
nichts anfangen. Wir
müssen das nur auswählen. Wir können zum Material zurückkehren,
bis wir uns
daran erinnern , was
wir gerade in
der Inhaltsschublade
ausgewählt haben in
der Inhaltsschublade
ausgewählt können die Darstellung,
die Visualisierung
unseres Materials so ändern die Visualisierung
unseres Materials dass es sich
dabei um Dinge wie einen
Zylinder, eine Ebene, einen Würfel handelt Und dann speziell
dieses Ziegelsymbol hier. Wenn Sie ein statisches Netz
ausgewählt haben und wir darauf klicken, erhalten wir eine
Darstellung,
Visualisierung unserer Ebene oder
des
Netzes Visualisierung unserer Ebene oder
des , das wir gerade in der Inhaltsdarstellung
ausgewählt haben . Das kann also sehr
praktisch sein, um Dinge zu visualisieren und genau zu sehen, wer dafür verantwortlich
ist. Aber was ist, wenn Sie
verschiedene Eigenschaften ändern und
sofort Feedback erhalten? Als Nächstes möchte ich, dass Sie sich überall
auf diese benannten Knoten konzentrieren . Diese werden als
benannte Reroot-Knoten bezeichnet. Anstatt Drähte, die sich
über unseren Graphen erstrecken, so
etwas wie eine
Verschwörungstheorie-Beweistafel Wir können uns stattdessen dafür entscheiden,
benannte Verbindungen nur einmal zu erstellen , und dann können wir
diese absolut
überall in unserem
Shader referenzieren . Völlig optional Sie werden diese
in anderen Beispielen nicht immer verwendet sehen ,
aber es
ermöglicht mir, meine gesamte
Shader-Logik auf
der linken Seite zu belassen und dann einfach Dinge
aufzurufen, wenn ich sie brauche,
auf der rechten Seite Eines dieser Dinge,
bei denen das Tool existiert, also warum es nicht verwenden Wie ich bereits erwähnt habe,
würde ich jedoch nicht empfehlen,
irgendetwas innerhalb des
Mastermaterials zu ändern irgendetwas innerhalb des
Mastermaterials , es sei denn, Sie
wissen, was Sie tun, oder zumindest ein Duplikat
zu
erstellen und einige Änderungen
daran vorzunehmen, damit Sie immer etwas haben,
auf das Sie zurückgreifen Der Hauptgrund dafür ist, dass wir uns im
nächsten Thema den materiellen Instanzen
befassen werden. Die Art
und Weise, wie die Instanz funktioniert, besteht darin,
die Informationen direkt
aus diesem Mastermaterial Wenn hier also etwas kaputt
geht, dann werden Sie möglicherweise alle Instanzen
,
die darauf angewiesen sind, kaputt machen . also wieder im
Materialordner sind, Wenn Sie also wieder im
Materialordner sind, können wir,
um ein bisschen
Zeit zu sparen,
einen ziemlich logischen Ausgangspunkt verwenden . Wir haben schon ein Flugzeug. Es hat die meisten
Texturen und alles genau so
eingerichtet, wie wir es brauchen, und das ist der MI
Underscore Plane Player Also mach weiter und schnapp dir diesen
, drücke die Strg-Taste, um ihn zu duplizieren und ihn in Flugzeug-Feind umzubenennen
, wobei der MI vorne Wenn wir darauf doppelklicken
und es öffnen, können
wir uns jetzt materielle Instanzen ansehen. Wir können sehen, dass
sich dies stark
von unserem Mastermaterial unterscheidet . Eine Sache, die Sie hier im
Auge behalten sollten, befindet sich auf der rechten Seite
im Detailbereich. Etwas, das ich erwähnen sollte, Sie
bemerken hier wahrscheinlich Muster. Jedes Mal, wenn wir in einem Panel sind,
egal ob es sich um Materialien,
Baupläne, Komponenten oder einen
Viewpot handelt Baupläne, Komponenten oder einen
Viewpot , wenn Sie sich etwas schnappen, gibt es normalerweise
irgendwo ein
Detailfenster , das Ihnen Informationen darüber gibt, was
Sie gerade sehen,
was definitiv eines
der schönen Dinge an Unreal ist Wenn du anfängst,
Teile der Feature-Sets zu erlernen, überträgt sich
das auf verschiedene Funktionen innerhalb der Engine Aber was ich sagen wollte, ist wenn wir uns das Detailfenster ansehen, wird hier das übergeordnete Element bezeichnet,
und das zeigt, dass dies
die MM-Unterstrichtexturbasis ist . Wir können also darauf
doppelklicken
und das bringt uns zurück zu
dem Material, und das bringt uns zurück zu das ich Ihnen gerade
gezeigt habe Also, wie ich bereits erwähnt habe,
stammen
alle Informationen direkt aus
diesem Mastermaterial. Eine andere Sache, es wäre schön das Flugzeug noch einmal
zu visualisieren. Um es noch einmal zusammenzufassen: Gehen Sie zurück
in den Ordner Meshes, schnappen Sie sich das Flugzeug und drücken Sie das Ziegelsymbol hier in
der Material-Instanz Die wichtigsten Dinge, die wir ändern
wollen, sind die Texturen. Wir können sehen, dass das ganz anders
ist. Wir haben hier weder
die Grafik noch
die Shader-Informationen. All das wird speziell im Mastermaterial
verwendet. Was wir innerhalb der Instanz haben,
sind stattdessen Dinge, die ich
ausdrücklich aufgedeckt habe. All diese benannten
großen Notizen hier, die Texturen, die Texturfarbe. Das sind parametrisierte
Variablen, die ich
verfügbar gemacht habe , damit wir sie in der
Instanz sehen können Worauf wir also
achten wollen, wenn wir Dans Kategorien weglassen, sind
all die
Dinge, die ich gerade mit den exponierten Eigenschaften
gezeigt habe den exponierten Eigenschaften
gezeigt Indem wir diese
innerhalb von Instanzen offenlegen, erhalten
wir eine wirklich angenehme
Arbeitsumgebung, in der wir einfach eine Änderung vornehmen können und die Aktualisierung sofort
sehen können die Aktualisierung sofort
sehen Das können wir also tun, um
unseren ersten Feindtyp zu finden. Wenn wir die Grundfarbe der
Textur,
also die Farbinformation, herunterfallen lassen , machen wir uns auf die
Suche nach dem grünen Feind. Ich denke, ich werde
die Feinde grün machen. Ich habe hier viele
verschiedene Texturfarben bereitgestellt, falls du das erweitern
und deine eigenen Feindtypen erstellen möchtest. Ich glaube, ich habe Gelb,
Lila, vielleicht Orange oder Rot aufgenommen . Ich werde mich für die Textur der
grünen Grundfarbe entscheiden, und wir können sehen, dass sich dadurch
sofort unsere Informationen zur
Einfärbung
ändern werden. Die meisten Normalen
und die OIME-Texturen sind wahrscheinlich ungefähr identisch, aber ich habe
sie einzeln
pro Textur exportiert , als ich sie erstellt
habe Also können wir genauso gut weitermachen
und uns das Normale schnappen. Also werden wir wieder nach Grün
suchen und wir werden
den schlichten grünen Helden finden. Aber dieses Mal wollen wir
die normale Textur. Und dann werden
wir endlich den OIME-Slot löschen und wieder nach Grün
suchen, und wir werden es einfach durch Hero Green OI ME ersetzen Okay. Also nur um
sicherzugehen, dass das genau den Modellen entspricht, die ich in
Blender gemacht habe ,
falls jemand neugierig war, und ich habe sie texturiert und
all diese Informationen
in Substance Painter gebacken all diese Informationen
in Substance Painter Wie ich bereits erwähnt habe,
sehen Sie möglicherweise ähnliche, aber leicht
unterschiedliche Workflows Es kommt auf den Künstler und die Person an
, die sie macht. Das Wichtigste dabei
ist jedoch, dass wir dieses
unmittelbare Feedback erhalten haben. Sobald wir etwas ändern,
gibt es keine Neukompilierung.
Wir haben gesehen, wie die neue Textur
auf das Material angewendet wurde, was einer der
Hauptvorteile von Material-Instances ist Definitiv nicht ausschließlich
zu diesem Vorteil, und wir sollten immer versuchen, nach Möglichkeit
Materialinstanzen
zu verwenden , in denen Dinge
ähnliche Eigenschaften,
Merkmale und Werte aufweisen, die wir offenlegen können Abgesehen von den Texturen wäre
dies also
ein perfekter Endpunkt, wenn Sie damit zufrieden sind, dass es so
aussieht, wie es ist. Ich wollte nur ein bisschen
mehr Informationen über
materielle Instanzen
geben , was sie tun und wie
wir sie verwenden können. Einige der anderen Eigenschaften
, die ich hier vorgestellt habe sind Fließkommawerte
oder Farben, die wir
direkt ändern und überschreiben können ,
die allgemeine Farbe oder Tönung, die
auf das Material angewendet wird oder Dinge wie die
Spiegelung des Werts Spiegelung ist also
wirklich einfach zu betrachten. Wenn ich
hier Spekularität ankreuze , können
wir das bearbeiten Und im Moment sind wir bei 0,5,
was ungefähr einer durchschnittlichen Spekularität was ungefähr einer durchschnittlichen So viel Licht wird von einer Oberfläche
zurückgeworfen,
wodurch die Dinge ein bisschen plastischer oder eher
wie Gummi aussehen , je höher
die Im Allgemeinen haben wir
nichts, mit dem wir täglich
interagieren, ohne dass es zu
Spekularität kommt Es ist also
einigermaßen realistisch,
irgendwo bei
0,3 oder 0,5 anzufangen einigermaßen realistisch,
irgendwo bei
0,3 oder 0,5 Wenn wir den Wert auf Null reduzieren, erhalten
wir sofort Feedback. Ich meine, ich habe eine
komplett mattierte, völlig nicht
reflektierende Oberfläche Wenn wir
das alles auf eins hochrechnen, dann wird das Licht viel, viel stärker
zurückgeworfen Also nochmal, du kannst
Funktionen wie diese anpassen und versuchen, dir ein Bild davon wie
deine aussehen soll Sie könnten auch mit Dingen
wie einer Farbmaske
oder einem Farbton
herumspielen wie einer Farbmaske
oder einem Farbton Wenn wir hier also die
Farbmaske übernehmen, im Wesentlichen ein Prozentsatz auf 0-1
normalisiert Also steht Null für keine Maskierung
und Eins für vollständige Maskierung. Wenn wir die
Texturfarbe einschalten, funktionieren diese beiden zusammen. Die Farbmaske
maskiert hier also die Überschreibung der
Texturfarbe Wenn ich etwas
wirklich Offensichtliches mache, wie zum Beispiel eine rote Farbe, und dann
die Maske ausschalte , indem ich
sie zu 100% wirksam mache, sodass 100% der
Farbe durchkommen Es ändert sich also auf den Wert eins. Wir haben jetzt ein vollständig rosafarbenes Flugzeug. Wir können das also sehr einfach kontrollieren
. Und das wirklich Schöne
daran ist
, dass wir sofort Feedback und
das sofortige Update erhalten , dass wir sofort Feedback und , wenn
wir diese Änderungen vornehmen. Wenn du das
etwas subtiler haben möchtest,
könnten wir die Farbmaske
auf etwa 0,5 ändern, und wir lassen nur die
Hälfte dieser Farbe
durchkommen. Wenn wir den Wert wieder auf
0,2 reduzieren, erhalten wir nur einen sehr hellblauen Farbton
auf unserer grünen Ebene es ganz auf Null herunterdrehen, Wenn wir es ganz auf Null herunterdrehen,
kommt überhaupt keine
Farbe mehr durch Also nur eine weitere Sache, mit der
Sie spielen können, zusammen mit den verschiedenen
Texturen, die Sie verwenden können, und dann funktionieren die
Emissionseigenschaften auf die gleiche Weise Also, ich hatte
hier nichts drauf , was man wirklich zum Leuchten bringen könnte, wie Stirnlampen oder
so Die Emission war also eher eine Möglichkeit
, dir verschiedene
Eigenschaften zu geben, mit denen du spielen kannst Wenn ich die Emissionsstärke aktiviere, müssen
wir ihr einen
Wert über Null geben Und wenn wir dann
die Emissionsfarbe einschalten, ist sie momentan Jetzt ist
Schwarz offensichtlich nur noch Null, Null, Null im RGB-Wert Wenn wir also
Schwarz mit eins oder 100 multiplizieren, erhalten
wir immer noch
Schwarz, was nichts ist. Also müssen wir dem eine
Farbe geben, wenn wir das in etwas wie
Gelb oder Orange ändern , und wir müssen vielleicht
die Stärke noch ein bisschen erhöhen . Und das ist tatsächlich eines
dieser Dinge ,
bei denen mir beim Ausnutzen
verschiedener Texturen klar wurde , dass
ein texturierter
Emissionskanal keinen Nutzen haben
würde . Wenn Sie also mit der Emissionseigenschaft
herumspielen möchten, können
Sie
hier die OME-Textur aufrufen und wir ändern sie wieder
in die blaue Ebene Flugzeuge hier sind blau.
Wir müssen das ein
bisschen abschwächen. Vielleicht, aber es gibt
eher etwas wie eins oder 0,5, also
überschreibt es die Farbe nicht vollständig Und du kannst hier das ganze
Flugzeug ein bisschen zum Leuchten bringen. Sie haben also auch die Kontrolle über die Emissionseigenschaften Wie ich schon sagte, habe
ich leider nicht daran gedacht, einige
Scheinwerfer im Voraus zu
modellieren, aber ich wollte
die Emissionseigenschaften verschieben,
damit Sie
das ganze Flugzeug zum Leuchten bringen
und Spaß damit haben können ganze Flugzeug zum Leuchten bringen
und Spaß damit haben Könnte nützlich sein, wenn du es animieren willst ,
explodieren zu lassen oder so Du könntest es
zwischen seiner normalen
Farbe und etwa Rot blinken lassen, bevor die Explosion
passiert, eine Idee Ich will nur irgendwie dabei helfen, zu visualisieren was hier passiert
und wie diese Texturen, insbesondere das OIME Mir ist klar, dass das ziemlich verwirrend
sein könnte. Ich schalte
das einfach aus und setze
sie zurück, weil ich nichts davon überschreiben
möchte. Und ich werde die Textur für
die OIME
wieder auf Grün
umstellen , da ich weiß, dass diese Textur speziell
für diese Farbeigenschaft
gebacken wurde für diese Farbeigenschaft Ich wollte dir nur ganz
schnell die Texturen zeigen
und dir zeigen , was passiert Wenn ich also sage, dass sie in
verschiedene Kanäle aufgeteilt wurden , wenn wir in den
Textur-Ordner gehen
und herausfinden, dass es
eigentlich egal ist,
welcher, um ehrlich zu sein. Wir können einfach
den schlichten blauen Helden finden und ich werde den OIME-Kanal
öffnen Normalerweise stammen die meisten Texturen, Farben und alles, was Farben und alles, was
wir hier
sehen, von den RGBA-Kanälen, die alle
gleichzeitig miteinander kombiniert werden Wenn man etwas wegnimmt, hat
man am Ende
nur etwas
matschige, komische Farben
wie diese, bei denen Rot und
Blau zusammengenommen matschige, komische Farben wie diese, bei denen Rot und natürlich Violett ergeben Rot und Grün geben uns eine Art orange
Farbe und so weiter Also würden wir es nicht so benutzen. Beim ORME-Prozess ist das
ein bisschen anders. Und das liegt daran, dass das, was ich im roten Kanal
gemacht habe, unsere
Umgebungsokklusion ist Also alles, was
weiß ist, wird im Grunde nicht durch andere
Elemente des Modells
blockiert Das Licht
trifft uns also voll und ganz, und dann hat alles, was
sich in Richtung Grau oder Schwarz bewegt, eine Art Okklusion gegenüber einem anderen
Teil des Modells, etwa dem
Unterfahrlager und dergleichen Und dort wird
ein bisschen
künstliche Schatten aufgetragen, um die Schatten hervorzuheben Im grünen Kanal war
das unsere Rauheit. Also nochmal, wenn man von
einem Wert von Null auf Eins geht, scheinen
verschiedene Bereiche rauer
zu sein, so wie diese Bereiche hier
einige grobe Details liefern, während diese viel glatter sein werden Das Blau war metallisch, also wiederum, das war
entweder metallisch oder nicht. Das wäre also die
Vorderseite des Propellers. Es gibt einige kleine
Metallteile an den Rädern und andere
kleine Merkmale wie diese Und dann
wurde der Alpha-Kanal gebacken, und wie
Sie hier sehen können, im
Grunde
der gesamte Körper
des wurde im
Grunde
der gesamte Körper
des Flugzeugs
in den Emissionskanal eingebaut Indem wir diese Informationen
herausnehmen und sie mit unseren
Farbeigenschaften
und ähnlichen Dingen
im Material multiplizieren unseren
Farbeigenschaften , können
wir
bestimmte Elemente
des Modells über
unsere Texturkanäle manipulieren des Modells über
unsere Texturkanäle Es ist also eine clevere
Art, Dinge zu tun. Das spart Speicherplatz
und gibt uns ein bisschen mehr Flexibilität bei
unseren Materialien. Nur ein paar andere Dinge bevor ich zu diesem Thema komme. Wenn Sie mit mehr Materialien
herumspielen möchten, nur um Ihnen ein
paar verschiedene Möglichkeiten zu zeigen, verschiedene
Materialinstanzen zu erstellen. Ich habe dir gezeigt, wie du
unser originales Spielermaterial duplizieren kannst. Die Steuerung in D wird das
duplizieren. Wenn du weißt, dass
du einfach etwas völlig Neues
machen willst , ein brandneues Material, um damit
herumzuspielen, gehen
wir einfach zum Material
und wählen dieses aus. Wenn Sie bereits
ein Mastermaterial haben, mit dem Sie
arbeiten können, und
Sie eine neue Instanz erstellen
möchten, können Sie hier mit
der rechten Maustaste auf das Mastermaterial klicken, hier nach oben
navigieren und eine neue
Materialinstanz erstellen. Es würde dir
etwas geben,
das der Spielerebene oder
was auch immer ich zuvor hatte, sehr ähnlich ist, und es hätte nur einige vorgefüllte
Standardwerte, im Grunde das gleiche Ergebnis. Also werde ich diesen loswerden.
Ich werde das nicht behalten müssen. Ich wollte dir
nur zeigen , wie du damit
arbeiten kannst. sage das, weil
es wahrscheinlich eines
der leichteren Themen ist, mit denen
man sich vertraut machen kann, und wir werden nicht viel
tiefer gehen , als wir es hier getan haben. Ich empfehle auf jeden Fall,
sich zwischen den
Themen etwas Zeit zu nehmen, um die Videos anzuhalten
und einen Schritt zurückzutreten. Erstellen Sie vielleicht ein paar
Materialinstanzen mit unterschiedlichen Farben. Das würde dir
später die Option geben , einen grünen Feind, einen violetten Feind,
einen roten Feind zu haben , was auch immer zu deiner
Vorstellung für das Spiel passt. Ihr könntet auch versuchen, verschiedene Chips und
unterschiedliche Säkularitätswerte zu
vergeben , von ihnen
eine kleine einigen von ihnen
eine kleine Abschusseigenschaft
zu verleihen
oder ihnen einen Farbton zu geben Wenn Sie also wirklich
anfangen möchten, mehr über
die Engine zu erfahren und wirklich zu
verstehen, was vor sich geht, nehmen Sie dies als kleine Hausaufgabe zwischen
diesem und dem
nächsten Thema und versuchen Sie,
ein paar materielle
Instanzen dazwischen zu erstellen ein paar materielle Aber wenn das erledigt ist, ist unser
materielles Zeug gewissermaßen abgedeckt, und wir sind bereit,
mit feindlichem Material zu damit wir mit der Erstellung
unserer neuen Klassen beginnen können. Mithilfe von Material-Instanzen waren
wir in der Lage,
diese neue Variante zu erstellen , ohne irgendeinen Mantel zu
berühren nutzten wir die eine übergeordnete
Materialklasse, die ich zur Verfügung gestellt habe, mit einer ganzen Reihe von Möglichkeiten , aus denen Materialinstanzen
entstehen könnten.
11. 10 - Feindbewegung: Zeit, sich ein paar
Feinde zu machen. Faire Warnung, wir werden das zuerst auf
suboptimale Weise machen. Sie könnten einige
der Optionen in Frage stellen , wenn Sie Unreal kennen Auch das ist
völlig beabsichtigt, und dieses Mal soll es
uns ermöglichen, unsere Arbeit umzugestalten. Refactoring ist Teil jeder echten Entwicklung. Es nimmt die Codebasis oder das
Projekt, das Sie bereits haben, verbessert den Code,
der funktioniert und den Sie behalten
möchten, und entfernt den Code
, den Sie nicht benötigen Ich möchte sichergehen, dass
ich die
Möglichkeit habe , das mit Ihnen durchzugehen
, damit ich Ihnen zeigen kann, wie Sie
den Prozess
etwas schmerzloser gestalten den Prozess
etwas schmerzloser Aber zuerst brauchen
wir natürlich
etwas, das
uns das Refactoring ermöglicht Um das zu tun, werden
wir unsere feindliche Spielfigur erschaffen. Wenn wir also zur
Inhaltsleiste
innerhalb des Blueprints
und des Hauptordners navigieren , klicken
wir mit der rechten Maustaste hier und gehen zur Blueprint-Klassenoption
und erstellen eine neue Wir geben ihr den Namen BP Underscore pawn
Enemy. Geben Sie ein, um es zu öffnen, und
es wird
fast identisch mit dem sein , was wir
bereits für unseren Spieler eingerichtet haben bereits für unseren Spieler eingerichtet Und das ist im Wesentlichen Teil
des ursprünglichen Problems hier. Wir werden
eine Menge Arbeit duplizieren , die
wir bereits erledigt haben Wir werden später die
bessere Lösung durchgehen, aber lassen Sie uns vorerst
einfach auf dem aufbauen, was wir zuvor
mit unserem Player hatten Im Bedienfeld „Komponenten“ wissen
wir also, dass wir
ein neues statisches Netz hinzufügen möchten. Wir nehmen
unser statisches Mesh und legen es im
Standard-Szenen-Root ab. das statische Mesh ausgewählt ist, gehen
wir im Detailbereich
zur rechten Seite
und wählen, ob wir den SM Underscore Plane Hero verwenden möchten Natürlich wollen wir nicht, dass
es dieselbe Farbe hat. Und wenn Sie Ihre Materialien
im Moment nicht im Detailbereich
sehen können , müssen
wir einfach das statische Netz verlassen und
die andere Komponente suchen. Sie das statische Netz erneut auswählen, können Sie sehen, dass wir jetzt
unser Material ausgewählt haben. Element Null ist der
Körper der Ebene. Dies ist die
Hauptfarbe und das Detail. Element eins ist ein
separater Materialschlitz der ausschließlich für
den Holzpropeller vorgesehen Auf diese Weise können wir mithilfe
des Shaders Dinge wie Scheitelpunkte animieren , sodass
der Propeller aussieht, als
würde er sich bewegen der Propeller aussieht, als
würde Ein bisschen komplex
für dieses Projekt, aber die Funktionen sind da, falls Sie es später
erweitern möchten Wenn wir Element Null herunterlassen, wollen
wir nach feindlichem Material suchen
. Und wenn
Sie diese zusätzlichen
empfohlenen Schritte
zwischen den Themen unternommen haben, stehen
Ihnen natürlich empfohlenen Schritte
zwischen den Themen unternommen haben, einige verschiedene
Materialien zur Auswahl. Wir wählen dieses
aus und ihr könnt sehen, dass mein Flugzeug grün geworden ist Es sollte sich
also
vom
Standardmodell und Material des Spielerflugzeugs abheben . Als Nächstes werden wir unserem Feind
etwas Bewegung verleihen wollen . Wenn wir also zum
Event-Graph übergehen, machen
wir dasselbe wie zuvor, entfernen die Acta-Startüberlappung Wir werden das nicht verwenden und
können uns auf das Ereignis konzentrieren. Es ist immer
nützlich, sich daran
zu gewöhnen, die die Sie implementieren werden, wirklich im
Voraus zu
planen Funktionen, die Sie implementieren werden, wirklich im
Voraus zu
planen. Das könnten wir zum
Beispiel tun, indem wir uns das
Projekt mit
den Inhaltsbeispielen ansehen, auf dem wir das aufbauen und
die Kernfunktionen und
Features aufschlüsseln die Kernfunktionen und , die die Gegner haben werden Das erste ist, dass die Bewegung nicht dieselbe ist wie die der Spieler Es gibt kein
falsches Momentum oder diese Art von
Pseudophysik Es ist flotter,
ich bewege mich einfach auf dem Bildschirm nach links,
rechts und runter .
Wir haben also diagonale Bewegungen Auf diese Weise können wir ein
wenig vorausschauend planen , weil
wir auch
Dinge sehen können , wenn der Feind gegen die Wand stößt und er die Richtung
ändert. Wir wissen also, dass wir einige
Seitwärtsbewegungen und Vorwärtsbewegungen ausführen müssen , und wenn sie gegen
Wände stoßen, müssen wir
etwas tun , um
einen Richtungswechsel zu berücksichtigen unsere Projekte auf
diese Weise strukturieren, können wir
ein größeres Problem
logischerweise in
Teilprobleme aufteilen ein größeres Problem
logischerweise in Wenn
wir unsere Projekte auf
diese Weise strukturieren, können
wir
ein größeres Problem
logischerweise in
Teilprobleme aufteilen, die einfacher zu lösen sein werden,
und wir können sie
Schritt für Schritt angehen und wir können sie
Schritt für Schritt Zu Beginn sollten wir also als
Erstes den hinzufügen,
den gleichen
Positions-Offset, den wir zuvor hatten Also suchen
wir vom
EventiceEcution-Pin hier nach
dem Also nochmal, sehr ähnlich dem, was
wir im Player gemacht haben. Wir werden auch
den gleichen Ansatz verwenden wollen , um herauszufinden, wo sich der Schauspieler gerade befindet, und dem dann einen Offset hinzufügen. Also werden wir den Standort des Schauspielers
abrufen verwenden und zuvor sehr
ähnliche Dinge tun. Wir ziehen von hier aus
und
suchen nach Hinzufügen oder drücken einfach
die Plus-Taste. Wir werden
zuerst die Berechnung herausfinden , bevor wir
etwas anschließen, und wenn wir das
fertig und einsatzbereit haben, können
wir das anschließen und testen, um sicherzustellen, dass wir
auf dem richtigen Fuß beginnen Wir wissen bereits, dass wir
keine magischen Zahlen wollen, also können wir genauso gut ein paar
Variablen
erstellen, von denen ich bereits sehe, dass
wir sie benötigen werden Der erste Wert wird ein
Fließkommawert für die Bewegungsgeschwindigkeit sein. Nur ein kurzer Tipp hier. Wenn Sie hier eine neue Variable
erstellen, dies
standardmäßig ein boolescher Wir können diesen tatsächlich behalten. Wir treiben
die
Bewegung voran, indem wir prüfen, ob
wir uns nach links oder
rechts bewegen . Also solange wir das haben? Lassen Sie uns weitermachen und
das B Move Left nennen. Damit wollte ich nur
sagen, dass jedes Mal, wenn Sie eine neue Variable
erstellen, Ihnen ein boolescher Wert zugewiesen
wird Eine Abkürzung, die ich
gerne verwende, da ich weiß, dass ich einen Fließkommawert
für die Bewegungsgeschwindigkeit
benötige, ähnlich dem, was
wir zuvor verwendet haben Wir können an
dieser grünen Stecknadel hier ziehen. Das Grün zeigt an, dass die Delta-Sekunden
ein variabler Wert sind. Fügen Sie diesen Wert in das Diagramm ein und klicken Sie
dann auf Als Variable heraufstufen. Wir geben diesem Beispiel den
Namen Bewegungsgeschwindigkeit. Und das ist nur ein schneller Weg
, um eine Variable des Typs zu erhalten
, nach dem Sie suchen,
ohne
das Drop-down-Menü verwenden und
sie im Diagramm finden zu müssen das Drop-down-Menü verwenden und
sie im Diagramm finden zu Sie können es
so oder so machen, aber es ist einfach nett, wenn wir einen
Vektor benötigen.
Wir können zum Beispiel einen zufälligen Vektor finden, in das Diagramm
einfügen, die Variable
heraufstufen ihn in das Diagramm
einfügen, die Variable
heraufstufen
und ihr dann einen Namen wie diesen geben Das Einzige ist, dass wir etwas aufräumen
müssen, also löschen wir die Knoten Die werden wir noch nicht brauchen. Aber ich wollte nur verschiedene
Möglichkeiten
vorstellen, wie Sie mit dem Grapheneditor der Unreal
Engine
arbeiten Der Vektor war nur ein Beispiel, also wähle ihn aus und lösche auch
diese Variable. Und
wir sind bereit weiterzumachen. die
Bewegung angeht, haben wir uns bereits mit der
Unabhängigkeit der Bildrate befasst und erklärt, warum wir sie brauchen, sodass wir das von Anfang an einbauen können. Wenn wir mit der rechten Maustaste klicken und nach
Get Wild Delta-Sekunden suchen Get Wild Delta-Sekunden können
wir das in unseren nächsten
Berechnungen verwenden. Für die Bewegung werden wir unsere Bewegungsgeschwindigkeit nehmen
wollen. Und wenn wir auf Compile klicken und nur sichergehen, dass es eine Variable gibt, setzen
wir sie auf
etwa 250. Das wäre zum Testen völlig
in Ordnung. Und wie ich bereits erwähnt habe,
benötigen
wir zwei separate Berechnungen. Wir benötigen eine
für die Seitwärtsbewegung und eine für die
Vorwärtsbewegung auf dem Bildschirm Für die Vorwärtsbewegung
können wir unsere Bewegungsgeschwindigkeit nehmen. Wir können das mit
einem Wert multiplizieren, um es umzukehren, also nehmen wir das als negativ an, weil,
wie ich bereits erwähnt habe, unten auf dem Bildschirm ein negativer Wert
ist, und wenn Sie den Bildschirm nach oben
bewegen möchten, wäre
das ein positiver Wert Die Vorwärtsbewegung für
den Feind ist also eigentlich
relativ einfach Und natürlich wollen wir dieses Ergebnis mit
Delta-Sekunden
multiplizieren , um die
Framerate unabhängig zu halten Das wäre also im Grunde unsere Vorwärtsbewegung,
bereit zum Testen Für die Seitwärtsbewegung werden
wir etwas mit
unserem
booleschen Wert anfangen wollen etwas mit
unserem
booleschen Also werde ich mir
die Bewegungsgeschwindigkeit ansehen
und sie die Bewegungsgeschwindigkeit ansehen
und Wir werden hier
etwas sehr Ähnliches machen wollen wo wir
einen Multiplikationsknoten nehmen, aber wir
werden natürlich nicht nur einen oder einen negativen Knoten multiplizieren
wollen nur einen oder einen negativen Wir müssen daraus eine
Art
bedingte Operation Wir werden den
booleschen Wert verwenden ,
entweder wahr oder falsch Wir würden sagen, wir bewegen uns
entweder nach links oder wir bewegen uns nicht nach links,
also bewegen wir uns Wenn Sie das nun versuchen
würden, würde nr
eine boolesche Multiplikation in eine
Fließkommamultiplikation umwandeln eine boolesche Multiplikation in eine
Fließkommamultiplikation Leider werden Boolesche Werte
nur als Null oder Eins gelesen, Null, wenn sie falsch ist,
Eins ,
wenn sie Das
würde natürlich bedeuten, dass das für unseren aktuellen Anwendungsfall nicht funktioniert, denn wenn wir mit
Null multiplizieren , anstatt uns nach links zu bewegen, würde
das nur
die Bewegungsgeschwindigkeit nehmen, diese mit
Null
multiplizieren, was jegliche Bewegung
aufheben würde aufheben Was wir aber tun könnten Wenn wir Alt drücken und hier mit der
linken Maustaste klicken, können
wir einen
sogenannten Auswahlknoten verwenden Also werden wir
von hier aus nach Select suchen. Und wir wollen diese Option
unten haben. Das gibt
uns einige Optionen. Wenn wir hier
mit Dingen wie
Ganzzahlen als Platzhalter arbeiten , können
Sie sehen, dass wir eine beliebige
Anzahl von Ganzzahlen hinzufügen Unabhängig von der Ganzzahl, die Sie hier eingeben, also
jede ganze Zahl, wenn Sie
zum Beispiel eine
ganze Zahl von Eins eingeben, könnten wir ihr
hier einen negativen Wert geben Was wir stattdessen tun wollen, ist dass
wir unseren booleschen Wert Wir werden das hier
in den Index einfügen, den Platzhalter, und Unreal
wird
das für uns in einen booleschen Wert
umwandeln Und wir können sehen, dass
dies jetzt
entweder auf wahr oder falsch gesetzt ist entweder auf wahr oder Die Art und Weise, wie wir das lesen
können, um es intuitiver
und verständlicher zu machen ,
ist, dass wir sagen können, wenn wir uns
nach links bewegen wollen , bewegen
wir uns dann nach links? Wenn das stimmt, muss
der Wert
negativ sein , weil wir einen negativen Wert annehmen
wollen. Wenn das Verschieben nach links
gleich False ist, wir uns
also nicht nach links bewegen, dann soll der Wert eins sein. Im Grunde bewegt sich
das also nach rechts. Das bewegt sich nach links, und das wird positiv sein und
das wird negativ sein. Also eine nette, einfache
Möglichkeit,
einen booleschen Wert zu verwenden, um
im Wesentlichen umzuschalten, ob wir uns nach links bewegen oder Und wenn du
das Gleiche noch einmal machst, nehmen
wir uns unsere Wir nehmen unsere Berechnung hier vor und
multiplizieren das mit den
Delta-Sekunden, um sicherzustellen , dass beide Richtungen unabhängig von der
Bildrate sind, und wir könnten im Grunde
damit beginnen, das einzufügen Also, nur um Ordnung zu halten, werde
ich
hier
vom Vektor-Pin herausholen und nach Make Vector suchen Also die haben wir schon einmal gesehen.
Dadurch erhalten wir nur die drei verfügbaren
Gleitkommawerte. Forward in Unreil
liegt auf der X-Achse. Sideways liegt auf der Y-Achse,
und das ist so ziemlich alles. Wir können das einhängen.
Wir könnten das testen und hätten
einen Feind, der sich bewegt. Wenn wir also auf Kompilieren, Speichern klicken kehren
wir zurück in die Hauptebene, wir können unseren Feind
einfach fallen lassen. spielt eigentlich keine Rolle, wo das
sein wird, solange es nur etwas weiter oben auf dem
Bildschirm vom Player entfernt ist. Ich werde es um 180 Grad auf der Z-Achse
drehen, sodass es
zum Spieler zeigt. Und dann können wir auf Play klicken und wir
sollten sehen, wie sich das
auf dem Bildschirm nach unten bewegt. Wir haben es mit
einer diagonalen Bewegung zu
tun, was der erste
Teil des Problems ist. Damit ist einer
dieser Schritte gelöst. Ich glaube, ich habe hier ein
kleines Problem bemerkt. Es sieht so aus, als würden
wir
durch die unsichtbare Mauer gehen . Also ja, der
Feind hat definitiv die unsichtbare Mauer passiert. Ich denke, es ist gerade
innerhalb der Grenzen. Wie gesagt, etwas, das leicht zu vergessen
ist, und ich habe
es gerade wieder getan, ist, dass wir sicherstellen
wollen, dass wir den Sweep-Schalter
drücken,
also stellen Sie sicher, dass
wir fegen, und wir sollten nicht die gleiche
Funktionalität wie der Spieler haben,
sondern wir stoßen einfach gegen die unsichtbare Perfekt. Das ist also der
nächste Teil des Problems. Das ist der nächste Schritt
, den wir lösen müssen. Wenn der Feind gegen die Wand stößt, wollen
wir diese Information nutzen und die
Bewegungsrichtung ändern Und das haben wir schon
irgendwie eingerichtet. Also haben wir noch unseren Zug übrig.
Wir ändern das auf „Wahr“ und lassen sie sich
relativ zur Richtung des
Feindes nach links bewegen . Kurz bevor wir das
durchgehen,
wollte ich ein paar
Informationen über die allgemeine
Art der Ordnung im Code durchgehen ,
Dinge, die wir hier
verbessern könnten, noch
bevor wir eine große Umgestaltung Ich habe das absichtlich
so angelegt, dass
es lesbarer und verständlicher Aber das ist eigentlich schon
ziemlich schlechter Code bevor wir überhaupt darauf eingehen, was
wir später umgestalten müssen. Als Erstes möchte
ich den Leuten
das Kommentieren vorstellen, was ich
noch nicht erwähnt habe Wenn wir uns
zum Beispiel einen Knoten schnappen und C drücken, können
wir einen Kommentar abgeben Eine Art
Selbstdokumentation uns daran erinnern
soll,
was etwas war, warum und wie es
berechnet wurde. Und es macht die Dinge
auch aus der Ferne
lesbarer . Du
musst nicht alles kommentieren. Möglicherweise haben Sie gesehen,
dass bestimmte Entwickler einen Teil ihrer Codebasis
geteilt haben, und vielleicht waren Kommentare
einfach überall
zu finden Sie haben vielleicht Dinge
wie diese gesehen, bei denen sie
eine Variable oder etwas
ganz Einfaches
wie dieses haben eine Variable oder etwas
ganz Einfaches , das als Bewegungsgeschwindigkeit bezeichnet wird, und sie haben dazu
einen Kommentar gegeben , in dem nur
Bewegungsgeschwindigkeit steht Das ist völlig willkürlich. Es macht nichts.
Es ist nicht nützlich. Und solange du deine Variablen
richtig oder mit einer
guten Absicht
benennst , wissen
wir bereits, dass
das die Bewegungsgeschwindigkeit ist ,
weil das der
Name der Variablen ist. Wir müssen uns also nicht so
äußern. Wenn wir uns das jedoch schnappen und es so
erweitern, dass es
all diese Knoten abdeckt, könnten wir
das so ändern so etwas wie
Richtung bewegen, vorwärts bewegen. Und wir könnten das sogar nützlicher
machen denn wenn wir F zwei drücken, um es
wieder umzubenennen, könnten
wir auch erklären,
warum wir
negative Eins als Multiplikation verwenden negative Eins als Multiplikation weil das
keinen Wert hat Es hat keinen wirklichen
Nutzen, eine Variable zu haben. Es ist also durchaus legitim ,
hier eine magische Zahl
zu haben, aber auf den ersten Blick vergessen
wir vielleicht, warum
eine negative Zahl verwendet wird, also könnten wir
einen Kommentar hinterlassen , der nur beschreibt,
was passiert. Wir können hier also sagen, dass wir diese
Zahl mit einer
negativen Zahl multiplizieren , um Gegner
gezielt auf dem Bildschirm nach unten zu bewegen gezielt auf dem Bildschirm nach unten Dann mach etwas ganz Ähnliches.
Wir könnten uns diese Knoten schnappen , C
drücken und
diesem einen ähnlichen Kommentar geben. Dieser
bedarf eigentlich keiner Erklärung. Ich denke, das ist ziemlich klar. Wenn wir uns nach links bewegen,
nehmen wir den Wert, der sich darauf bezieht, in welche Richtung
wir uns bewegen wollen. Das Wichtigste
dabei ist, dass wir, wenn wir
anfangen, aus dem Diagramm herauszuzoomen, diesen Abschnitt jetzt sehen können, ohne uns den Code
anzusehen Dieser Abschnitt ist für die
Vorwärtsbewegung vorgesehen. Dies ist für Seitwärtsbewegungen. Wenn Sie jemals
schnell
einen bestimmten Teil des Codes finden mussten, um etwas zu
reparieren oder es noch einmal zu überprüfen, wissen
wir genau, wo diese sind. Das ist nur die Verwendung von Kommentaren.
Diese können nützlich sein Sie müssen sie nicht überall
verwenden, aber auf jeden Fall an Orten, an denen Sie glauben, Sie könnten vergessen, was Sie gerade tun, wenn Sie
in ein oder zwei Monaten wiederkommen. Nun, das Hauptproblem, das
wir jetzt beheben wollen, ich werde sie löschen,
ist, dass wir derzeit eine
Menge Duplizierungen durchführen Wir haben
hier G World Delta-Sekunden , die einzeln zweimal
multipliziert Also eine Sache, die wir
tun könnten, und das
war vielleicht nicht ganz
offensichtlich,
aber anstatt die einzelnen
Fließkommawerte hier zu multiplizieren
, können
wir mit aber anstatt die einzelnen
Fließkommawerte hier zu multiplizieren , dem Ergebnis
multiplizieren Wenn wir also die Ergebnisse
dieses Make-Vektors nehmen , den wir erstellt haben, ziehen wir von hier ab und
suchen nach Multiplikation Wir können uns eine unserer Get
World to Delta-Sekunden schnappen,
Strg X drücken, um sie auszuschneiden, und Strg B drücken, um sie einzufügen und
sie dann hier einfügen. Und RL wandelt das in einen
Vektor um, der mit einer Gleitkommazahl multipliziert wird. Wir können diese
Berechnung hier einbauen. Und dann können wir diesen Knoten hier
loswerden, sodass wir dieses Multiple nicht
mehr benötigen und das einstecken. Und wir können diese beiden Knoten
loswerden. Wir brauchen sie überhaupt nicht und stecken das
dann wieder in das Y. Also haben wir jetzt
etwas aufgeräumteres Wir haben nicht so viele
Multiplikationen im Gange. Wir nehmen jetzt den
gesamten Vektor, der
die
Multiplikation für X und Y gleichzeitig
mit unseren Delta-Sekunden berechnet,
um sicherzustellen, dass alles für die gesamte Berechnung
rahmenunabhängig
ist für die gesamte Berechnung
rahmenunabhängig Das war also ein wirklich
schneller Code, aufgeräumt. Wenn wir also auf Kompilieren und Speichern klicken, sollten
wir sehen, dass wir genau
die gleiche Antwort erhalten , also hat sich
nichts geändert Es sieht genauso aus und bewegt sich
genauso wie zuvor. letzte Sache, bevor ich
dieses Thema für
heute Abend verlasse , bevor ich
den Ru-Faktor mache , ist, dass
sich
jeder Feind in
die gleiche Richtung
und mit der gleichen Geschwindigkeit bewegen wird, was ein
bisschen langweilig sein wird. Wenn wir ein
paar Gegner hinzufügen, können
wir einfach die Alt-Taste gedrückt halten und ein Widget hierher ziehen , um es sofort zu
duplizieren. Also halte ich einfach die Lt-Taste gedrückt, die Richtung des Widgets und
ziehe in eine
Richtung , die das Gleiche ergibt,
was wir haben Wenn wir Play drücken, wird es eine Art
Synchronschwimmen
aussehen Sie fahren alle in genau
derselben Richtung, mit derselben Geschwindigkeit. Es wird ein
bisschen langweilig werden. Wenn wir also
zum Startspiel zurückkehren, werde
ich dir zeigen, wie man einen
booleschen Wert zuerst zufällig anordnet, um zumindest
die Richtung zu ändern, in die sich die
einzelnen Gegner könnten. Das ist
eigentlich ganz einfach Wir halten die Alt-Taste gedrückt und ziehen den Boom neben dem
Startpunkt des Events nach links. Oder du könntest es einfach hier auf
die Hinrichtungsnadel setzen. Und dann
wollen wir von der Variablen hier aus dem Pin ziehen. Ich werde nach
etwas suchen, das sich Random Ball nennt. Also werden wir einen zufälligen booleschen Wert
bekommen und das
auf dem BignPlay einstellen So super einfach. Wir haben eine 50-50-Chance, uns nach links oder rechts zu
bewegen. Wenn wir also auf Play drücken, haben
sie sich alle dafür entschieden, in dieselbe Richtung zu gehen, und
sie haben es wieder getan. Wir können sehen, dass es eine gewisse
Randomisierung gibt, also ist das gut. Sie werden nicht immer genau dieselbe Richtung
einschlagen Also eine kleine
Lernübung für dich. Der Ansatz,
einen Random Float zu machen , ist
etwas anders, aber nimm dir ein paar Minuten Zeit, pausiere
das Video und schau, ob du etwas Ähnliches
mit der Bewegungsgeschwindigkeit umsetzen
kannst. also die
Bewegungsgeschwindigkeit ein und schauen Sie, ob Sie einige
eingebaute Funktionen finden , die UNR möglicherweise benötigt,
damit wir einen zufälligen Wert in
die Gleitkommazahl
ziehen Ihr könntet diesen Wert nach dem Zufallsprinzip
zwischen etwa 250, was derzeit unsere
Standardeinstellung ist, und vielleicht 500
anordnen, sodass sich jeder Feind einer etwas
anderen Geschwindigkeit
bewegt Pausiere das Video, probiere
es aus und fange an zu testen, wie gut
du dich
mit dem Blueprint-System Okay, also werde ich die Art und Weise
durchgehen, wie ich das gemacht
hätte Wenn wir das anschließen und
Sie das
hoffentlich ausprobiert haben, denn auch hier werden
diese wirklich wertvoll sein, um tatsächlich zu lernen, wie
man Baupläne benutzt, anstatt
nur meinen Schritten zu folgen Aber damit wir zumindest
den gleichen Code haben oder
etwas, von
dem wir ausgehen können Ich würde mir
meine Flugvariable hier schnappen. Wir werden
eine zufällige Wohnung bekommen. Das ist das einzige, was Sie
vielleicht
abgeschreckt hat, und Sie
wollten vielleicht ein paar verschiedene Optionen
ausprobieren. Aber anstatt einfach Random Float zu
verwenden, was
Ihnen einfach eine beliebige Zahl geben würde, könnte
das sehr
schnell oder sehr, sehr langsam sein. Also nicht allzu brauchbar. Du hättest auch Dinge wie Random Float From Stream ausprobieren können. Aber die, die ich verwenden
würde, wäre dieser zufällige Float-in-Range-Wert. Wenn wir also diesen
auswählen, gibt es uns nur zwei Punkte, die wir
aus unserem Minimum auswählen können, was ich sagen
würde, 250, und wir verdoppeln das
auf 500 als Maximum. Einige Flugzeuge könnten also mindestens 250
erreichen, andere vielleicht 500 oder einen Wert
dazwischen . Und da haben wir's. Wir können sehen, dass sie alle
mit völlig
unterschiedlichen Geschwindigkeiten
beginnen , was die
Dinge wieder ein bisschen
interessanter macht , wenn wir
sie hinzufügen und sie im Level richtig
funktionieren, von den Wänden
abprallen
und solche Dinge Damit bewegen sich die Feinde
jedoch und sie
kollidieren mit den Wänden Sie springen noch nicht ab und würden auch nicht mit dem
Spieler interagieren Bevor wir uns mit dem großen Ruf-Faktor
befassen, werden wir uns als Nächstes mit
der Kollisionserkennung
befassen, bei der Dinge tatsächlich passieren wenn sich Objekte berühren
12. 11 - Feindkollision: Habe Feinde, die sich bewegen,
aber auf nichts reagieren. Wenn ein Feind auf etwas
trifft,
müssen wir im Idealfall überprüfen, was es ist. Ist es eine Wand, und wenn ja,
dann ändere die Richtung. Wenn es der Spieler ist, können wir tatsächlich wieder aus dem
Beispielprojekt ersehen, dass er
sich selbst Schaden zugefügt hat und zerstört wird Wir werden also
den Feind automatisch zerstören,
wenn er den Spieler berührt. Die Projektile
regeln sich von selbst, also werden wir später
darüber nachdenken Es wird kein
Problem sein, das hier zu berücksichtigen. Eine Sache, die es zu erwähnen gilt, ist, dass
das unreale Kollisionssystem flexibel und leistungsstark
ist, was leider bedeutet, dass
es etwas komplex Zumindest wenn man anfängt, damit zu
arbeiten, nachdem man
ein paar verschiedene Iterationen
verschiedener Dinge ausprobiert ein paar verschiedene Iterationen
verschiedener hat, die
man damit machen möchte, denke
ich, dass es ziemlich schnell funktioniert
und es ein recht komfortables
System ist, mit denke
ich, dass es ziemlich schnell funktioniert
und es ein recht komfortables
System ist, dem man arbeiten kann Lassen Sie uns also zurück zum
Pan-Feind navigieren. Wir können das zum
Testen verwenden. Wenn wir uns das statische Netz schnappen und den Kollisionsbereich
auf der rechten Seite
öffnen, scrolle
einfach hier nach unten und
finde unsere Kollisionskategorie. Wenn wir das runterlassen, können wir
das Kollisions-Preset hier sehen .
Wir lassen das hier fallen. Wir können sehen, dass es auf
Blockieren oder Dynamisch eingestellt ist. Das ist also unser aktuelles
Kollisions-Setup. Der Objekttyp ist hier ebenfalls auf World Dynamic
gesetzt, das ist
also der
Kollisionskanal, als den
dieses Objekt identifiziert. Deshalb hält der Feind an
den Wänden an, wenn wir auf Play drücken . Dies ist eine physikalische oder physische Kollision, bei der sich beide gegenseitig
blockieren
und versuchen, nicht denselben physischen Raum zu bewohnen Nun, wenn wir
das weglassen und auf
Überlappung oder Dynamisch
ändern, also das Äquivalent,
aber für Überlappungen klicken
wir auf Kompilieren
und spielen schnell Wir werden sehen, dass sie jetzt wieder durch die Wände
gehen Jetzt, unter der Motorhaube, wird
etwas abgefeuert. Es wird eine Nachricht
gesendet, die besagt, dass diese drei Feinde
gerade die Mauer überlappt haben Da es sich jedoch nicht um eine
physische Interaktion
handelt, handelt es sich lediglich um eine Benachrichtigung und im Wesentlichen um eine
Beobachtung, dass
sie denselben Raum durchquert Du kannst dir das Blockieren
gegen Überschneidung quasi wie
ein Rennspiel
vorstellen . Wir wollen, dass die Wände und
die Umgebung die Fahrzeuge blockieren. Wenn du mit ihnen
zusammenprallst, wirst du angehalten. Wir wollen, dass sich die Checkpoints
überschneiden. Wir wollen natürlich
wissen, ob ein Fahrzeug einen Checkpoint
passiert hat und zu welcher Uhrzeit das passiert ist,
aber wir möchten nicht, dass diese
Checkpoints die
Fahrzeuge
physisch am Weiterfahren hindern Das wäre nur ein
bisschen nervig. Wenn wir also zurück
zu den Bauernfeinden gehen, dann nur
, um zu zeigen,
wie sie anders funktionieren Wir haben auch die dritte
Option. Wir haben die Option Ignorieren. Nun, das ist
wahrscheinlich ziemlich offensichtlich. Dadurch wird dies so eingestellt, dass
alle Arten von Kollisionen ignoriert werden. Das könnte man zum Beispiel tun, indem zur Option Keine
Kollision
geht, und obwohl es so
aussieht, als ob bedeutet, dass
es auf Blockieren gesetzt ist, steht das tatsächlich im Code liest die Option Ignorieren. Jetzt werden
keine Nachrichten mehr abgefeuert. Niemand weiß wirklich, dass das
Flugzeug es durchquert. Und das ist gut für Objekte , die nicht zur Aufrufliste und
zur
Kollisionsprüfung hinzugefügt werden müssen Aufrufliste und
zur
Kollisionsprüfung . Also
gut für die Leistung. Aber im Allgemeinen
werden wir mit Überlappung oder
Block arbeiten , je nachdem, wofür
wir sie benötigen. In diesem Fall können
wir dies auf Standardeinstellung zurücksetzen, die blockdynamisch
ist. Ich habe das getan, indem ich
einfach hier gedrückt habe. Du kannst den kleinen Pfeil sehen. Wenn Sie jemals
Eigenschaften auf ihre Standardeinstellungen zurücksetzen wollten, können
wir einfach darauf drücken,
und schon ist es wieder
so wie es war, bevor wir die
Dinge optimiert haben. Da das statische Mesh
noch ausgewählt ist, möchten
wir
im Detailbereich noch weiter nach
unten
scrollen im Detailbereich noch weiter nach
unten Und wir haben diese Optionen
hier, die Ereignisse. Nun, wir werden sie nicht alle
durchgehen. Die Dinge, an denen wir wieder
am häufigsten
interessiert sein werden, werden
die einkomponentigen Treffer sein. Das passiert, wenn sich zwei
Dinge physisch gegenseitig
blockieren und eine
Komponente anfängt, sich zu überlappen,
und manchmal, wenn sich das Ende
einer Komponente überschneidet. Diese werden aufgerufen, wenn
zwei sich überlappende Objekte jedes Objekt
hineinkommen oder es verlassen Wir können also die Endüberlappung ermitteln,
denn wie wir gesehen haben, ermöglichen
überlappende Kollisionen es den Objekten, denselben physischen Raum zu bewohnen Hier wollen wir
unseren Wall Check an
die Funktion „On Component Start
Hit“ binden die Funktion „On Component Start
Hit Dadurch entsteht für uns ein neues
Kundenereignis, eine Funktion, die jedes Mal aufgerufen wird, wenn eine Kollision
auf unserem statischen Netz erkannt wird. Wenn Sie sich erinnern,
jedes Mal, wenn wir unsere Klasse
erstellt haben und wir
diese Standardfunktion hatten , brauchten
wir die Actor-Hit-Funktionsprüfung
,
die wir immer gelöscht haben, wirklich nicht . Das war im Grunde
eine ähnliche Sache, aber wie ich schon erwähnt habe,
für die gesamte Klasse. Jetzt können wir genauer
nachschauen, ob nur das statische
Mesh getroffen wurde, und nachschauen, ob nur das statische
Mesh getroffen wurde, dann können wir danach
etwas tun. Diese Knoten liefern tatsächlich
ziemlich viele Informationen. Wenn
wir zum Beispiel hier mit der rechten Maustaste auf
den Link zur Trefferstruktur klicken und die Option zum Teilen
der Struktur
auswählen , können wir zurückbekommen können jedes Mal, wenn uns etwas
trifft oder
wir auf etwas
stoßen, alle Informationen
sehen, die wir . Wir können die Uhrzeit
herausfinden. Wir können herausfinden, ob die
Sperrung erfolgreich war. Wir können den tatsächlichen
Ort des Treffers und den Aufprallpunkt sehen. Wir können daraus Dinge wie
die Rotation, die Art des physischen
Materials und so weiter ableiten. Das alles brauchen wir
momentan nicht, aber es ist nützlich, wenn du anfängst, fortgeschrittener zu werden und dich mit Unreal vertraut zu machen.
Wenn du ausgefallene Dinge
wie
Geschossdurchschlagskraft oder
die Art von Ergebnissen machen willst Dinge
wie
Geschossdurchschlagskraft oder , die entstehen,
wenn zwei Dinge kollidieren, kannst
du definitiv
hier eintauchen und sehen, was verfügbar ist Klicken Sie einfach mit der rechten Maustaste auf einen
dieser Pins und
kombinieren Sie den Struktur-Pin neu, nur um diesen Knoten wieder aufzuräumen Die wichtigsten Dinge, mit denen wir normalerweise arbeiten, wenn
wir
mit Kollisionen arbeiten, sind, dass wir ein paar
Informationen über
den anderen Akteur
wissen wollen , weil wir im Moment nicht
wissen, was uns getroffen hat Wir wissen nur, dass wir
getroffen wurden, wenn das aufgerufen wird. Es könnte die
Mauer sein, es könnte
ein Spieler sein , es könnte ein weiterer Feind
sein. Es wird also
nützlich sein, das später zu lesen, also können wir es genauso gut jetzt
zu einer Variablen machen, und das nennen wir
One-Hit-Schauspieler. Und aus diesem Grund wollte
ich mir nur einen kurzen Moment Zeit nehmen , um verschiedene
Möglichkeiten aufzuzeigen, wie Sie
dieses Problem
lösen könnten, indem Problem
lösen Sie
herausfinden, was uns getroffen hat. In vielen Studentenprojekten,
die ich überprüfe und mit denen ich arbeite, sehe
ich eine Menge Casting, weil viele sehr einfache
Tutorials, die Sie
online finden , dazu neigen, einfach zu zeigen, wie man auf andere Objekte überträgt, weil es eine schnelle und einfache Möglichkeit ist, Informationen
zu erhalten. In unserem Projekt ist das, was wir tun,
relativ klein und
einfach, sodass es
eigentlich nicht so schlecht aussehen würde. Aber wenn Sie diesen
Weg gehen würden, hätten
Sie vielleicht etwas, das
am Ende so aussieht. Ich werde nur einen kurzen
Schnitt machen. Schneller Cutaway Wie gesagt, das ist im Grunde das,
was du am Ende haben würdest. Die Art und Weise, wie eine Besetzung funktioniert, und ich möchte Ihnen das Casting trotzdem vorstellen, die Art und Weise, wie Casting
funktioniert, ist, dass
wir, wenn wir mit
unserem anderen Schauspieler arbeiten, wenn wir hier
über der Stecknadel hervorheben, tatsächlich sehen können,
was zurückgegeben wird. Also drücke ich auf Kompilieren. Und ich bewege den Mauszeiger über die Informationen zu den anderen
Schauspielern Dies zeigt uns
, dass dies eine Referenz für einen Schauspieler darstellt. Der Grund dafür ist, dass, wenn
wir uns an die Vererbungshierarchie
von
UnrelEngine erinnern ,
alles, mit dem wir
in der Welt interagieren
können , das physisch präsent ist,
diese Transformation, von
einem Akteur oder einer höheren
Ebene sein muss Indem wir hier also eine PIN angeben, die das grundlegendste Objekt ist , das wir
auf
der Welt finden können, einen Akteur, können
wir sicherstellen, dass wir alles
überprüfen
und uns dann gezielt darauf konzentrieren können können
wir sicherstellen, dass wir alles
überprüfen
und uns dann gezielt darauf konzentrieren können, welche Art von Akteur, welche zusätzlichen Funktionen
und Merkmale Nun, die Art und Weise, wie Sie das
tun könnten, oder ich habe das
oft in vielen
Tutorials gesehen , ist, dass sie Ihnen zeigen, wie Sie so etwas wie
den Schauspieler
nehmen können, den Sie getroffen haben,
und wir casten dagegen. Und was das ist, das ist
im Grunde eine Frage. Es heißt, dieser generische Akteur, ich kann sehen, dass der generische
Akteur existiert. Ist es speziell die
Art der Bauernbasis, die für uns der Spieler ist Wenn es so ist, also
das stimmt, ja, es ist ein Pfannenboden, dann
mach das hier. Also würden wir die Funktion als
spezifisch für die Spielerklasse bezeichnen,
die, wie ich bereits erwähnt habe, darin besteht, dem
Spieler Schaden zuzufügen
und sich dann selbst abzulenken Wenn nicht, also wenn
wir diesen Check gemacht haben
und es wieder herauskommt, dass es nicht
der Spieler ist, den wir getroffen haben, dann haben wir etwas anderes getroffen.
Also würde es zu Besetzung F gehen und dann wirst du sehen, wie
die Leute eine zweite Besetzung machen. Wir sind also wie ein
Wasserfall von Castings
, der chaotisch und wild ist Und wenn wir uns mit
viel größeren Projekten befassen, können
Sie sehen, dass wir nur
drei Dinge zu beachten haben Aber wenn wir verschiedene
Dinge wie Pickups und Hindernisse und viele andere Dinge haben, die wir
vielleicht berücksichtigen müssen, werden
wir einen viel
größeren Wasserfall bekommen Aber das nächste, was Sie vielleicht noch einmal
tun werden, ist, dass wir wieder
reinkommen und
sagen, dass das generische Objekt, der generische Akteur,
speziell ein Feind ist Wenn ja, dann
machen wir die feindlichen Sachen,
wobei ich im Moment noch nicht entschieden
habe, wie
wir mit Feinden umgehen sollen. Ich denke, sie werden sich
schrittweise gegenseitig durchgehen, aber wir müssen diese Funktion erfüllen. Wenn nicht, dann schauen wir nochmal nach. Dann könnten wir
auf etwas wie die Sperrlautstärke wechseln, wenn die
Dinge die Lautstärke blockieren,
wenn das stimmt, dann ja,
wir sind wenn das stimmt, dann ja, gegen eine Wand gestoßen und
wir werden die Richtung ändern. Das ist also eine Möglichkeit, wie
Sie sehen können, wie es gemacht wird. Es mag so gewesen sein, wie
Sie
es in Betracht ziehen , wenn Sie wissen,
was Casting bewirkt. Und ich wollte nur
einen allgemeinen Überblick darüber geben warum wir das nicht
tun werden und warum wir versuchen sollten,
dies nach Möglichkeit zu vermeiden Es ist eine weitere Sache, die
sich sehr leicht wiederholen lässt, wie die allgemeine pauschale
Aussage, niemals ein Häkchen zu verwenden Sie werden die Leute sagen hören, benutze
niemals Casting. Auch das ist
wirklich sehr vereinfacht. Es gibt eine Reihe von Gründen
, warum wir
Casting verwenden möchten , wo es absolut sicher und
sehr billig ist. Es liegt etwas außerhalb
des Kontextes für dieses Thema. Im Moment werden
wir einfach sagen,
ich werde diese löschen. Wir werden das nicht nur tun, weil
wir diesen kaskadierenden
Wasserfall-Effekt
nicht wollen Wo wir pro Objekt prüfen. Um die Dinge zu vereinfachen, werde
ich das
für dieses Projekt
in zwei verschiedene Dinge aufteilen, nach denen wir
eigentlich suchen wollen. Wir wollen nach der Mauer suchen, und wir wollen nach dem menschlichen Spieler
suchen. Ich denke, nur für das Spieldesign
und damit es sich besser anfühlt, werde
ich die Gegner durcheinander bewegen lassen ,
sodass der Spieler nur noch überlegen muss, in
welche Richtung sie zwischen dem
Aufprall und den Wänden bewegen. Das macht
sie also wirklich, wirklich einfach. Wir können zunächst eine wirklich einfache
Überprüfung durchführen. Wir können mit der rechten Maustaste
in das Eventdiagramm klicken und nach Get player pawn
suchen Das ist also eine eingebaute Funktion. Die Unreal-Engine
verfolgt immer , was
als Spielerbauern eingestuft wird, also
das, was der
menschliche Spieler kontrolliert Wenn wir also auf
Play drücken, wäre das das blaue Schiff . Also
, was können wir hier tun? Dadurch wird Casting vermieden, was eine nützliche Sache
ist. Wir müssen nicht alle Informationen aus
der anderen Klasse herausholen. Das bedeutet auch
, dass wir, wenn wir mehr
Funktionen hätten , wie die Möglichkeit,
den Spieler zwischen fünf verschiedenen
Bauplanklassen
mit völlig einzigartigen Schiffen
wählen zu lassen wählen ,
den Spieler zwischen fünf verschiedenen
Bauplanklassen
mit völlig einzigartigen Schiffen , nicht jedes einzelne
Schiff überprüfen müssten jedes einzelne
Schiff Wir müssen nur wissen, dass es sich bei
dem Ding, das wir
getroffen haben , um ein Spielerschiff handelt, und das würden wir
anhand dieser Überprüfung hier wissen Wir können also aus diesem Mülleimer ziehen und nach zwei Gleichheitszeichen suchen, also nur nach zwei Gleichheitszeichen. Und ich werde das einfach aushängen
, um es ein
bisschen lesbarer zu machen Schließ das wieder an.
Wir können einfach sagen, ist der Erfolgsdarsteller? Also, die Sache, mit der wir
gerade kollidiert
sind, ist das auch genau das, was der Spieler
kontrolliert? Wir können dann hier von
unserem Booleschen Wert ziehen. Wir können nach einer Filiale suchen.
Wir können das in unseren Ausführungs-Pin stecken und das ist eine nette Vereinfachung des Codes, gegen den
wir suchen müssen Also, wenn das Ding, das
wir getroffen haben, der Spieler ist, wenn das stimmt, dann
werden wir unseren Schaden anrichten Also wollen wir vielleicht nur eine gedruckte Zeichenfolge hier haben, um uns
daran zu erinnern, zurückzukommen. Also werde ich eine gedruckte
Zeichenfolge verwenden, weil wir noch keine
Schadensfunktionen
und ähnliches haben ,
aber ich mache das groß und fett, damit wir jedes
Mal, wenn das passiert, daran erinnert werden,
zurückzukommen und den Code zu ändern. Das wäre also der Punkt, an
dem wir dem Spieler Schaden zufügen. Und dann ist die Zerstörung von uns selbst
eigentlich ganz einfach Wir müssen nur die
Funktion Destroy Actor aufrufen. Wir können das hier
reinwerfen. Und das ist tatsächlich Teil des
Funktionsumfangs, der bereits fertig ist. Wenn ich also die
feindlichen Flugzeuge abfliegen lassen würde, wären
sie
bereit, Schaden anzurichten, obwohl wir sowieso noch keine Gesundheit
und alles haben, und dann werden sie sich selbst
zerstören. Nun,
wieder vom falschen Zweig,
eigentlich ganz einfach, der uns jetzt sagt,
dass, wenn wir den Feinden
erlauben, sich gegenseitig zu
durchdringen, dann machen wir uns
darüber keine Sorgen, was bedeutet, dass wenn wir auf etwas anderes stoßen, das eine Mauer sein
muss. Das ist die einzige
andere Sache, mit der wir in diesem Projekt kollidieren
können Also können wir das hier von
der falschen Filiale aus machen. Und was wir
tun wollen, ist, dass wir den richtigen Weg einschlagen. Also werde ich das an den
Execution-Pin anschließen. Schieb das hier runter. Und noch einmal, nur um zu überlegen, wie
Sie das angehen könnten. Wenn Sie sich
an den Codefluss gewöhnen, könnten
Sie versucht sein, einen Banchon
zu werfen also greife ich einfach
nach der Ausführungsnadel Dadurch werden sie automatisch miteinander
verbunden, und Sie könnten
so etwas tun Überprüfen Sie also den Wert von Move Left. Bewegen wir uns gerade nach links? Falls ja. Wenn also links wahr ist, dann wollen
wir, dass das falsch ist, und wenn links nicht wahr ist, dann wollen wir, dass das umgedreht und in wahr umgewandelt wird Also das ist definitiv eine
Möglichkeit, wie du es machen könntest. Aber auch hier möchte ich nur zeigen, wie wir das
auf nette Art und Weise tun können. Also, wenn wir das hier wieder anschließen, können
wir sie aus dem Weg räumen. Ich lösche
sie hier
aus unserem booleschen Wert,
ich ziehe
und
suche nach etwas, das als Knotenkugel oder nicht boolescher Wert bezeichnet
wird Knotenkugel oder nicht Das
funktioniert im Grunde so,
wenn das wahr ist, wird falsch zurückgegeben Wenn das falsch ist,
wird wahr zurückgegeben. Wir können also diesen Wert nehmen
und er wird im Grunde
immer
umkehren, egal, ob der
aktuelle boolesche Wert aktiviert ist Wenn wir uns also nach links bewegen, bewegen
wir uns nach rechts, und wenn wir uns nach rechts bewegen,
bewegen wir uns nach Also eine nette, einfache, einzeilige
Version dessen, was eine zusätzliche
Zweigstruktur
hätte sein können , die wir nicht benötigt haben. Und
das ist so ziemlich alles. Das bedeutet, dass unsere Gesundheit berücksichtigt
wird , wenn wir etwas später zu
diesem Thema kommen, die Zerstörung durch den
Kontakt mit dem Spieler
und das Umkehren der
Richtung, wenn wir gegen eine Wand stoßen Wenn wir also wieder reingehen und Play drücken, können
wir sehen, dass sie gerade voneinander
abprallen. Ich denke, das wäre eine
absolut gute Implementierung, ganz bei Ihnen Und wenn sie dann den Spieler
treffen,
können wir oben
links sehen, dass
die Druckzeichenfolge aufgerufen
wurde und sie entfernt werden Also wird es wieder
auf Design ankommen. Wenn Sie möchten, dass sie voneinander
abprallen, können
wir diese
Funktionalität beibehalten Wenn Sie möchten, dass sie sich gegenseitig
durchdringen, werde
ich das zeigen, wenn
wir uns etwas später näher mit
den Kollisionsthemen befassen Aber das ist alles. Wir haben jetzt
eine funktionierende Implementierung. Und wie gesagt, der Grund dafür,
dass das funktioniert, ist jedes Mal, wenn in dieser Klasse jetzt eine Kollision erkannt wird, diese automatisch ausgelöst
wird. Es verfolgt all
diese Informationen
darüber, was getroffen wurde
und was passiert ist, und dann
extrapolieren wir aus diesen Informationen, was nur
für unser Projekt relevant ist Wir werden
etwas ziemlich
Cleveres mit den Projektilen machen , sodass wir auch nicht mit
Projektilen rechnen müssen , wenn sie
den Feind treffen Das wird
im Projektilcode geregelt. Also alles, was der Feind
wissen muss , ist der Spieler
und die Wände, was eigentlich ein weiteres
Programmierprinzip ist, das wirklich
wichtig ist, besonders in Sprachen wie C plus
und Blueprint, weil es im Grunde immer noch auf
diesem Workflow im echten Engem basiert diesem Workflow im echten Das allgemeine Konzept ist
, dass wir versuchen,
eine Klasse so spezifisch
und klein wie möglich zu gestalten eine Klasse so spezifisch
und klein wie möglich Es soll also eine
Sache und eine Sache gut machen. Ein Beispiel für schlechten Code
in einer gegnerischen Klasse
wäre , nachzuverfolgen, welche Pickups
der Spieler möglicherweise in der Hand gehalten hat, nach Dingen zu
suchen, wie zum Beispiel, welches
Projektil ihn gerade getroffen hat, wie viel Schaden das
Projektil anrichten sollte und solche Dinge, denn
das ist die umgekehrte Logik Alles, was
mit dem Schaden durch ein
Projektil zu tun hat, sollte im Projektil gespeichert
werden
, und diese Informationen Der Feind
sollte nur Dinge berücksichtigen, die mit dem
Feind zu tun haben, und dafür verantwortlich Und in diesem Fall bewegt sich das und prallt gegen Wände, ein
sehr einfaches Gebilde. Also nur ein kurzer
Blick auf das, was als
sauberes Programmieren bezeichnet werden könnte , ist diese
Kapselung , um sicherzustellen, dass Ihre Klasse im Allgemeinen die Regel ist, wie gesagt, eine Sache zu tun und eine
Sache Aber wenn das alles vorbereitet
und bereit ist, haben
wir jetzt eine komplette Klasse, die zur Umstrukturierung
bereit ist Als Nächstes werden wir uns mit dem Thema Erbschaft befassen. Dies wird eine bessere
Methode sein, um mit vielen
gemeinsam genutzten Codes und
Funktionen umzugehen , die wir derzeit im
Feind und im Spieler sehen. Wir haben
viel Arbeit dupliziert, also wird es an der
Zeit sein, das zu beheben
13. 12 - Vererbung BasisKlasse: Zeit, das Chaos zu beheben
, das wir angerichtet haben. Wir haben das Mesh-Setup dupliziert. Wir gehen unterschiedlich mit
Bewegungen um, folgen
aber
zweimal
derselben Strukturlogik . Das scheint im Moment
klein zu sein. Aber wenn wir
Gesundheit, Zerstörung und
Effekte hinzufügen, wird sich das alles
noch verschärfen. Jedes gemeinsame Feature bedeutet für uns
doppelte Arbeit, aber möglicherweise
auch doppelt so viele Bugs. Auch innerhalb der
Bauerklasse verwenden
wir derzeit das
gesamte Mesh als Collider, was
für diese Art von Spiel wirklich nicht ideal Die meisten
ICD-Actionspiele wie dieses verwenden
einen Trick, damit sich
der Spieler ein
bisschen schlauer fühlt, als
er es tatsächlich einen Trick, damit sich
der Spieler ein
bisschen schlauer fühlt , als
er Wenn du denkst, dass du etwas gekonnt
ausgewichen bist, aber eigentlich einfach
vorbeigeschrammt bist, fühlt sich das gut an,
aber das liegt daran, dass dein
Collider wahrscheinlich
ein bisschen kleiner ist als der Collider des ein bisschen kleiner Wir werden so etwas
implementieren wollen, damit sich die Interaktion unserem Spiel wirklich
interessant anfühlt mit
unserem Spiel wirklich
interessant anfühlt. Nur eine geringfügige Form
psychologischer Manipulation, aber dadurch fühlt sich das Spiel fair an, auch wenn die Mathematik etwas anderes sagen
würde. Wir lösen
das Problem, indem wir
statt des Meshs einen Sphere Collider als neue Route Das Netz dient lediglich als
völlig kollisionsfreie Dekoration Beide Klassen benötigen dies, also können
wir es genauso gut nur einmal erstellen
und Komponenten und Funktionen für
alle Klassen
gemeinsam solche Komponenten und Funktionen für
alle Klassen
gemeinsam nutzen. Das machen wir
mit etwas, das man Vererbung nennt. Ich habe bereits erwähnt, dass
die UnrelEngine
eine sehr stark
auf Vererbung basierende Software ist , also werden wir die
gleichen Konventionen befolgen Es bedeutet im Grunde, dass
wir etwas einmal
in einer sogenannten
Eltern- oder Basisklasse codieren können in einer sogenannten
Eltern- oder Basisklasse Wir können daraus dann untergeordnete
Klassen machen,
die alle
Komponenten, Funktionen und
Systeme,
die wir eingeben, erben Funktionen und
Systeme,
die wir eingeben, Wir haben zum Beispiel gesehen, wie die
Schauspieler eine Transformation vorgenommen haben,
eine Rotationsskala für ihren Standort in der Welt, und dann nehmen Spielfiguren
diese Informationen
und bauen darauf auf, indem sie
ihnen
die Mechanik gegeben haben , die sie
besitzen können, und viele
andere und dann nehmen Spielfiguren
diese Informationen
und bauen darauf auf, indem sie
ihnen
die Mechanik gegeben haben, die sie
besitzen können, und viele
andere Dinge.
Das ist genug geredet Sehen wir uns das in Aktion an.
Lassen Sie uns also unsere neue Basisklasse erstellen, die uns
helfen wird, das
System in der Praxis zu sehen. Wenn wir zu den
Blueprints und dem Core-Ordner zurückkehren, werden
wir
etwas völlig Neues erstellen Mit einem Rechtsklick in das
Fenster gehen wir wieder zur Blueprint-Klasse und
erstellen eine brandneue Ich werde das jetzt
nicht mehr Pawn underscore
irgendwas heißen, auf BP underscore
plane base statt Pawn umstellen nicht mehr Pawn underscore
irgendwas heißen, auf BP underscore plane base Es werden alles
Flugzeuge sein, also können wir genauso
gut unsere
Namenskonvention hier klarstellen In unserer neuen Klasse
gehen wir zu den Komponenten und fügen die
Kugelkomponente hinzu, die ich erwähnt habe. Wir suchen hier nicht nach
diesem. Dies ist eine solide visuelle Drei-D-Kugel. Wir wollen nur eine kollidierende Verbindung. Wenn wir nach
dem Wort Kollision suchen, können
wir hier sehen, dass wir
ein paar verschiedene Optionen haben Wir wollen unseren Sphere Collider, der das genau hier anwenden wird, und wir können das
Gleiche tun, was wir zuvor getan haben Wir können
das auf das Standard-Szenen-Root ziehen , um es zu unserer
neuen Root-Komponente zu machen Wir können dann zurück
zur Schaltfläche Hinzufügen gehen. Wir wollen immer noch unser statisches Netz. Das wird einfach nicht
mehr
mit Kollisionen umgehen können . Das
Gleiche werden wir wieder tun. Wir gehen hier zu unserem statischen
Mesh und wählen unseren SM
Underscore Plane Hero Wenn das statische Netz
immer noch ausgewählt ist, können
wir zum
Kollisionsbereich hier drüben gehen, und wir können einfach dieses Drop-down-Menü
verwenden und ihm
sagen, dass es keinerlei
Kollisionserkennung durchführen soll Wir können auch die Ereignisse zur Erzeugung von
Überlappungen ausschalten. Dadurch wird nur sichergestellt, dass zu keinem Zeitpunkt
etwas mit dem statischen
Netz verglichen wird. Perfekt, weil wir wollen, dass
das visuell ist. Das bedeutet, dass es nicht zum Kollisionsstapel
hinzugefügt werden muss . Es sitzt einfach
da und wird gerendert. Wenn wir auch unseren
Sphere Collider auswählen , können wir hier ein
paar Änderungen vornehmen. Wenn wir das wieder auf
der rechten Seite im Kollisionsbereich platzieren, wollen
wir das von Überlappung oder Dynamisch ändern, und wir können das sogar
deutlicher als das machen,
und wir werden sagen, dass das als Bauernkollision
eingestuft Wir werden also sehen, dass
dadurch die
Kollisions-Voreinstellung auf Pfandhaus Kollisions-Voreinstellung auf Pfandhaus Der Objekttyp wird jetzt wie eine Schachfigur
verfolgt, und hier wurden einige
Dinge getan. werden es nicht dabei belassen, wenn wir volle Flexibilität wollen Wir nehmen dies als
Standardvoreinstellung, aber wir können es anpassen
, indem wir es erneut herunterklappen und Benutzerdefiniert
auswählen. Wir haben
dieses Set also immer noch als Spielfigur. Wir haben immer noch die Einstellungen zur
Kollisionsaktivierung, wie wir wollen, und wir haben all
das standardmäßig eingestellt Vielleicht möchten wir aber wieder
reinkommen
und dafür sorgen, dass aber wieder
reinkommen
und dafür sorgen sich
nicht mit anderen Figuren überschneidet
oder andere Figuren blockiert, etwas anderes
mit der statischen Welt
machen, und wir haben jetzt die
Möglichkeit,
diese zu ändern , wenn wir wollen.
Das werden wir jetzt nicht tun Wir werden das tun, indem
wir testen und schauen, wie sich das Projekt entwickelt. das erledigt ist, befinden wir uns jedoch in einer wirklich guten
Position Jede untergeordnete Klasse wird dieses Set
nun erben. Das bedeutet, dass wir das einmal
konfiguriert haben und nie wieder darüber nachdenken
müssen Jetzt können wir uns also auch
unsere gemeinsamen Funktionen im Event-Grab ansehen, die Art von Dingen
, die wir zwischen den beiden Klassen
teilen möchten . Wie immer nehmen wir
das Event, das mit der Überlappung beginnt,
und löschen dieses Event. Und was die Bewegung angeht,
gibt es ein paar Dinge zu beachten. Noch einmal, rein auf
der Grundlage der Nachbildung
des Beispielprojekts versuchen
wir, ein gewisses
Maß an Parität zu erreichen . Es gibt
ein kleines Feature wenn man sich wirklich
anschaut, was passiert wenn sich die Flugzeuge und
der Spieler nicht bewegen
oder die
Bewegung nicht aufeinander abstimmen, wenn sie ihn spawnen. Sie spielen eine kleine
Animation ab. Sie animieren den Bildschirm
vielleicht für ein oder zwei Sekunden nach
oben und lassen dann die
Bewegung seitwärts laufen Also werden wir
etwas sehr Ähnliches machen. Wir werden
jede Bewegungseingabe einfrieren oder pausieren , bis die
Animation verfügbar ist. Wir werden zu den Animationen
im Abschnitt „Feinschliff“ kommen ,
aber wir müssen einfach noch einmal
darüber nachdenken, was
wir
berücksichtigen müssen , und
das können wir jetzt programmieren. Fangen wir also damit
an. Wir werden einige sehr einfache,
logische Wenn-Checks machen
wollen . Wenn wir also von
unserem Ausführungs-Pin ziehen, suchen
wir nach einem Zweig. Und von der Filiale aus können wir die Bedingung hier
übernehmen. Wir werden das sofort auf eine
Variable hochstufen. Nennen wir das B,
Bewegung aktiviert. Wir klicken auf Compile und stellen sicher, dass dies
standardmäßig auf true gesetzt ist Wenn also Bewegung aktiviert ist, was wir tun
wollen, während wir
nur debuggen, bevor wir die Animation eingerichtet
haben, wenn Bewegung aktiviert ist, dann erlauben wir dem Feind, Seite zu Seite zu fliegen und sich auf
dem Bildschirm nach unten zu bewegen,
und wir erlauben dem Spieler, basierend auf
der Eingabe von
Seite zu Seite zu fliegen basierend auf
der Eingabe von
Seite zu Seite zu Wenn nicht, dann bedeutet das, dass wir uns
wahrscheinlich in der Animation und wir hier die
Funktion false aufrufen und
jede Bewegung verhindern .
Also das bereitet uns einfach vor. Später, wenn wir
zu diesen Funktionen kommen vorausschauend denken, müssen
wir
den Code nicht noch einmal
komplett umgestalten Als Nächstes
benötigen beide Klassen irgendeine Art von Bewegung Aber wie ich bereits erwähnt habe, programmieren
wir die Bewegung etwas
anders, sodass wir den
eigentlichen Bewegungscode nicht teilen können weil nicht dieselbe
Art von Bewegung verwendet wird. Aber was wir tun können, ist Logikfluss und
die
Funktionskonzepte, die wir benötigen, mit anderen zu
teilen . Wir können das tun, indem
wir uns jetzt die Funktionen ansehen. Auf der linken Seite
haben wir also genau hier diese
Funktionskategorie. Ähnlich wie bei Ereignissen können
wir
unsere eigenen benutzerdefinierten Funktionen erstellen , und dann wird einfach
Logik aufgerufen
, wenn diese Funktion
aufgerufen wird
, genauso wie wir es in der Vergangenheit
mit Ereignissen gemacht haben. Wenn wir also hier Plus drücken
und ich
diese neue Funktion aufrufen werde, haben wir die Bewegung
handhaben lassen. Und Sie können hier einen
der Unterschiede erkennen, und einer der
Hauptvorteile der Verwendung von Funktionen gegenüber Ereignissen besteht darin, dass sie
fast das Gleiche tun. Sie reagieren darauf, dass sie aufgerufen werden, aber hier bekommen wir unseren
eigenen Funktionsgraphen. Es ist also irgendwie
versteckt, und wieder, um die Dinge schön und aufgeräumt
zu halten Also, wir werden uns hier nicht wirklich
um die
Bewegungsfunktionen kümmern die
Bewegungsfunktionen Die Art und Weise, wie das
verwendet wird, ist, dass wir diese Funktion später in
unseren untergeordneten Klassen
überschreiben werden, aber wir brauchen sie,
damit wir sie aufrufen können. Was wir tun wollen, ist zurück zum Event-Graph zu
gehen. Wir wollen unsere
Griffbewegungsfunktion übernehmen. Und wir werden das einfach auf die richtige Stecknadel
fallen lassen. Wenn also eine Bewegung aktiviert ist, rufen wir die Funktion
Handle Movement auf. Also nochmal, es wird
nett und lesbar. Und wenn wir das
tatsächlich umsetzen, können
wir uns ein Bild davon was
genau
passieren wird. Also das ist vorerst ziemlich
einfach. Sie werden sehen, wie sich das entfaltet
und viel mehr Sinn ergibt wenn wir tatsächlich anfangen, Dinge zu
implementieren Das ist eines dieser Dinge,
bei denen ich versuchen könnte,
fünf bis zehn Minuten damit zu verbringen , zu beschreiben,
was wir später tun werden, aber ich denke, es wird einfach viel
sinnvoller es
einfach nach und nach umzusetzen Eine weitere Sache, die
beide einfachen Klassen brauchen
werden:
den Feind und den Spieler und die Bosse
oder was auch immer du von dieser Klasse erben
willst, sie müssen alle irgendwann
zerstört oder getötet
werden irgendwann
zerstört oder getötet Wenn wir schon mal hier sind, können
wir genauso gut eine weitere Funktion
hinzufügen,
und ich nenne diese hier Handle
Death Nochmals, wir werden hier jetzt
nichts hinzufügen,
aber eine Sache, die wir mit dieser Funktion
machen können, die generischen Dinge wie alles
muss
einen Sound- oder
Partikeleffekt abspielen , wenn sie sterben. können wir in
dieser Klasse hier tun ,
weil das eine
universelle Funktion ist. Das ist etwas, das unabhängig
von der Art des Flugzeugs alle
ein gewisses Feedback geben müssen ,
wenn das passiert. Also können wir hier die universelle
Funktionalität nutzen. Und wenn es dann
etwas Einzigartiges für
die einzelne Ebene gibt , dann können wir
die Funktionalität, die hier
passiert, wieder außer Kraft setzen und dann noch etwas
draufsetzen. Also nur eine grobe
Vorstellung davon, wie Vererbung funktioniert und wie wir diesen wiederverwendbaren Code
verwenden können, was uns Zeit und
Mühe spart. Nun, das Letzte, was
ich mir vorstellen kann, dass beide Flugzeugklassen benötigen werden, ist die Bewegungsgeschwindigkeit.
Und das wissen wir
gewissermaßen schon. Wenn wir uns unseren eigenen Code ansehen, eines der wenigen Dinge,
die beide
haben, dass ist
eines der wenigen Dinge,
die beide
haben, dass wir
ihre beiden Eventdiagramme öffnen, Pan Base, was bedeutet, dass der Player viel mehr Funktionen
hat. Hier gibt es viel mehr
Variablen, aber es gibt eine Bewegungsgeschwindigkeit. Und dann ist die Pfanne etwas
anders, vereinfacht. Während wir in der Player-Version den Zug nach links nicht überprüfen, verwenden
wir immer noch die
Bewegungsgeschwindigkeit. solchen
Dingen
suchen wir also in unseren Basisklassen. Dinge, die wir mehr als einmal
implementieren mussten ,
konnten wir einfach
direkt in die Basisklasse übernehmen Also werde
ich hier
eine neue Variable erstellen , die als Bewegungsgeschwindigkeit bezeichnet
wird Und wir haben das
in ein Float geändert, es und stapeln, speichern. Und jedes Mal, wenn wir sie
zwischen den Kursen verwenden
müssen
, ist sie verfügbar
und sofort einsatzbereit. Auch hier
müssen wir es noch nicht wirklich nutzen, aber das ist nur
die Grundlage für
einen reibungsloseren und
angenehmeren Übergang Und das
ist wirklich unsere Basisklasse, die so
weit ausgearbeitet ist,
wie wir gerade brauchen Wir können später zurückkommen und Dinge
hinzufügen, aber wir haben die gemeinsamen
Komponenten, die
wir brauchen, die einheitliche Kollision, die Bewegung, die bereit ist, sie
in den einzelnen untergeordneten Klassen umzusetzen in den einzelnen untergeordneten Gleiche gilt für den Tod
und dann die
Geschwindigkeitsvariable , die ebenfalls einsatzbereit ist. Um einen
kurzen
Blick darauf zu werfen, wie wir diese Basisklasse nutzen
können, werden
wir die volle Funktionalität
etwas später hinzufügen, aber das ist eine sehr kurze Demonstration. Wenn wir zu
unserer Inhaltsauswahl zurückkehren, können wir mit der rechten Maustaste
auf die einfache Base klicken. Und hier oben
haben wir die Möglichkeit, eine untergeordnete Blueprint-Klasse zu erstellen Wenn wir auf diesen klicken, wird ein neuer
Blueprint für uns erstellt Dieser wird
alles von Plain Base erben. Das nenne ich BP
Underscore Plane Player. Und wenn wir dann darauf
doppelklicken, um es zu öffnen, können
wir sehen, dass es
jetzt
mit unserer Kugel und
unserem statischen Netz vorkonfiguriert mit unserer Kugel und
unserem statischen Netz Wir haben hier auch noch ein paar andere
Dinge. Wenn wir auf die Option Override klicken, können
wir tatsächlich
die Funktionen sehen , die wir manuell erstellt haben, Death
behandeln und Bewegungen
handhaben, speziell von
unserer Basisklasse aus. Wenn wir auf diese klicken, erhalten wir eine
Funktion, mit der wir dann
anfangen können ,
die übergeordnete
Version der Funktion zu verwenden , wie ich bereits erwähnt habe, darüber hinaus
unser eigenes Ding zu machen . Wir drücken die Steuerung, um das eins für neun
loszuwerden. Wir wollen noch nichts
überschreiben,
und wir müssen auch noch nichts
ändern, aber ich wollte dir auch
einen anderen Weg zeigen , wie wir Klassen hinzufügen können
, die auf denen basieren, die wir haben Wenn du noch einmal zur
Inhaltsauszeichnung zurückkehrst , klicke hier mit der
rechten Maustaste, und dieses Mal gehen wir
zu einem Blueprint-Kurs,
etwas, das vielleicht
nicht ganz offensichtlich ist. Aber viele Leute denken
, dass dies auf
Unreal-Engine-Klassen und solche beschränkt ist , die von den
Unrelengin-Entwicklern erstellt wurden Aber sobald
wir eine Klasse erstellt haben,
können wir tatsächlich hier finden Wenn ich also nach Plain Base suche, können
wir hier sehen, dass Basic ein Kind
eines Bauern ist und ein Bauer, wie
gesagt, ein Kind eines Schauspielers ist Und unser einfacher Spieler ist
ein Kind von Plain Base. Also können wir jetzt tatsächlich
unsere eigenen Klassen aus unserer
Klassenliste hier im Editor auswählen . Also wählen wir
wieder Plain Base. Wählen Sie diesen aus. Und natürlich
werden wir dieses eine
BP Underscore-Flugzeug Feind nennen BP Underscore-Flugzeug Feind Also sind beide jetzt startklar
, wenn wir anfangen, die Dinge zu
konkretisieren Ich wollte nur
erwähnen, dass
es mehrere
Möglichkeiten gibt, wie Sie Ihre Basisklassen verwenden können Ihre Basisklassen verwenden wenn Sie sie
bereit und eingerichtet haben Damit ist die
Basisklasse jedoch fertig. Wie gesagt, wir haben
die gemeinsamen Komponenten, die gemeinsame Funktionalität und
das einheitliche Kollisions-Setup. Als Nächstes werden wir zuerst den
Player umgestalten. Wir nehmen den großen
, gehen
den klobigen Code durch , über den wir
uns bewegen werden, und konzentrieren uns danach auf
den Feind
14. 13 - RefactoringPlayer: Der Unterricht ist jetzt startklar.
Jetzt müssen wir also unseren Player konvertieren,
um das nutzen zu können. Dies wird als Refactoring bezeichnet
, bei dem
im Wesentlichen
vorhandener Code umstrukturiert wird, im Wesentlichen
vorhandener Code umstrukturiert ohne seine Funktionsweise zu ändern Wir streben
das gleiche Verhalten an,
aber eine bessere Organisation und die aber eine bessere Organisation und Reduzierung des Overheads oder der Wiederverwendung von
Variablen, Komponenten und ähnlichem, wo immer dies
möglich Im vorherigen Thema, das
wir gerade durchgegangen sind, wurde mir klar, dass
ich Ihnen Anweisungen gegeben habe, wie Sie zwei neue Flugzeugklassen
erstellen Es gibt noch eine weitere Sache
, die
mir zwischendurch
bewusst sein könnte und
die uns tatsächlich ein
bisschen mehr Zeit sparen
würde. Was ich also
empfehlen werde, ist, dass wir Plain Enemy
und Plain Player tatsächlich löschen. Also können wir uns diese Shift
Select schnappen und Löschen drücken. Wir haben damit sowieso
nichts gemacht, also verlieren wir
nichts, und zumindest wissen
Sie, dass diese
Optionen verfügbar sind. Ich würde stattdessen vorschlagen, dass wir zu unserer Flugzeugbasis gehen
und diese schließen, um die Dinge nicht
zu verwirren.
Wir wollen die Flugzeugbasisklasse, an
der wir
gearbeitet haben
, doppelklicken und öffnen an
der wir
gearbeitet haben
, , um
sicherzugehen, dass Sie die Flugzeugbasisklasse nicht
gelöscht haben die Flugzeugbasisklasse nicht
gelöscht Da die Flugzeugbasis also immer noch da ist, wollten
wir sie nicht
loswerden Was wir tun wollen, ist, dass
wir tatsächlich
die vorhandenen Klassen nutzen und Dinge
einfach dorthin verschieben, wo wir sie brauchen. Das Erste ist also, uns auf unsere Benennung
zu konzentrieren. Wenn wir uns zuallererst auf den
Spieler konzentrieren, werde
ich ihn in BP umbenennen
, Unterstrich Plain Player Und aus diesem Grund
mussten wir
diese anderen Klassen löschen , damit wir
keine Namenskonflikte haben Der Klassenname war in Ordnung, aber wir können hier einfach
etwas ganz
Intelligentes tun , um das zu nutzen was wir bereits in dieser Klasse
haben. Und wir werden
dasselbe für unseren Feind tun. Also schnappen wir uns diesen und nennen
ihn BP Underscore
Plain Enemy Und wenn wir dann
doppelklicken, um
den BP Underscore Plane Player zu öffnen , können
wir hier anfangen,
unsere Änderungen vorzunehmen Ich dachte also, es
wäre nützlich zu
wissen, dass es
eine wirklich coole Methode gibt, wie
wir ändern können, was diese Klasse als ihr
übergeordnetes Objekt Im Moment können wir also
die übergeordnete Klasse als Schachfigur betrachten. Wenn wir hier
zu den Klasseneinstellungen
und dann zurück zum Detailbereich kommen , können
wir sehen, dass wir hier die
übergeordnete Klasse haben Das Drop-down-Menü ist auf Pfand eingestellt. Wenn wir nach einem Flugzeug suchen, können
wir das so ändern, dass es jetzt von BP
Underscore Plane Base erbt Und das ist eigentlich eine
nette Art, Dinge umzugestalten. Ein Grund dafür ist, dass wir
dadurch Fehler
und Warnungen über Code erhalten , der möglicherweise dupliziert wurde Und das können wir quasi
schon sehen. Wenn wir also nach
links schauen, können
wir sehen, dass wir
zwei statische Maschen haben. Alles, was hier steht, in Blueprint bearbeiten oder
In C plus plus bearbeiten, wenn Sie in einem
C Plus Plus-Projekt arbeiten, ist ein Hinweis darauf, dass dies von
einer Basisklasse
geerbt wurde Also, wenn Sie das sehen, können
wir nicht reinkommen. Wir können uns die geerbten nicht schnappen und sie löschen, also stecken
sie hier fest. Wir
wollen also unseren statischen
Mesh-Unterstrich Null
abrufen Wir brauchen nicht zwei verschiedene
Meshes für unsere Ebene, und wir können dieses löschen, also löschen wir es einfach hier Die andere Sache, die wir
hier sehen können, ist, dass wir in den Variablen einen sogenannten
Bewegungsgeschwindigkeit-Unterstrich
Null haben in den Variablen einen sogenannten
Bewegungsgeschwindigkeit-Unterstrich
Null Wenn wir schreiben und darauf klicken,
können wir zur Suche nach Referenzen gehen und dort alle
aktuellen Klassenmitglieder finden Wenn wir
darauf doppelklicken,
gelangen wir direkt
zu der Stelle, an der sie sich befindet. Wie ich bereits erwähnt habe, ist
es eine nette und schnelle
Möglichkeit ,
Dinge aufzuräumen, weil wir diese Abkürzungen
verwenden können , um herumzuspringen und die verbleibenden Dinge
zu finden , die wir vielleicht loswerden müssen Und noch einmal, der
Grund, warum dem
ein Unterstrich Null gegeben wurde , ist
, dass wir wissen, dass wir in
der Basisklasse etwas
haben, das
Bewegungsgeschwindigkeit genannt wird , und wir können nicht dieselbe Variable
haben, selbst wenn sie sich in einer untergeordneten
Version dieser Also werden wir das Gleiche
noch einmal tun. Wir werden diesen löschen. Wir löschen einfach die
Bewegungsgeschwindigkeit. Das sagt uns nur, dass
wir das gerade verwenden, aber das ist völlig in Ordnung,
weil wir wissen, wo das ist. Und was wir dann hier
tun wollen, ist, dass wir von hier aus
ziehen und nach der Bewegungsgeschwindigkeit
suchen. Und wir können hier sehen, dass
wir
die Bewegungsgeschwindigkeit variabel machen wollen , und das ist die in unserer
Basisklasse, der Paarungsklasse Und da haben wir es. Also
das ist so ziemlich alles. Das ist der Kurs irgendwie
eingerichtet und bereit zu gehen. Wir könnten es also definitiv hier
belassen, aber es gibt noch ein paar
Dinge, die wir aus der übergeordneten Klasse
verwenden können . Das Erste, was
wir immer
berücksichtigen wollen , ist zu Beginn
des Spiels, und das müssen wir im Grunde bei all
unseren Funktionen tun. Aber um mit dem Spiel zu beginnen, klicken
wir mit der rechten Maustaste auf den Knoten, und wir wollen hier
diese Option finden, um übergeordneten Funktion einen Aufruf
hinzuzufügen. Und wir wollen
dies zwischen unserer aktuellen Ausführung und der Funktionalität, die
wir bereits aufrufen, verbinden. Das stellt nur sicher, dass
die Logik der Eltern mit dem
Spielen beginnt , auch aufgerufen wird,
wenn wir anfangen zu spielen,
was bedeutet, dass, wenn
wir wieder eine
universelle Logik hätten , die wir für
die übergeordnete Klasse anwenden wollen, diese auch aufgerufen wird. Andernfalls wird dies nur von selbst
aufgerufen und wir ignorieren die Version der
Eltern. Wir wollen
dasselbe für den Eventic tun. Wir schreiben, klicken Sie
darauf, fügen einen Aufruf zur übergeordneten Funktion hinzu und schließen dann
einfach alles an Einschließlich der Delta-Sekunden müssen
wir hier vielleicht
ein paar Dinge verschieben. Und dann können wir das einfach hier drüben
einstecken. Und wieder, räume die Dinge
auf, wenn du willst. Versuchen Sie,
dies für Sie zu visualisieren Die übergeordnete Funktionalität
wird zuerst aufgerufen Wenn unser
Spieler also zum ersten Mal erstellt wird, wird sein Event
Begin Play automatisch
einmal aufgerufen, und dann
senden wir sofort eine Nachricht,
um uns die
übergeordnete Version anzusehen und zu sehen ob
bei diesem Startspiel etwas passiert. Navigiere hier drüben. Wir können den übergeordneten Blueprint
mit dieser Tastenkombination hier öffnen, und wir können hier zum
Start des Spiels gehen
und sehen, dass es im Moment keinen
echten Code gibt Wenn wir jedoch
etwas tun würden, wie
eine Druckzeile
von hier abzuziehen , würden
wir einfach Parent
Begin sagen und das für einen Moment auf
dem Bildschirm belassen Was jetzt passieren würde,
ist, wenn wir auf Play drücken. Wir werden sehen, dass Parent Begin oben steht. So können wir bestätigen, dass
unsere übergeordnete Logik, die universelle Logik, tatsächlich aufgerufen wird. Das Problem ist
natürlich, wenn wir das zu den Feinden hinzufügen. Wenn wir
also in die Klasse der
einfachen Feinde gehen, kommen
wir zum Startspiel. Wir werden dasselbe
tun wollen. Wir klicken mit der rechten Maustaste, fügen einen Elternanruf hinzu und
fügen das hier ein. Da wir nun drei
Gegner und einen Spieler haben, werden
wir diese
Nachricht viermal sehen, weil sie alle dieselbe Funktion aufrufen
. Natürlich müssen
wir die gleiche Änderung
in den Klasseneinstellungen der gegnerischen
Klassen vornehmen. Ändere das von einer
Spielfigur zur einfachen Basis. Okay. Also machen wir das
Gleiche. Wir rekonstruieren nur, was diese
Klasse erbt Klicken Sie auf Kompilieren. Also machen
alle vier
den gleichen Prozess. In diesem Fall ist das in Ordnung, aber hier sollten Sie vorsichtig
sein und
sicherstellen , dass Sie überlegen, was
Sie implementieren. Also das und würde keinen Sinn machen wenn diese Nachricht so etwas
aussagen würde wie, wenn das spezifisch auf das ausgerichtet wäre, was
der Spieler tun sollte, wie zum Beispiel zu schreien, ich bin der Spieler Wenn wir auf Kompilieren klicken,
also den Flugzeugspieler, nennen
wir ihn, was völlig in Ordnung
ist Aber all die Feinde. Also sagen alle drei Gegner
auch, ich bin der Spieler, was
ein bisschen verwirrend ist. Also hier müssen Sie vorsichtig mit der Erbschaft
sein. Deshalb sage ich
immer wieder, dass wir unsere universelle
Logik hier haben wollen. Alles, was
nur damit zu tun hat, eine allgemeine Ebene zu sein,
ist völlig in Ordnung. Wenn das so wäre, dass
sich jedes Flugzeug einfach
selbst ankündigen und einfach sagen müsste , ich bin ein Flugzeug,
wäre das völlig in Ordnung weil alle vier Flugzeuge tatsächlich Flugzeuge sind. Wie wir sehen können,
würden wir aber keinen Code in
der Basisklasse haben wollen , der sich speziell
auf den Spieler
bezieht. Hoffentlich macht das Sinn, und wir können
anfangen zu sehen, wie wir Vererbung
nutzen können und wie wir unsere Funktionen,
Komponenten und Logik
zwischen mehreren Klassen teilen
können . Und so werden wir Dingen
wie Zerstörung
umgehen. Wir können die
Partikeleffekte die Soundeffekte alle in
der übergeordneten Klasse abspielen lassen,
weil das nicht spezifisch für eine Ebene ist. Sie müssen alle auf irgendeine Weise
zerstört werden. Aber Dinge wie die Bewegung
sind einfach ein bisschen einzigartig, wir werden das stattdessen in
den Kinderkursen regeln. Zurück zum normalen Spieler. Wir werden diesen
zuerst beenden. Ein sehr schneller Weg
, den Code zu übernehmen, dem wir wissen, dass er
bereits funktioniert. Wie ich bereits erwähnt habe, wollen
wir nur sicherstellen, dass wir das nicht herumliegen
haben, und wir können die Funktion nutzen
, die und wir können die Funktion nutzen
, die
wir vor Kurzem erstellt haben Wenn wir also alles aufnehmen, was mit Bewegung zu
tun hat, also diese
Knoten hier, Berechnung hier, ich einfach die Umschalttaste gedrückt und
ziehe und dann die Position des
Schauspielers Das bezieht sich nur
auf die Rotation, also belassen wir
das vorerst Was wir tun wollen, ist,
Strg und X zu drücken , um zu schneiden, und wir werden hier klicken, um die
Griffbewegungsfunktion zu überschreiben. Wir wollen also die Funktion, die wir zuvor
gemacht haben , diesen leeren Raum. Und dann drücken wir hier
die Taste V und wir werden alles wieder
anschließen. So können wir sicherstellen, dass unsere
Bewegungsfunktion immer aufgerufen
wird, weil
wir unsere Eventic aufrufen Und wenn Bewegung
aktiviert ist, dann wird Handle Movement auch von diesem
Eventic aus aufgerufen Also nochmal, wir müssen diese Funktion hier nur einmal
aufrufen, und wir können diesen
Funktionsaufruf in unseren untergeordneten Klassen verwenden Funktionsaufruf in unseren untergeordneten Wir haben das verschoben und ich komme
einfach zurück
zum Event-Graph. Wir verschieben das vorerst, die Rotation, und wir
schließen das wieder an. Und während wir das Ganze testen
, wie ich bereits erwähnt habe,
geht es eher darum,
Ihnen zu zeigen, wie
Sie Code bei Bedarf
selbst umgestalten können Sie Code bei Bedarf
selbst umgestalten Und das ist ein sehr
verbreiteter Prozess. Wir wollen diese
kleinen Schritte nur im Laufe der Zeit testen, und wir sollten
die Bewegung trotzdem aktivieren. Wenn also etwas kaputt ist, lass mich noch einmal überprüfen,
was das sein könnte. Wenn Bewegung aktiviert ist, wenn das
stimmt , nennen wir unsere Eventi Wir haben
hier unseren Griff, Bewegung, Geschwindigkeit. Mir ist gerade aufgefallen, dass wir
unsere neue Bewegungsgeschwindigkeit
in der Basisklasse haben,
aber wir haben ihr unsere neue Bewegungsgeschwindigkeit
in der Basisklasse haben, keinen Wert
gegeben. Wenn wir also unsere
Klasseneinstellungen hier abrufen, erhalten
wir tatsächlich Zugriff auf die
Klasseneinstellungen, wenn wir das oberste Element
hier oder die Standardklasse
auswählen Wir können hier sehen,
dass die Klassenstandardwerte die Variablen enthalten, und wir können unsere
Bewegungsgeschwindigkeit sehen, und ich glaube, ich habe das im Player auf
1.000
gesetzt . Also setzen
wir das zurück Und dann sollten wir in der Lage
sein, Play zu
drücken und uns zu bewegen. Wir haben also dieselbe Bewegung,
wir haben dieselbe Rotation. Es fühlt sich alles gleich an. Wir haben
die Funktionalität nicht geändert. Wir haben gerade
unser Diagramm und die Art und Weise, wie die
Dinge gehandhabt werden, aufgeräumt unser Diagramm und die Art und Weise, wie die
Dinge gehandhabt werden, Also stellen wir sicher, dass es aufgerufen
wird, wenn und wann wir
wollen , und ein weiterer
wirklich cooler Vorteil von Dis Now ist, dass wir reinkommen können Wir könnten aktivierte
Bewegungen deaktivieren, sodass Bewegungen
nicht mehr aktiviert sind. Wir können Play drücken und jetzt können
wir das Flugzeug nicht bewegen. Aber natürlich unterbricht es
die Rotation, weil wir jetzt mit einem Wert multiplizieren , der eigentlich gar nichts bewirkt Aber Sie können sehen, dass die
Logik darin besteht, dass wir die Dinge so handhaben, wie
wir wollen, dass sie funktionieren Und all das wird jetzt
tatsächlich in
der Basisklasse geregelt , was
den Status „Bewegung aktiviert“
und „Deaktiviert“ angeht , und
das nutzen wir einfach innerhalb
der Spielerversion
dieser Klasse Stellen Sie also sicher, dass wir darauf klicken. Wir werden sicherstellen, dass die Bewegung
vorerst aktiviert ist. Wir werden das
etwas später
im Code umschalten , wenn wir zur Animation
kommen Denken Sie daran, dass ich gesagt habe, dass wir keine Dinge wie
die Rotation oder vorgetäuschte
Physik und Dinge
in der feindlichen Klasse hinzufügen werden die Rotation oder vorgetäuschte , weshalb wir den Bewegungscode nicht genau
wiederverwenden Eine weitere Sache, die die
Gegner nicht haben werden, ist die eigentliche Rotationslogik, die wir aus diesem Grund hier
haben Wir könnten jedoch etwas
tun, um
die Namenskonventionen und
das allgemeine Design beizubehalten . Es gibt noch einen anderen Tipp, den
ich zeigen wollte. Wir können all
diese Knoten erfassen Shift-Taste drücken
, um diese Knoten zu erfassen. Und wenn wir dann mit der rechten
Maustaste auf einen der Knoten
klicken , die
wir hier ausgewählt haben , können wir
ihn auf eine eigene Funktion reduzieren. Und wir werden
diesen einfach so nennen. Sie können es wahrscheinlich erraten. Wir werden das Rotation mit
einem Griff nennen. Nett und offensichtlich. Wenn wir das
durchgehen und anfangen müssten, unseren Code
durchzulesen, kämen
wir vom
Flugzeugbasisfestival
und wir könnten sehen, dass, wenn
das Event läuft, wenn wir Bewegung aktiviert haben, Bewegung
regeln
und das Ganze dann aus der Basisklasse
herausspringt. Sobald das erledigt ist,
kehren
wir zu unserer untergeordneten Klasse zurück. Also das wurde jetzt
erledigt. Der Execution-Pin wird aufgerufen, und dann fangen
wir an, diesen aufzurufen. Wir kümmern uns also um Bewegung,
wenn Bewegung aktiviert ist, und dann
wieder um Rotation, wenn Bewegung aktiviert ist. Genau die gleichen Ergebnisse, wenn
wir auf Play drücken, hat sich
nichts geändert. Wir machen das nur viel
lesbarer und wartbarer Wir werden
diesen Spaghetticode oder sogar das Potenzial
, dass das hier passiert, los, weil wir die volle Kontrolle über unsere Codebasis
haben und darüber, wie sie ausgeführt werden soll Wir nutzen die Vererbung, also sparen wir viel Zeit, wenn wir neue Funktionen
hinzufügen Im Moment mag sich das
einfach nach anstrengender Arbeit anfühlen, aber auf lange Sicht würde es Ihnen
definitiv
viel Zeit sparen , zu
verstehen, was
das bedeutet und wie Sie es nutzen können. Sobald wir hier sind, wenn du dich
innerhalb der Flugzeugbasis befindest, wenn du genau
mitmachst, können
wir
diese Nachricht loswerden , die beschreibt,
was die Klasse ist Wir werden den einfach los.
Es kompiliert sich ein. Der Feind wird vorerst gehen
und nur noch einmal überprüfen
, ob alles
in der Spielerklasse gespeichert ist, und das ist das
Player-Refactoring abgeschlossen Du kannst also sehen, dass es nicht
wirklich so schmerzhaft war. Ich habe etwas länger gebraucht,
nur weil ich diese Konzepte
erklären und sie im Laufe der Zeit
klarstellen wollte . Wenn ich das
alleine gemacht hätte, wäre das wahrscheinlich eine einminütige Aufgabe
gewesen. Selbst das Refactoring und das
vollständige Überdenken, wie
die Struktur von Klassen
gehandhabt wird,
muss also die Struktur von Klassen wirklich nicht so lange dauern,
vor allem, wenn Sie
früh in der Entwicklung nachdenken, weshalb ich versuche, dies im Laufe der Zeit zu
betonen Versuchen Sie, diese
Entscheidungen im Voraus zu treffen, und das ist der
Unterschied zwischen einminütigen Refactor und
einem einstündigen Refactor Wenn Sie Ihren Code testen und etwas kaputt ist
oder nicht funktioniert, überprüfen Sie
einfach, ob alle
Ihre übergeordneten Anrufe miteinander Ihre übergeordneten Anrufe Also diese übergeordneten Aufrufe hier, die orangefarbenen Knoten sind
miteinander verbunden und werden beim Start der Wiedergabe,
beim Event-Häkchen usw.
aufgerufen. Sie ebenfalls sicher, dass
die Bewegung aktiviert ist, sowohl in
der Basisklasse hier
als auch, was noch wichtiger ist,
durch diesen Wert hier oben,
wie ich gerade gezeigt habe,
nur ein paar Fallstricke der Basisklasse hier
als auch, was noch wichtiger ist, durch diesen Wert hier oben,
wie ich gerade gezeigt habe, , in die ich mir vorstellen
kann, dass einige Leute fallen
könnten Also überprüfe noch einmal die Dinge, die wir geändert
haben Beim nächsten Thema werden
wir uns natürlich mit derselben Sache
befassen, aber für den Feind
sollte es
etwas weniger Zeit in Anspruch nehmen . Jetzt haben
wir hier gesehen, wie das geht.
15. 14 - Feind neu bewerten: Den Feind umgestalten. Wir haben das
schon einmal gemacht Das sollte etwas schneller gehen. Falls ihr das
noch nicht geöffnet habt, werden
wir natürlich dafür sorgen, dass wir die einfache Feindklasse
öffnen. Überprüfe das nochmal, falls du nicht
schon die Änderung vorgenommen
hast, dass wir die übergeordnete Klasse hier
auf BP Underscore Plane Base
zurückgesetzt haben die übergeordnete Klasse hier
auf BP Underscore Plane Base
zurückgesetzt Denken Sie daran,
dass wir das über die
Klasseneinstellungen und das
Drop-down-Menü hier tun können Klasseneinstellungen und das
Drop-down-Menü hier Noch einmal die gleichen Dinge
wie mit dem Spieler. Wir werden
das statische Netz löschen, was uns hier ein
kleines Problem bereiten wird. Wir sagen einfach: Das ist
in Ordnung, also klicken wir auf Ja. Das hat mich direkt zum
Problem gebracht,
und das ist, dass wir die vorherige Funktion,
die Kollisionsprüfung, an
das ursprüngliche statische Netz gebunden haben vorherige Funktion,
die Kollisionsprüfung, . Das ist eigentlich kein Problem , weil wir das sowieso beheben wollten
. Wir wollen das
Mesh nicht als Collider verwenden sondern wir nehmen hier
die Kugelkomponente, also nehmen wir diese, und wir wollen das
Gleiche noch einmal machen Also lassen
wir das auf der rechten Seite
im Detailbereich einfach weg Wir werden die
On-Component-Hüftfunktion finden und eine Bindung dazu erstellen. Und das ist alles, was das tut. Es ist einfach bindend,
wann immer eine Aktion stattfindet, es bindet diese Funktion
, damit sie dann aufgerufen wird. Also können wir diesen löschen, dieselben Dinge
miteinander verbinden, also Hinrichtungs-Pin und Akteur-Pin, und damit ist der erste Teil
des Problems gelöst. Dann springe ich einfach schnell
in den Viewport. Wir werden uns
das statische Netz schnappen
und sicherstellen, dass
wir das Material aktualisieren Also nochmal, in Element Null hier
ist es derjenige, der
den Körper des Flugzeugs kontrolliert. Wir lassen das fallen
und wir können jetzt
das andere Material finden, das Sie
vielleicht für Ihren Feind hergestellt haben, was für mich nur MI
Underscore Flugzeug-Feind ist Wählen Sie das aus und wir sind so
ziemlich wieder da, wo wir waren Das Gleiche gilt für die
Bewegungsgeschwindigkeit. Wir wollen mit der rechten
Maustaste darauf klicken und
die Referenzen
des Klassenmitglieds finden, die Referenzen
des Klassenmitglieds nur um sicherzugehen
, dass sie alle gelöscht werden. Wir können auf eines
davon doppelklicken und sehen, wo
sie verwendet werden. Wir können sehen, dass wir einige
davon haben , um sicherzustellen, dass wir nichts
verpassen , wenn wir versuchen, die
Dinge wieder miteinander zu verbinden. Ich
klicke einfach mit der rechten Maustaste in das
Ereignisdiagramm hier unten,
suche nach der Bewegungsgeschwindigkeit und wir erhalten hier die Variable für die
Bewegungsgeschwindigkeit, die
in unserer übergeordneten Klasse erstellt wurde. Hängen Sie das hier ein, duplizieren Sie
das, hängen Sie das hier an, entfernen Sie sie, nur um die
Dinge ein wenig aufzuräumen, und doppelklicken Sie auf die
letzte Datei, die sich hier befindet. Und wieder klicken
wir einfach mit der rechten Maustaste und suchen nach der Bewegungsgeschwindigkeit Wir stellen
hier
die Bewegungsgeschwindigkeit ein und schließen das dann
an. Wenn wir das loswerden,
sind wir wieder da, wo wir sind. Nun, es gibt eine Option, die ich nicht erwähnen
wollte, weil ich sie als
etwas fummelig
empfand Tatsächlich scheint
es in der aktuellen Version einfach nicht zu funktionieren Aber etwas, das nützlich sein
könnte wenn sie das in Zukunft beheben,
ist, dass
wir in der Vergangenheit mit der rechten Maustaste auf die Variable klicken konnten . Wir können hier auswählen, ob Referenzen
ersetzt werden sollen. Was mir im
Moment fehlt, ich weiß nicht, wo
das Feature geblieben ist. Normalerweise kannst du das herunterklappen, und wir hätten die Variable für die
Bewegungsgeschwindigkeit finden in der übergeordneten Klasse
erstellt wurde. Aus welchem Grund auch immer,
ich kann nur direkt auf die
Variablen des Schauspielers
und des Bauern zugreifen , nicht auf die tatsächliche
BP-Unterstrich-Forderungsbasis, obwohl ich dazu in der Lage sein sollte Aber nur um zu sagen, dass
wir aus diesen
Gründen vielleicht einfach
den etwas
manuelleren Weg gehen
müssen den etwas
manuelleren , als wir
gerade diese entfernt haben.
Denken Sie daran, den
Unterstrich Null für
die Bewegungsgeschwindigkeit zu Unterstrich Null für
die Bewegungsgeschwindigkeit Wir sollten
das überhaupt nicht mehr verwenden
und dann einfach auf Kompilieren klicken, um
sicherzugehen , dass
alles durchgegangen ist Gleiche gilt für den Spieler. Jetzt
, wo wir sie in
der feindlichen Klasse haben, wollten wir
das nur noch einmal überprüfen. Ich habe
diesen Weg bereits
eingeschlagen, als wir an den Spielerinhalten gearbeitet haben. Falls du dich entschieden hast, nicht
in die gegnerische Klasse zu springen konzentriere
ich mich nur auf die
einfache Spielerklasse. Dann überprüfe noch einmal, ob
du auch die Optionen Begin Play, Parent Call und
EventI Override of Parent Call Also gehen wir zu
R, klicken Sie hier. Wir werden den
Aufruf zum Hinzufügen zur übergeordneten Funktion ausführen und auch hier nur
sicherstellen, dass wir diese Funktionen
im Laufe der Zeit miteinander verbinden die Bewegungslogik
angeht, werden wir das
Gleiche noch einmal tun Also wollen wir eigentlich, dass dieselbe
Bewegungslogik passiert. Wir können uns das alles schnappen. Nichts
wird sich wirklich ändern. Wir können uns diese schnappen, also drücken Sie einfach die
Shift-Taste, um sie zu holen. Wir wollen die Strg-Taste in X drücken , um alle
Knoten von hier zu entfernen. Wir werden zum Überschreiben
übergehen und wir werden die Funktion zur
Bewegung des Griffs überschreiben. Nachdem wir alles getan haben
, was möglicherweise in der übergeordneten Funktion
passieren muss , fügen
wir
diese hier ein und
stellen dann sicher, dass unsere
Bewegung aufgerufen wird. Nachdem das erledigt ist, hat mich das
nur daran erinnert, dass wir hier
noch etwas verbessern
könnten. Wir wollen also sichergehen, dass wir aufgrund der Überschneidung,
die wir gemacht
haben, vorher nur
Destroy Actor angerufen und hier eine Nachricht
hinterlassen haben. Wir können unsere
Handle-Death-Funktion einbauen, das hier einfügen und
das durch die
Destroy-Funktion ersetzen . Also werden wir Destroy loswerden.
Wir haben unsere im Griff. Wir möchten vielleicht
sogar herkommen. Wir werden uns einen
Kommentar hinterlassen. Das ist also genommen Wenn wir darauf doppelklicken, gelangen wir
zur Flugzeugbasis. Also sind wir jetzt in
der Elternklasse. Wir können von hier aus ziehen
und etwas, das wir am Ende
immer
machen wollen , heißt
Destroy-Akteur. Eine Sache, die wir vielleicht anders verwenden möchten , ist, dass ich es einfacher machen kann, Dinge
aufzuspüren. Wenn wir also C drücken, um hier einen Kommentar zu
platzieren, überlasse
ich es
mir, diese Art von Post-Notizen
zu machen, fast Wir können so etwas sagen wie den Pre-Death-Effekt
implementieren. Was passiert also,
bevor wir
unseren Schauspieler zerstören ? Das werden
wir genau hier machen. Das macht es wirklich
einfach, weil
du in
jeder Klasse die Strg-Taste in F drücken und nach Do
suchen kannst . Doppelklicken Sie darauf. Und wo auch immer Sie sich
in Ihrer Klasse befinden, wenn Sie noch eine Menge
zu erledigender Kommentare übrig haben, können
Sie schnell zu
ihnen springen und sehen, woran
Sie arbeiten können. Wir können auch auf
die rechte Seite kommen. Wir können dem
eine andere Farbe geben ,
nur um
es ein bisschen hervorzuheben. Es liegt ganz bei Ihnen, wie
Sie damit umgehen möchten. Aber wie ich bereits erwähnt habe, ist es
einfach eine nette Möglichkeit für mich, schnell
die Funktionen zu finden , die möglicherweise noch nicht vollständig implementiert werden können,
weil wir
diese Teile des Systems nicht berühren, aber ich weiß, dass ich
irgendwann
wieder hierher zurückkehren und
das tun muss . Wenn wir also später zurückkommen, um dies zu
aktualisieren, sollten Sie sich auf
diese Weise wirklich auf Ihren Arbeitsablauf
konzentrieren. Das hat im Moment nicht wirklich
etwas für uns getan. Das bedeutet, dass wir,
wenn wir später zurückkommen ,
um Effekte und
ähnliches hinzuzufügen, nicht zurückkommen
und unseren feindlichen Code ändern müssen. Das ist jetzt startklar. Wir können das gesamte Projekt
weiterentwickeln, und das wird
automatisch berücksichtigt, wenn wir die Funktionen hier
aktualisiert haben. Der Rest der Kollision
ist immer noch derselbe. Das wird immer noch so
ziemlich das sein , was wir hier tun
müssen. Sie könnten
das durch einen Kommentar ersetzen, weiteren zu erledigenden Kommentar, wenn
Sie möchten, aber auch haben
wir noch nicht
das Gesundheitssystem erreicht, also brauchen wir etwas, das uns
daran erinnert,
hierher zurückzukommen , und diese
Zeichenfolge ist in Ordnung. Wir wollen nur überprüfen
, ob das alles funktioniert, also gehen wir zurück in den
Spielmodus und stellen sicher, dass die Gegner und der Spieler
immer noch bewegen. Beabsichtigt, und das ist
alles ziemlich gut. Sie prallen immer noch von den Wänden
ab. Sie nehmen immer noch
ihre zufällige Richtung, zufällige Geschwindigkeit, prallen aneinander ab, und wir können wieder
zurückkommen und
das ändern , je nachdem, wie sich
das Spiel unserer Meinung nach entwickeln sollte Aber ich denke
, wenn das erledigt ist,
haben wir jetzt die gleiche Verhaltensweise Alles funktioniert
wie zuvor, aber mit der
richtigen Vererbung Es ist nur eine kurze Zusammenfassung, jetzt, wo wir unsere Umgestaltung abgeschlossen haben zur Vererbung übergegangen sind
.
Finden Sie heraus, was uns das gebracht
hat Das Wichtigste wird sein, dass wir das Kollisions-Setup gemeinsam genutzt
haben Wir können
diese Kugel einmal konfigurieren und sie wird in
beiden Klassen funktionieren , die das verwenden. Wir haben die gemeinsame
Todesstrafe. Also nochmal, wenn wir Dinge wie Sprengstoff und
Geräusche
hinzufügen, werden beide Klassen in der Lage sein, das zu benutzen Wir können den
Effekt bei Bedarf überschreiben, müssen
aber jetzt keine Änderungen
an unserem Basiscode vornehmen jetzt keine Änderungen
an unserem Basiscode Wir haben den Umschalter für die gemeinsame
Bewegungslogik Wenn wir
also die Animationen
hinzufügen, gilt
diese aktivierte
Bewegung sowohl
für
den Spieler als auch für den Feind für Zwischensequenzen Wir haben die gemeinsamen Variablen
wie die Bewegungsgeschwindigkeit. Es existiert, sobald wir
keine Duplikate oder mehrere Versionen
davon im Unterricht haben Vielleicht sehe ich meinen Overkill
im Moment nur
für diese beiden
verschiedenen Klassen, aber wir sind dabei,
Dinge wie Gesundheit,
Projektile,
Spornos-Effekte und so weiter hinzuzufügen Projektile,
Spornos-Effekte Wir werden jetzt einen gemeinsamen
Feature-Pool haben, aus dem Bedarf auf dasselbe zurückgreifen können,
anstatt es
zu dasselbe zurückgreifen können,
anstatt es Eine Sache, die mir gerade in den Sinn
gekommen ist, ist, dass wir diese
Sphären-Updates jetzt machen
könnten Wie ich bereits erwähnt habe, ist der
allgemeine Ansatz, den die Leute bei dieser Art
von Spiel verfolgen, für den Spieler. Wir möchten, dass die Kugel vielleicht
etwas kleiner ist, als Sie
erwarten würden. Also das könnte tatsächlich
in Ordnung sein. Wir könnten den
Kugelradius
möglicherweise ein wenig vergrößern. Wir können im Moment sehen, dass es sich
tatsächlich im Körper befindet. Es ist so klein, dass wir
es nicht sehen könnten. Projektil wird also die gesamte Flügelspannweite
und den größten Teil des Körpers
durchfliegen gesamte Flügelspannweite
und den größten Teil des Körpers
durchfliegen Das
ist, wie ich bereits erwähnt habe, nur, um dem Spieler das Gefühl zu geben, dass er ein bisschen besser ist
als er Wenn sie in
ihren Augen denken, dass
eine Kugel sie fast verfehlt hat, sie sie aber tatsächlich getroffen hat. Sie werden das
Gefühl haben, dass sie dem ausgewichen sind. Und was wir nicht wollen, ist
, dass es in die andere Richtung geht, wo sie das Gefühl haben, etwas hätten ausweichen
sollen, obwohl sie es eindeutig nicht getan
hätten,
und sie fühlen sich betrogen, wenn sie
diesen zusätzlichen Schaden in ihrem Kopf hinnehmen diesen zusätzlichen Schaden in die Kugel
ausgewählt ist, wollen
wir hier den
Kugelradius finden, und wir können ihn
auf etwa 50 setzen,
und Sie werden sehen, wo
das ins Spiel kommt Das ist also der Bereich
, in dem der Spieler Schaden erleiden
würde. Also vielleicht reduziere ich
das ein bisschen, also ist es nur der Körper, etwa 45, und ich denke das ist wahrscheinlich genauso viel Spielraum,
wie wir ihnen geben wollen Wenn wir auf Kompilieren klicken und dann zur feindlichen
Klasse
zurückkehren , ist das Gleiche Wir gehen in den
Viewpot und schnappen uns die Kugel, aber ich glaube,
dieses Mal könnte ich daraus etwas wie
64 machen oder es verdoppeln Und vielleicht ist das sogar ein
bisschen zu klein, also machen wir etwas wie 70. Also auch hier wird es sich so
anfühlen,
als ob
der Spieler das Gefühl hat, seine Schüsse viel
besser zu wird es sich so
anfühlen,
als ob
der Spieler das machen , dass er jedes Mal
,
wenn er einen Schuss abgibt , den Feind
genau so
trifft, wie er es geplant hat,
wo ihm tatsächlich , den Feind
genau so
trifft, wie er es geplant die Leiche fehlt,
aber wir werden das für ihn
aufheben und ihm das
Gefühl geben, dass für ihn
aufheben und ihm er es tut besser im Spiel,
als sie es vielleicht sein könnten. Offensichtlich wollen wir
das ausbalancieren. Wir wollen es nicht zu einfach
machen, aber Sie können sehen, dass es trotzdem nett und einfach ist, diese
Dinge zu optimieren So ist also die Erbschaft eingerichtet. Beide Klassen funktionieren, beide erben von
der Flugzeugbasis Als Nächstes können wir mit dem
Hinzufügen von Gesundheit und Schaden fortfahren. Und hier werden
Sie wirklich die Vorteile erkennen, die sich daraus ergeben sich diese Zeit vor
der Implementierung nehmen ,
um die Erbschaft einzurichten.
16. 15 - Gesundheitssystem: Zeit, Gesundheit und Schaden hinzuzufügen. Wir haben unsere Basisklasse bereits eingerichtet, um die
wichtigen Daten gemeinsam zu nutzen, also lasst uns direkt zur
BP Underscore Plane Base übergehen Hier werden wir
zwei verschiedene Variablen benötigen. Wir wollen
unsere aktuelle Gesundheit,
die Gesundheit, die wir
derzeit haben,
und unsere maximale Gesundheit verfolgen die Gesundheit, die wir
derzeit haben, . Wir können
das mit Floats machen, also nehme ich die
Bewegungsgeschwindigkeit, drücke die Strg-Taste, dupliziere das einmal und nenne das eine
aktuelle Gesundheit es ein zweites Mal duplizieren, nennen
wir es Max Health. Wenn wir auf Kompilieren klicken
, hole ich mir die maximale Gesundheit und setze sie auf den
Standardwert 100. Wir können den aktuellen
Gesundheitszustand leer lassen. Stattdessen
lassen wir zu Beginn des Spiels unsere aktuelle Gesundheit auf
den Hinrichtungsstift
fallen, unsere aktuelle Gesundheit auf
den Hinrichtungsstift
fallen, und wir wollen unsere
aktuelle Gesundheit nehmen und diese
als unsere maximale
Gesundheit festlegen . Keine menschlichen Fehler. Jedes Mal, wenn wir anfangen
zu spielen,
werden wir sicherstellen, dass wir bei voller Gesundheit
beginnen. Also eine nette, einfache Art
, einfach sicherzustellen, dass wir mit unserem Gesundheitssystem nichts falsch machen. Nochmals, nur zur Erinnerung. Deshalb ist es
wirklich wichtig. Wenn wir auf Kompilieren und Speichern klicken, gehen wir zurück in den normalen Player und
überprüfen Sie einfach, ob Sie
das Override-CE haben , um
mit dem Spielen zu beginnen, und
dasselbe gilt für den Feind. Das ist der Punkt, an dem es wichtig
wird, denn wir wollen sicherstellen
, dass beide
Klassen ihre Lebenspunkte auf
den Wert ihrer maximalen
Lebenspunkte setzen Wenn das bestätigt ist, können
wir auch
unseren Damage Handler einsetzen .
Das ist wirklich einfach. RL Engine verfügt über ein
integriertes
Nachrichtensystem speziell
für den Umgang mit Schäden. Wenn wir in
das Ereignisdiagramm klicken, müssen
wir nach einem
Ereignis suchen, das als Schaden bezeichnet wird. Es ist also dieser hier,
das Ereignis, jeder Schaden. Und das wird
immer dann aufgerufen, wenn wir
eine Nachricht von einem anderen Akteur senden , sei es ein Projektil,
ein Sprengstoff, der das
Flugzeug oder die gegnerische Klasse trifft, wir können eine Nachricht senden, um zu sagen:
Hey, du wurdest beschädigt Wenn diese Nachricht gesendet
und hier empfangen wird, dieser Ereignis- oder
Funktionsaufruf ausgeführt Und wenn das passiert,
wollen wir
nur unseren aktuellen Zustand einstellen, also ziehen wir das ins Hinrichtungs-Pentagon Wir machen das zu
unserer aktuellen Hölle, also nehmen wir die aktuelle
Gesundheit ein zweites Mal, ziehen sie mit der
Steuerung in das
Diagramm, um den Wert abzulesen, und das ist
negativ für unseren Schaden Also die aktuelle Hölle
minus einen Wert hier
, der unser Schaden ist
, den wir weitergeben. Das wird
also etwas sein, das wir in den Call
der anderen Klasse
setzen. Das Ergebnis dieser Berechnung
wird unser Gesundheitswert sein. Eine Sache, die normalerweise für diese
Art der Berechnung
empfohlen wird, ist zu vermeiden, dass die Dinge ein bisschen hackig oder seltsam Wir wollen keinen Schaden zulassen oder wenn wir auch
Heilung eingeführt haben, wollen
wir nicht zulassen, dass
diese Werte uns
über unseren Höchst- oder
Mindestschwellenwert bringen unseren Höchst- oder
Mindestschwellenwert Wir können also etwas verwenden, das
man eine Klammer nennt. Wir ziehen hier an dieser Stecknadel
und suchen nach einer Klammer. Wir wollen die Option Clamp Float, die ist nur ein
bisschen hier oben. Also Clamp Float. Und
das Ergebnis dieser
Klemmung stecken wir gleich hier in unseren Stift. So können wir sehen, was uns
das ermöglicht. Wir können unseren Mindestwert annehmen. Also die Mindestmenge an
Gesundheit, die wir haben sollten, ist Null. Und die maximale Menge an
Gesundheit, die wir haben können,
wird unser maximaler Gesundheitswert sein.
So nett und einfach. Das heißt einfach, wenn wir
etwas wie Gesundheitspakete hinzufügen, wenn du eines
davon kaufst, kannst
du maximale Gesundheit, mit der du angefangen hast
, nicht überschreiten. Das bedeutet, dass die Ergebnisse
dieser Berechnung
immer innerhalb dieses Bereichs bleiben. Sobald wir bestätigt haben, dass die
Einstellung der Gesundheit korrekt ist und wir nichts davon falsch machen
können, werden
wir überprüfen, ob
der Schaden, den wir gerade erlitten haben,
ausreicht, um uns zu vernichten. Also ziehen wir gleich hier von unserer
Hinrichtungsnadel. Wir werden nach einer Filiale
suchen. Unsere wahre falsche
Flusskontrolle hier. Und alles, was wir
tun wollen, ist wieder unseren aktuellen
Gesundheitswert
zu ermitteln,
also kontrollieren Sie ihn, ziehen Sie ihn rein.
Mal sehen, ob das weniger ist als. Also werden wir hier nach
dem Operator „Weniger als“ suchen. Und ich werde
tatsächlich überprüfen, ob dieser kleiner oder gleich
einer bestimmten Zahl
ist. Stecken wir das in den Zweig
hier, den Boolean, und wir haben jetzt eine
Prüfung, die besagt, dass wir, wenn unser aktueller Zustand
kleiner oder gleich Null ist, unser aktueller Zustand
kleiner oder gleich Null ist,
unser Aufruf der Death-Funktion oder
der Handle-Death-Funktion
bewältigen können Death-Funktion oder
der Handle-Death-Funktion
bewältigen Fragen Sie sich, warum wir
weniger als gleich verbrauchen,
vor allem, weil
wir das nur
so festgeklemmt haben, um sicherzugehen, dass es
nie unter vor allem, weil
wir das nur
so festgeklemmt haben Null fällt Und das ist einfach eine
Art Sicherheitsgewohnheit. Wenn etwas mehr
Schaden anrichtet als die verbleibende Hölle, oder wir eine Art
Fließkomma-Verrücktheit bekommen, oder auch wenn wir den Code
später einfach noch einmal
umgestalten und beschließen, das
nicht zu begrenzen, möchte
ich sicherstellen,
dass diese Prüfung immer relevant ist, um
sicherzustellen, dass wir Wenn wir
zum Beispiel diese Klemme nehmen, wenn wir fünf Lebenspunkte haben und weitere zehn
Schaden erleiden, werden
wir natürlich bei
minus fünf sein, was
bedeutet, dass, wenn wir nur Null
ankreuzen würden,
dann
würde etwas, das
mehr Schaden erlitten hat , als es sollte, verhindern, getötet zu werden . Aber wenn das erledigt ist, können
wir
von unserer Filiale hier aus den Tod übernehmen. Und wenn das stimmt, können
wir das einfach
einbauen Das
ist es, was jetzt
damit beginnen wird , alle Todesfunktionen für alle Flugzeuge zu übernehmen, die
Sie vielleicht bauen möchten, und natürlich für die beiden,
die wir bereits haben Handle Death enthält bereits
die Zerstörungsfunktion , und wie ich bereits erwähnt habe, werden
wir später hierher
zurückkehren, um Dinge wie Explosionen,
Soundeffekte und all
die lustigen, saftigen Dinge
hinzuzufügen Soundeffekte und all
die lustigen, , die wir in unser Spiel integrieren
möchten. Um das Schadenssystem tatsächlich zu
nutzen, haben
wir bereits etwas
eingerichtet, mit dem wir
zumindest teilweise testen können,
wie diese Struktur innerhalb unseres Feindes funktionieren
wird Wenn wir also zurück in die
feindliche Klasse gehen, diesen Teil hier
, der einfach am längsten
unsere Druckkette benutzt hat , können wir
das
endlich entfernen. Was wir stattdessen wollen, ist, dass
wir unseren Hauptdarsteller nehmen, also kontrollieren wir, ob wir
das in die Grafik ziehen. Wir ziehen uns von dem anderen Schauspieler und suchen nach der globalen Botschaft
, die ich
vorhin erwähnt habe, die dann Schaden anrichtet. Wir können hier also sehen,
dass wir Schaden angerichtet haben. Dadurch wird einfach jeder
Akteur angerufen , mit dem es
kommunizieren kann. In diesem Fall
wird es der sein
, auf den wir gerade gestoßen sind Wir werden
das einfach hier anhängen, also nehmen wir unsere
Hinrichtungsnadeln, stellen sicher, dass sie alle miteinander
verbunden sind, ziehen das aus dem Weg und wir wollen dem
Spieler eine bestimmte
Menge Schaden zufügen Ich denke, was die Gegner
angeht, werde ich
dieser Hälfte der Spieler Gesundheit geben dieser Hälfte der Spieler Gesundheit Ich weiß, dass der Spieler 100 Heals haben
wird. Wir setzen diesen Wert auf 50,
was bedeutet, dass der Spieler
zwei Treffer von einem Feind
einstecken kann , damit er
nicht zu oft auf ihn prallt Es wird kein
schneller und sauberer Weg sein,
zusätzliche Punkte zu sammeln , indem man einfach auf
alle Feinde zufliegt . Nun,
das erinnert mich daran. Eine weitere Sache, die wir
mit unseren ererbten Variablen machen können ist, wenn wir zum Beispiel
den Feind auswählen
und die Klassendetails
genau hier, auf der
rechten Seite, abrufen genau hier, auf der
rechten Seite, wollen
wir sicherstellen,
dass
sich die Gesundheit des Feindes wahrscheinlich von der Gesundheit des Spielers unterscheidet
. Wir könnten also die Gesundheit des
Feindes auf 50 setzen, und im Player, wir werden
einfach noch einmal nachsehen, dort die
Standardeinstellung 100 sein sollte Stellen Sie sicher, dass die
Gesundheit des Spielers auf 100 gesetzt ist. Also nochmal, eine nette und
einfache Möglichkeit,
den Gesundheitswert nur
einmal festzulegen und dies in
der übergeordneten Klasse
sowohl für den
erlittenen Schaden als auch für die
hier angegebene Gesundheit zu handhaben der übergeordneten Klasse
sowohl für den
erlittenen Schaden als auch für die
hier angegebene Gesundheit , da sie auf Variablen
basieren , die in
allen Klassen existieren werden. Und dann müssen wir in den untergeordneten Klassen nur diese Variablen im Editor
anpassen , wenn wir
die allgemeine Art
des Markups unseres Spiels
ändern wollen allgemeine Art
des Markups unseres Spiels
ändern Und wie ich schon erwähnt habe,
weil wir das
schon auf eine bestimmte Art eingerichtet haben ,
bedeutet das jetzt, dass wir den Tod
im Griff
haben Wir müssen nicht
zurückkommen und das anfassen. Wir mussten eine
kleine Änderung vornehmen, die Seite
der feindlichen Klasse
musste nicht
berücksichtigt werden und alles
wird so weiterfunktionieren, wie es war. Eine Sache, die ich
Ihnen ganz schnell zeigen möchte, nur weil dies ein weiterer dieser
wirklich klaren Orte
ist , an denen Sie versucht
gewesen sein könnten einen anderen Ansatz im Umgang mit dem Tod für
den Feind
zu wählen , ist, dass wir das vorerst einfach
abschalten könnten Eine andere Sache, die Sie tun
könnten, ist, dass wir unsere Funktion „
Schaden anwenden“
duplizieren könnten unsere Funktion „
Schaden anwenden“
duplizieren Wir könnten das hier
einbauen, weil die Hauptsache ist, dass wir, wenn
wir das Spielerflugzeug treffen, wissen, dass sich die gegnerische Klasse im Grunde
selbst Schaden zufügen
muss. Wir könnten unseren MAX-Gesundheitswert
nehmen. Wir können also nach MaxEL suchen
und das hier eingeben. Und dann der geschädigte
Schauspieler, wir könnten uns im Grunde einfach selbst
Schaden zufügen Wenn wir also von
dem geschädigten Schauspieler herkommen und nach einer Zelle suchen, bekommen
wir diese eingebaute Option die
ich einführen
wollte, um einen Verweis auf uns selbst zu
bekommen. Also das wird im
Grunde ein bisschen komisch sein. Dies wird im Grunde einen Verweis auf
sich selbst
finden , der hier zu finden ist. Es ruft die Meldung „
Schaden anwenden“ auf sich selbst auf, was natürlich in
der Basisklasse aufgegriffen
wird , denn dort
haben wir das Ereignis, bei dem jeder
Schaden ausgelöst wird. Und weil wir ein Höchstmaß
an Gesundheit weitergeben und das nur aus Sicherheitsgründen ist. Später entschied ich,
dass die Lebenspunkte
des Feindes mit 50 tatsächlich zu niedrig waren, und ich ging rein und
änderte sie auf 75. Natürlich
wollen wir diese
50 nicht fest codieren
lassen, weil
alle Änderungen, die wir auf einer breiteren Basis als
nur an diesem einen Knoten hier vornehmen,
gewissermaßen vergessen und übersehen würden . Nur eine andere Möglichkeit, wieder,
einfach darüber
nachzudenken, wie Sie Ihren Code
strukturieren, die Verwendung von Variablen,
hauptsächlich nur eine Art
Zukunftssicherheit , damit Sie in Zukunft
nicht mehr arbeiten müssen. Die Hauptsache bei Programmierern
ist, dass wir ziemlich faul sind. Je weniger Arbeit
wir erledigen müssen, desto besser,
sodass wir nicht zu unserem Code zurückkehren und überall
Variablen ändern Wenn wir so etwas
einrichten können, kann
ich die maximale
Gesundheit auf alles Mögliche ändern. Ich könnte sie senken, ich
könnte sie erhöhen. Diese Funktion wird es
immer geben. Wie ich bereits erwähnt habe,
liest es sich einfach nicht sehr sauber Es dauert etwas
länger, um herauszufinden, warum wir einen Schaden angerichtet
haben, einen
anderen hier, und was
diese verschiedenen Akteure sind Ich denke, es ist sinnvoller,
wenn wir einfach
eine Art Feind im
Kamikaze-Stil machen , wir können sie einfach anschließen,
und das macht es Also werden wir dem, was
wir getan haben,
Schaden zufügen , sobald wir das getan haben, werden
wir uns selbst
Schaden zufügen Und denken Sie daran, das ist wirklich sicher, denn wir
schauen hier unten, wir prüfen, ob
der Hauptdarsteller das
ist, was der menschliche Spieler gerade kontrolliert, und nur wenn das stimmt,
werden wir das tun. Das wird also keinen
Schaden an den Wänden, den Projektilen oder anderen
Feinden Das alles wird hier unten
abgerechnet. Das ist also eine nette, einfache und sichere
Methode, um Aufprallschäden zu strukturieren. Etwas, das ich nicht
wirklich erwähnt habe, aber denken Sie auch daran , dass die Reihenfolge der Bedienung wirklich wichtig
ist. Sobald Sie darüber nachdenken, wenn Sie noch nicht
darüber nachgedacht haben, wird
es wirklich offensichtlich. Es ist etwas
, das die Leute vermissen. Wenn wir uns zuerst um den Tod kümmern
würden, dann könnten wir es auch in
die andere Richtung werfen. Wenn wir das hier
einstecken, aushaken, das verschieben. Nur ein sehr kurzes Beispiel.
Stecken Sie das wieder ein. Und das nur, weil ich das schon einmal
gesehen habe. Die Schüler waren sich nicht ganz sicher, warum bestimmte Funktionen nicht
aufgerufen wurden , als sie es
erwartet hatten. Manchmal kann es auch systembedingt sein. Bei einigen Systemen könnte es funktionieren, anderen vielleicht
nicht, je nachdem, wie schnell die Ticket-Iteration und solche Dinge passieren
werden Aber im Grunde genommen, wenn Sie
darüber nachdenken, was hier passiert, wenn wir den Spieler treffen und zuerst handle death
aufrufen, springt
das in die übergeordnete Funktion ruft destroy auf, und wenn das Ganze
möglicherweise sofort zur
Müllsammlung hinzugefügt und aus dem Speicher gelöscht
wird, existiert
diese Klasse nicht mehr Das heißt, sie wird nicht wieder von hier weggehen , wieder in diese Funktion zurückkehren und dem Spieler Schaden zufügen könnte also sein, dass Sie am Ende ein Spiel haben, in dem der
Spieler einfach nie Aufprallschaden Seien Sie also vorsichtig mit
solchen Dingen. Und noch einmal: Es ist sehr
üblich, dass Leute sich
bereits mit der
Death-Seite von Funktionen auseinandergesetzt haben , und dann kommen sie
zurück und fügen danach
die Partikeleffekte und den
Sound hinzu und dann nicht sofort klar,
warum die Partikel und die
Soundeffekte nicht abgespielt werden . Das liegt daran, dass Ihre
Klasse wahrscheinlich aus dem
Speicher gelöscht
wird und sie nicht existiert. Diese Funktion wird
aufgerufen. Die Reihenfolge der Operation ist also auch wichtig. Flusskontrolle ist
ein anderes Wort dafür. Das war ein wirklich
einfaches Beispiel, aber es ist eine leichte Falle,
in die man tappen kann, wenn man nicht
genug aufpasst. Selbst wenn Sie das Konzept
verstehen, ist
es ein einfacher Fehler. Wenn wir also einfach
auf Kompilieren und Speichern klicken, können
wir wieder reingehen und
testen oder auf Play klicken. Die Sache, nach der wir hier
suchen, ist sicherzustellen, dass sie sich immer noch selbst zerstören
, wenn sie den Spieler treffen. Und am wichtigsten ist, dass sie nach
zwei Treffern, wie wir
sie dort gesehen haben, auch den Spieler
zerstören. Also haben weder der Spieler noch der
Feind ein Gesundheitssystem, wenn man bedenkt, dass
wir
dieses Gesundheitssystem nicht
in jeder Klasse implementieren werden. Wir machen das nur
einmal in der Basisklasse, und all diese Funktionen, um den Zustand
zu berechnen, zu
überprüfen, ob ihre Klasse tot ist, und dann die Funktion
aufzurufen, werden dort abgewickelt. Als ich mir das ansehe, wurde mir gerade klar, dass ich
wahrscheinlich ein bisschen
einen Programmier-Fauxpar
gemacht habe , das
wird uns tatsächlich ein kleines Problem bereiten weil wir
handle death aufrufen, obwohl wir berechnet haben,
dass der Tod angemessen
wäre , und
wir nennen es hier. Es besteht eine gute Chance
, dass zwei Gruppen von Partikeln miteinander
spielen. Wir werden einen
aus dem Störungsmeldedienst
und dann einen aus dem
Störungsmeldedienst bekommen , was
aus gesundheitlichen Gründen geschieht. Jetzt, wo ich meinen eigenen
Code durchschaue, sollten
wir meiner Meinung nach
genau so vorgehen, ich versucht habe
, es
nur als Lernbeispiel zu verwenden. Aber wenn wir das noch einmal duplizieren, müssen wir es
meiner Meinung nach anders
machen. Also werden wir uns selbst
Schaden zufügen. Also noch einmal, wir ziehen
vom Schadensverursacher ab. Wir sagen verkaufen und
stecken das hier ein. Das sorgt einfach dafür, dass man solche
Dinge wirklich leicht übersehen kann Zum Glück sind wir
zurückgegangen und haben uns den Code kurz angesehen. Dies stellt nur sicher, dass uns selbst Schaden zugefügt
wird. Wir werden den
gleichen Trick anwenden, den ich vorhin erwähnt
habe , also Maxel Und wieder wurde mir klar, dass ich das
aus dem Video herausschneiden könnte. Aber da ich
dieses ganze Projekt mit
der Absicht erstellt habe , beizubringen,
wie man über Programmieren nachdenkt, denke
ich, dass dies ein ziemlich
gutes Lernbeispiel dafür
ist , welche Dinge
man übersehen kann und wie
man sich leicht in
eine kleine Situation bringen eine kleine Situation , die man später noch einmal korrigieren muss Das wird also sicherstellen, dass wir uns
definitiv selbst umbringen. Wir geben
immer das
Maximum an Gesundheit weiter, das wir haben
könnten Dadurch wird das aufgerufen,
was sicherstellt, dass unser Handle Death immer nur einmal aufgerufen wird,
das heißt , wenn wir
zu den Partikeleffekten kommen, den Soundeffekten,
wird es hier einmal
aufgerufen und dann
auch hier einmal abgespielt. Das ist also das
Wichtigste, was wir vermeiden wollen, also kann ich das löschen. Es
liest sich nicht ganz so gut. Hier möchten Sie
vielleicht
einen Kommentar einbringen , nur um das
klarzustellen. Das ist für den Spieler. Das ist für dich,
damit du sicherstellst, dass wir uns immer aus
dem Spiel
entfernen, nachdem wir den Spieler getroffen haben. Wirklich einfache Sache,
wirklich kleine Sache. es zu einem größeren Thema gemacht,
nur weil es eher
ein Lernmoment ist, der ein Lernmoment ist, einfach versehentlich da
aufgetaucht Letzte Kleinigkeit, die
wir tun können, solange wir noch in der feindlichen Klasse Wir können die Verwendung
von magischen Zahlen abschaffen. Im Moment fügen
wir dem Spieler also nur 50
Schaden zu. Wir können das
zu einer Variablen heraufstufen und das nennen wir
einen Aufprallschaden. Überprüfe einfach noch einmal ob es noch andere gibt, die wir
vielleicht übersehen haben. Ich glaube, es war genau dieser.
Wir haben diese sogar, falls ihr eine minimale und maximale
Bewegungsgeschwindigkeit festlegen wollt , weil
der Feind
die Chance hat, diese zufällige
Reihenfolge zu erreichen. Es kompilieren, speichern,
zurück zum Player gehen , hier
nochmal nachschauen. Ich glaube nicht,
dass wir so viele Variablen
haben wie in letzter Zeit
, also ist das in
der Player-Klasse
und dann auch in der
Basisklasse in Ordnung . Etwas anderes, das Sie
vielleicht tun sollten, wenn Sie wirklich versuchen, all
diese Variablen sauber
zu halten , wenn Sie anfangen, viel
mehr Variablen
zu bekommen Es kann
etwas schwieriger werden .
Es kann
etwas schwieriger werden, herauszufinden, womit sie zusammenhängen Sie können Variablen also
Kategorien zuweisen, was hilfreich sein kann. Also
haben wir hier zum Beispiel die aktuelle Geschwindigkeit, die
Zielgeschwindigkeit und die Interp-Geschwindigkeit Diese drei
beziehen sich also alle auf Bewegung, und dann
beziehen sich diese beiden auf Rotation Was wir also tun können,
ist, wenn wir
eine davon
im Detailbereich auswählen , wir bekommen diese Option
hier für eine Kategorie, und wir können sie auf so
etwas wie Bewegung setzen. Und dann können wir die anderen Bewegungen
einfach per
Drag-and-Drop in die Bewegungskategorie ziehen. Wir können uns die Rotation schnappen
und
ihr vielleicht eine Kategorie
Rotation geben. Nochmals, gib sie und dann können wir sie
zusammenklappen. Macht es ein bisschen einfacher,
besonders wenn Sie
eine lange Liste von Variablen haben , die in größeren Klassen auftauchen Das heißt, Sie können
einfach sehr
schnell navigieren , um alle bewegungsbezogenen
Dinge zu finden , wenn Sie nach
einem ganz bestimmten Wert suchen, den Sie anpassen können
, und
demselben Wert für die Rotation Du kannst kämpfen. Sie können
eine Kategorie von Booleschen Werten, Vektoren, was auch immer Sie hier einrichten
möchten, einrichten Sehr viel darüber, wie Ihr Arbeitsprozess am besten zu Ihrem
Projekt passen
wird, aber nur eine schnelle Idee Wenn du
etwas zwischen den
Themen machen möchtest , kannst du gerne eine Pause einlegen, eine kleine Pause
vom Mitmachen einlegen und vielleicht noch einmal die anderen Klassen
durchgehen und schauen, wie du die Dinge vielleicht in
die Basisklasse und vielleicht
sogar in die gegnerische Klasse einordnen möchtest die Basisklasse und vielleicht
sogar in die gegnerische Klasse Ich werde das nicht auf dem Bildschirm machen,
aber es ist nur eine Idee, um
diese Konzepte zum Laufen zu bringen und
Sie wissen zu lassen , dass es diese
Funktionen gibt Damit ist unser
Gesundheitssystem jedoch abgeschlossen . Wir haben das einmal implementiert
und es funktioniert überall. Das bedeutet, dass wir zu
den Projektilen übergehen können. Und wieder können wir
jetzt einfach auf
dem Fundament aufbauen , das
wir bereits geschaffen haben Das wird der Zeitpunkt sein, an
dem der Kampf
interessanter wird und wir tatsächlich zurückschießen
können.
17. 16 - Verbesserte Bewegung: Erinnern Sie sich an den Fehler
bei der Bildrate, den wir erkannt und
gerade behoben haben. Es ist Zeit, darauf
zurückzukommen und es zu beheben. Wir werden den
problematischen Bewegungscode
durch einen produktionsbereiten Code ersetzen . Richtige Unabhängigkeit bei der Bildrate, sauberere Struktur
und bessere Füllung. Mir ist klar, dass
wir, bevor wir anfangen,
ausgefallene Dinge wie
Schauspieler-Spawner und
Projektile hinzuzufügen ,
ausgefallene Dinge wie
Schauspieler-Spawner und das Schadenssystem zu
konkretisieren, während wir diesen Faktor und die Verbesserung
des Basiscodes vornehmen, wahrscheinlich zurückkehren
und sicherstellen sollten, dass wir die Bewegung und
den Bug, den wir bereits kennen, nicht vergessen Bug, den wir bereits kennen, Der fehlerhafte Code
, den wir korrigieren
müssen, befindet sich in unserer Spielerklasse. Also, wenn du das noch nicht geöffnet
hast, mach weiter und öffne BP
Underscore Plain Player In meinem Fall drücke ich einfach die
mittlere Maustaste und
schließe die Tabs, die
wir nicht verwenden werden Also Basisklasse und
Feindklasse und navigiere zur
Griffbewegungsfunktion gleich hier drüben. Das ist also der Code, den wir ersetzen und verbessern
wollen. Als Erstes wollen
wir nach der Bewegung
des übergeordneten Handles auf diesen Code klicken und
ihn enthaken Manche Menschen haben
unterschiedliche Meinungen zu solchen Dingen Auch hier möchte ich mich weiterhin auf die Codestruktur,
bewährte Verfahren und solche
Dinge
konzentrieren . Was Sie vielleicht sehen, insbesondere
in C plus plus Code, ist einige Entwickler
den alten Code behalten dass
einige Entwickler
den alten Code behalten, den wir zu ersetzen
versuchen. Vielleicht schreiben Sie das in einen Kommentar,
nur für den Fall, dass Sie es später
sehen möchten , falls Sie denken, dass Sie
darauf zurückgreifen müssen. Das endet mit einem
überfüllten Arbeitsbereich. Sie haben vielleicht viel mehr Code in Ihrem C Plus Plus,
als Sie benötigen In Blueprints können wir
natürlich
viel mehr Dinge nur
im Diagramm haben , als wir brauchen Und idealerweise
würden wir sowieso
so etwas wie Github für die
Quellcodeverwaltung verwenden sowieso
so etwas wie Github für die
Quellcodeverwaltung Wenn wir uns also jemals alten Code
ansehen müssten, würden
wir im Idealfall einfach
unser Repository zurücksetzen und uns das über Git
oder Perforce oder so ansehen In diesem Fall werde
ich das nur für einen Moment behalten
, weil ich denke, es gibt ein paar Dinge, die wir der Schnelligkeit halber einfach
kopieren und einfügen können, aber wir werden diesen Code
komplett loswerden Also werden wir diesen neu
beginnen. Das erste, was wir tun
wollen, ist von unserem
Ausführungs-Pin hier oben zu ziehen und etwas zu
erstellen, das als Sequenz
bezeichnet wird . Wir wollen diese Option genau hier haben. Und falls Sie diese noch nicht
gesehen haben, werden
Sequenzen stark zu
wenig genutzt Sie sorgen dafür, dass sich unser Blueprint wie herkömmlicher Code
liest, also von oben nach
unten, von links nach rechts Jeder der Pins erfüllt
eine bestimmte Aufgabe, oder zumindest sollten
wir
darüber nachdenken, sie auf diese Weise zu verwenden Das ist viel sauberer als Logik sich über
alle drei Monitore erstreckt, nur weil Sie
diese lange logische Linie haben. Nur um darauf hinzuweisen,
ich gebe nicht an. Das war übertrieben. Ich
habe eigentlich nicht drei Monitore. Es gibt noch andere
Vorteile und Gründe
, warum Sie das vielleicht nutzen
möchten, aber die Hauptsache, zurück zu Sequenzen,
ist, dass sie
einfach eine wirklich nette
Möglichkeit sind ,
unseren Code zu strukturieren und uns zu helfen Dinge
logisch im Wesentlichen in Schritte zu
unterteilen Du sagst, mach das,
dann tu das, dann tu das, und du versuchst, alles
irgendwie einzigartig für eine bestimmte Aufgabe zu halten irgendwie einzigartig für eine bestimmte Aufgabe zu Das Erste, was wir bei unserer gegebenen Aufgabe eigentlich wollen, ist, dass wir unsere
Zielbewegungsgeschwindigkeit berechnen müssen. Das machen wir hier unten schon, also
das ist eines der Dinge
, die wir uns einfach schnappen können. Wenn wir den Code bis zum
Zielknotenpunkt für die Bewegungsgeschwindigkeit abrufen, Strg-Taste in X
drücken, dann kommen wir rüber
und fügen ihn ein. Das wird also die
allererste Aufgabe sein , die wir uns in
unserer Sequenz stellen. Eine weitere Sache, die
uns helfen kann, den Code ein
wenig lesbar zu halten , ist, wenn wir auf ein Kabel
doppelklicken, wodurch wir einen Reroot-Knoten erhalten Wir können das
hier nach oben verschieben, weil wir sichergehen
wollen , dass wir genug Platz haben, im Wesentlichen für den anderen Pfad
, dem wir folgen Eine Sache, die wir jetzt ändern
werden, ist, dass
wir unsere eigene Interplation erstellen werden Wir werden F Interp Two nicht verwenden. Aus diesem Grund werden
wir die Get
World Delta-Sekunden
ein wenig ändern Get
World Delta-Sekunden
ein wenig Man wird diesen Knoten
hier los, dann multipliziert man sich. Hängen Sie das direkt an die
eingestellte Zielgeschwindigkeit an, und wir werden diese Bildrate etwas
später
unabhängig
machen . Wir behalten das bei uns. Wir werden das
gleich brauchen. Die bekommen Welt-Delta-Sekunden. Aber das ist so ziemlich alles.
Das ist unser erster Schritt. Als Erstes müssen wir ein Ziel haben,
das wir erreichen müssen. Das verbündet uns dann. Dann
können wir zu dem einen gehen. Und wir werden hier
unsere eigene benutzerdefinierte
Interpellation Alpha berechnen unsere eigene benutzerdefinierte
Interpellation Das wird ein
bisschen mathematisch werden, aber es wird der Schlüssel zur
richtigen Unabhängigkeit der Farmen sein richtigen Unabhängigkeit der Farmen Wir gehen das durch,
wir fügen das hinzu, und dann werde ich einen Schritt
zurückgehen und versuchen zu
erklären, warum wir am Ende zu einer Berechnung kommen, die wir haben Das allererste,
was wir wollen, ist unsere Bewegungs-Interp-Geschwindigkeit, also werden wir das per
Drag-In
kontrollieren und die Interp-Geschwindigkeit der
Bewegung ermitteln Wir multiplizieren das
mit unseren Delta-Sekunden, weshalb es
gerade erst verfügbar ist. Wir werden
also unsere Funktion „
Welt-Delta-Sekunden abrufen“ verwenden, um unsere um Berechnung wieder unabhängig von der
Framerate zu
machen Dann wollen wir die Berechnung,
die wir erstellen, negieren oder umkehren , also werden wir hier multiplizieren Wir werden den Knoten multiplizieren und diesen
mit minus eins multiplizieren Aus unserer Berechnung hier ziehen
wir wieder ab. Ich werde nach
etwas suchen, das EXP heißt. Das ist der
Exponentialwert, also steht hier, das
Exponential E mit dem Wert
potenziert wird .
Also werden wir das verwenden Und dann, nach
unserem Exponentialknoten, ziehen
wir von hier ab
und wir werden subtrahieren,
also drücken Sie einfach die Minus-Taste,
suchen Sie Subtraktion und subtrahieren Sie
eins von der endgültigen ziehen
wir von hier ab
und wir werden subtrahieren, also drücken Sie einfach die Minus-Taste,
suchen Sie Subtraktion also drücken Sie einfach die Minus-Taste, und subtrahieren eins von der Das Wichtigste,
bevor
wir vergessen , dass wir natürlich
keine magischen Zahlen wollen, wir ziehen
vom letzten Wir werden das zu einer Variablen
heraufstufen und
diese MV Alpha nennen. Wenn Sie Kategorien
erstellt haben, möchten
Sie dies vielleicht
in die Kategorie Bewegung verschieben. Denn das wird
natürlich bewegungsspezifisch sein. Wir werden das an unseren Ausführungs-Pin anschließen, dann an einen, und schon haben wir
unseren Alpha-Code einsatzbereit. Das ist also unsere reibungslose
Interpolation, die wir
in unserem Code eher manuell und
bewusst verwenden werden in unserem Code eher manuell und
bewusst verwenden werden Um uns wieder
darauf zu konzentrieren, was das macht,
das gibt uns eins minus E
zur negativen
Geschwindigkeit mal das gibt uns eins minus E zur negativen
Geschwindigkeit Im Wesentlichen sorgt dies für
eine glatte Abklingkurve. Das ist der Hauptgrund, warum
wir am Ende die Option
Eins subtrahieren müssen , da wir wollen
, dass das mit der Zeit zerfällt Und der Grund, warum wir eine Formel
wie diese verwenden
müssen , ist, zur Hauptursache des
Problems zurückzukehren ,
das wir zwischen
verschiedenen
Bildraten haben, und die Dinge unabhängig von der Bildrate zu halten Dinge unabhängig von der Bildrate Die F-Interp-Funktion bietet
tatsächlich eine
lineare Näherung,
und das ist es, was
bei niedrigen Bildraten kaputt geht Wenn wir im Vergleich dazu eine Funktion
wie diese
erstellen, die wir mit
einer Standard-LARP-Funktion verwenden können, ermöglicht uns
dieser exponentielle
Ansatz mathematisch korrekte Das war also das
Hauptziel hier, wir wollen
eigentlich einfach komplett aufhören, das zu
benutzen abschließend daran
, dass wir versuchen wollen, sehr einzigartige spezifische
Dinge pro Zeile zu
tun. Wir werden einen weiteren Pin hinzufügen, und wir wollen die
beiden Pins genau hier haben. Wir ziehen von hier aus, und wir wollen
die letzte Sache machen, nämlich
die aktuelle Geschwindigkeit verwenden sie interpolieren Wir wollen immer noch Interpolation
verwenden, aber nur die
rudimentärere Basisversion mit Also können wir aus
dem Ausführungsstift ziehen. Wir können die
eingestellte aktuelle Geschwindigkeit ermitteln. also den Wert einstellen, den
wir verfolgt haben, und das ist der Punkt,
an dem wir von diesem Pin hier ziehen wollen, und wir werden nach Loop
suchen. Und dieses Mal wollen wir
nur
den Standard-Float-Loop verwenden . Sie können also sehen, dass es
etwas einfacher ist. Anstatt den
Strom zum Ziel
zur Delta-Zeit und
eine Interp-Geschwindigkeit zu haben, müssen wir, wenn wir
die Interp-Geschwindigkeit ändern wollen, hier
eine Art Offset hinzufügen Wir stellen lediglich diese Exponentialkurve zur Verfügung
, die unser Alpha sein wird Wenn wir also den Zug Alpha einziehen, können
wir ihn hier einwerfen Aber abgesehen davon
machen wir im Grunde immer noch das Gleiche. Wir werden uns von A nach B
bewegen. Und ich habe
das erwähnt, als wir uns das F in den ersten beiden Bereichen
angesehen haben, wir haben 0,1 in 0,2 oder Punkt A und Punkt B. Also machen wir
immer noch das Gleiche. Wir gehen von A, das
ist die aktuelle Geschwindigkeit, zu B, was unsere Zielgeschwindigkeit
über einen bestimmten Zeitraum ist, und wir basieren jetzt
auf unserer eigenen benutzerdefinierten Alpha-Bewegung Die wichtigste Änderung
besteht darin, dass die Art und Weise, wie
wir die aktuelle
Geschwindigkeit einstellen, aktualisiert wird Wenn wir das also durchgehen, können wir das jetzt
tatsächlich löschen. Wir können also sehen, dass wir
fast die meiste Zeit damit beschäftigt sind , unsere Codebasis zu aktualisieren. Ich
doppelklicke hier nochmal, um
einen weiteren Reroot-Knoten zu erstellen , nur um das Ganze einigermaßen aufgeräumt zu
halten, Dinge
aus dem Weg zu räumen, uns
einfach
genug Platz zu geben Die letzte Sache ist also, dass wir unseren Standort erneut festlegen
wollen. Wir werden auch hier
etwas anderes machen . Nachdem wir also
die aktuelle Geschwindigkeit eingestellt haben, wollen wir, sobald wir die Geschwindigkeit
verfolgen, von
unserem Ausführungs-Pin ziehen
und nach etwas
suchen, und nach etwas
suchen man Add Actor World Offset nennt. Wir können die
Option also genau hier oben sehen , bei Actor World Offset. Für unseren Anwendungsfall ist dies also
tatsächlich die bessere Lösung im Vergleich zur Einstellung der
Position des Schauspielers für
physikbewusste Bewegungen. Das Einzige, was
wir wirklich ändern
müssen, ist, dass wir hier mit der
rechten Maustaste auf den
Delta-Ortsvektor klicken und den Strukturstift
teilen, sodass
wir dieselben Ergebnisse wie zuvor erhalten. Wir wollen
unsere aktuelle Geschwindigkeit nehmen, damit wir sie einstecken können, wenn Sie möchten, aber in diesem Fall werde
ich nur Zugstromgeschwindigkeit steuern Wir werden das mit
Delta-Sekunden multiplizieren. Also werden wir weitere
G-Welt-Delta-Sekunden bekommen und das werden wir hier in
unser Ergebnis einbauen. Und dann machen
wir das
natürlich zum Y, weil wir uns von einer Seite zur anderen
bewegen. Also wollen wir das auf der
Y-Achse haben. Das ist so ziemlich alles. Also haben wir jetzt aktualisiert. Wir können das auch
loswerden. Wir haben jetzt
unseren Bewegungscode aktualisiert. Wir verfolgen die
Zielgeschwindigkeit etwas anders. Wir haben unser komplett
benutzerdefiniertes Bewegungs-Alpha auf einer Zerfallskurve
basiert, und wir haben die Art und Weise
, wie wir mit
der aktuellen Geschwindigkeit umgehen und wie wir sie mit der Position
der Welt verbinden, ein
wenig geändert die Art und Weise
, wie wir mit
der aktuellen Geschwindigkeit umgehen und wie wir sie mit der Position
der Welt verbinden, ein
wenig der aktuellen Geschwindigkeit umgehen und wie wir sie Position
der Welt verbinden, ein Eine Sache, die wir hier tun
könnten, nur um die Dinge ein wenig zu verbessern,
ist, dass wir
wieder Dinge kommentieren könnten Also nochmal, das ist eine nette Verwendung von Kommentaren, wenn wir
diese schönen großen Spaltungen
spezifischer Logik in unserer haben spezifischer Logik in unserer also was wir tun könnten, ist, diese Knoten hier oben zu
nehmen und C zu
drücken. Und wenn ich dem einen Kommentar geben
wollte, würde
ich vielleicht so etwas sagen wie die festgelegte Geschwindigkeit, die das Flugzeug erreichen soll Und damit ich später nicht in den Code
eintauchen muss, könnte
ich einfach angeben,
dass dies
genau die
Zielgeschwindigkeit ist , die wir uns ansehen. Auch hier könnte ich diese Art von einzigartigen
Farben verwenden, nur damit die Kommentare von
anderen
Dingen abheben , die wir zuvor
erstellt haben. Wir müssen das nicht tun und dafür sorgen, dass alles wirklich hübsch
aussieht. Davon kann man sich definitiv
mitreißen lassen. Aber wenn ich
die Farbe von Dingen ändere, ist
es eher so, dass ich auf
einen Blick weiß, dass ich für Kommentare ein bestimmtes
Grau verwende. Ich verwende ein bestimmtes Rot für potenziell fehlerhaften Code oder etwas, das alle zusammen verschoben werden
muss. Normalerweise verwende ich zum Beispiel
ein grünes Zeichen für To Do. Also nochmal, nur auf
einen Blick, kann ich sehen, wie ich meinen Code
durchgehe. Dies sind nur Kommentare
, bei denen ich eine Auffrischung benötige.
Das muss ich später wirklich loswerden, und solche Dinge
können nützlich werden. Also gebe
ich ihnen eine sehr blaue,
gräuliche Farbe, nur
um mich daran zu erinnern drücke
einfach Strg C und
Strg V, um hier drüben
einen weiteren Kommentar zu bekommen, den duplizieren wir Strg V, um hier drüben
einen weiteren Kommentar zu bekommen, quasi, und wir verschieben ihn grob an richtige Stelle, damit ich
die Farbe
nicht noch einmal einstellen muss . Und das
ist eines dieser Dinge. Sobald Sie sich an Abkürzungen
und solche Dinge gewöhnt haben, die winzige zusätzliche
Zeit, die Sie benötigen, um sich eine benutzerdefinierte
Farbe und Art von
Theme-Dingen zu
geben ,
Ihre Entwicklungszeit nicht wirklich so sehr. Wenn ich
mir also einen Kommentar für später hinterlassen würde, hilft uns
das, Alpha
für die Verwendung in unserer
Interplationsfunktion zu verfolgen für die Verwendung in unserer
Interplationsfunktion Ich erinnere
mich noch einmal daran, dass es sich dabei ausdrücklich um eine Aktualisierung der
Funktion „Alpha verschieben“
handelt Und dann wollen wir vielleicht noch
einen Kommentar. Ich habe bereits erwähnt, dass ich
das nicht für jede Codezeile tun werde, und ich werde das auch nicht für den
Rest des Projekts und
der Videos tun , da die Videos zu lang werden
würden. Aber nur um das
Konzept zu zeigen, während wir einige dieser größeren
Umgestaltungen und Änderungen
durchgehen , die vielleicht
etwas verwirrender sein könnten, denke
ich, dass es auf jeden Fall
wertvoll ist, sich das anzusehen Also werden wir sie einfach an
ihren Platz bringen. Und was ich das nennen könnte,
ist, dass wir
unsere aktuelle Geschwindigkeit aktualisieren und dann den
Standort unseres Flugzeugs festlegen. Und wenn ich das sage, ist
das
eine weitere wirklich nützliche Sache Ich stelle jetzt
meinen eigenen Code in Frage , weil wir zwei Dinge pro Zeile
machen Und wenn Sie sich erinnern, sagte ich, die allgemeine Regel ist, dass
wir
mit einer Sequenz sie
ein bisschen wie
Funktionen behandeln , bei denen
Funktionen eine bestimmte Sache
und eine Sache wirklich gut
machen sollten und eine Sache wirklich gut
machen Im Moment folgen wir dem also
hauptsächlich. Damit wird speziell
die Zielgeschwindigkeit festgelegt. Das ist die Berechnung und Einstellung speziell der Bewegung Alpha, aber das macht jetzt eigentlich
zwei Dinge. Es stellt die aktuelle Geschwindigkeit und bewegt dann das Flugzeug. Ich könnte also
versucht sein, eine weitere
hinzuzufügen und dann hier unten feststecken, Brustkontrolle in X,
Kontrolle in V. Schließen Sie das an Und mehr als alles andere hätte
ich es lassen können, aber nur um zu zeigen, wie
einfach es ist, den Code sauber
zu halten und bestimmte Regeln
und Strukturen zu
befolgen Jetzt halten wir uns also tatsächlich an die
Regeln, die wir uns selbst gegeben haben, und ich muss die Dinge
nur ein bisschen
verschieben und hier vielleicht einen weiteren Reroot-Knoten
hinzufügen Die Dinge ein bisschen aufräumen. Auch hier versuchen wir nicht, dieses Kunstwerk
zu machen,
aber je einfacher es
ist, damit zu arbeiten, desto dankbar
wird uns
unser zukünftiges Ich sein Was wir jetzt tun, ist, wenn wir
irgendwie an den Code denken. Wir können kommen und die letzte Bemerkung dazu machen
. Das ist also die Einstellung der
aktuellen Geschwindigkeit auf der Grundlage einer einfachen Interplation,
also Das ist also die eine Sache, die diese Leitung speziell macht Und dann
brauchen wir noch eine letzte Bemerkung, also hat Control C Control
V das eingerichtet. Ich meine, ich habe einen wirklich
schönen logischen Baustein, also
aktualisiert er jetzt einfach den Standort des Flugzeugs. Wenn wir das also lesen
,
können wir genau sehen,
was passiert. Wir legen die Zielgeschwindigkeit fest. Wir aktualisieren die Move-Alpha, die später für die
Interpret-Funktion verwendet wird. Wir verwenden diese
Interpret-Funktion und stellen die aktuelle
Geschwindigkeit auf dieser Grundlage ein. Und dann nehmen wir
diese Variablen und aktualisieren den endgültigen Standort des
Flugzeugs. Also das ist jetzt wahrscheinlich besser als das, was ich
noch vor einem Moment hatte. Es ist nur eine kleine
Änderung, aber auch hier, Regeln halten, wir uns an diese im Grunde
als kleine Funktionen, und sie alle
machen diesen einen Job sehr spezifisch und
sie machen ihn gut. Sorgen Sie für Ordnung, sorgen Sie dafür, dass
alles leicht lesbar ist. Und wenn wir jemals
zurückkommen und etwas
entfernen oder etwas hinzufügen müssten , dann wird es in Zukunft viel einfacher
sein, unseren
Code zu aktualisieren und zu korrigieren Da ist es also wie eine Seitentangente. Ich hatte nicht erwartet
, so
ausführlich auf die Sauberkeit des Codes einzugehen, aber ich habe einfach wieder die
Gelegenheit gesehen, weil ich aber ich habe einfach wieder die
Gelegenheit gesehen, weil ich
irgendwie gegen das verstoßen habe, was ich zu
Beginn des Themas
erwähnt habe zu
Beginn des Themas
erwähnt Das ist erledigt. Das ist die
Bewegung, die jetzt startklar ist. Als Nächstes
müssen wir uns mit dem Rotationssystem befassen. Es wird dasselbe
Problem sein, weil
wir dieselbe Art von Dingen verwenden. Wenn wir uns um die Rotation kümmern. Wir haben eine wirklich einfache
Funktion, was
wiederum das wirklich Schöne ist , was Unreal für uns tut Es bietet eine Menge
dieser Hilfsfunktionen, dieses eingebaute R-Interp zwei, nett und einfach, einen Knoten, ein paar Knoten daneben
für die Berechnung,
und dann die aktive Rotation einstellen, und schon sind wir
startklar für den Test Aber etwas, dessen sich die
Leute
bewusst sein müssen , ist, dass
es im Allgemeinen nur zum Testen
geeignet Wir wollen wahrscheinlich anfangen
,
unseren eigenen Code zu entwickeln, wenn wir
ernster werden und die Dinge
tatsächlich angehen. Bevor wir mit der
Fixierung der Drehung fortfahren, müssen wir nur ein paar Dinge beachten, um die Bewegung des Griffs zu
überprüfen. Da wir die aktuelle Geschwindigkeit auf diese Weise
etwas
manueller einstellen werden
, möchten
wir wahrscheinlich sichergehen , dass ich gerade erst bemerkt habe, als ich darauf
geklickt habe, dass aktuelle Geschwindigkeit
einen Standardwert hat Der Standardwert war hier
im Wesentlichen die Zeit, als dies
ursprünglich unsere allgemeine
Bewegungsgeschwindigkeit Also werden wir das zurücksetzen
wollen und sicherstellen, dass die aktuelle Geschwindigkeit, Zielgeschwindigkeit der
Bewegungsinterp-Geschwindigkeit einen Wert haben, aber die Zielgeschwindigkeit und die
aktuelle Geschwindigkeit des Mobs standardmäßig alle auf Null
gesetzt sind und diese nur zur Laufzeit
berechnet werden Die andere Sache, das gleiche Problem,
wirklich einfach wieder zu machen,
ist, dass ich fast vergessen habe, die Sweep-Funktion
anzukreuzen, also hat sie dieselbe Funktion wie die
Funktion zum Einstellen der tatsächlichen Position, die wir zuvor verwendet haben, also müssen wir sicherstellen
, dass der Sweep aktiviert ist. Das sollte
so gut wie fertig sein. Das wird im Moment nicht
vollständig funktionieren. Und mir wurde gerade klar, dass wir
das falsch gemacht haben. Ich glaube, ich habe dir
vorhin gesagt , du sollst das
Richtige abziehen, aber während der Implementierung
habe ich das falsch angeschlossen Wenn wir also mit der Alt-Taste
hinter der Exponentialzahl klicken, was
hier wirklich wichtig ist, wollen wir unsere
Berechnung von
eins subtrahieren Also arbeiten wir von
einer zurück. Wir erstellen diese Zerfallskurve aus einer, die auf
diesem Update im Laufe der Zeit basiert. Also ja, es wird nur
schnell getestet , um
sicherzustellen, dass das immer noch funktioniert. Wie ich bereits erwähnt habe, wird
die Rotation ein bisschen überarbeitet, aber wir haben immer noch
die gleiche Bewegung, also haben wir eine schöne,
gleichmäßige Bewegung, die Rotation, weil sie auf der Geschwindigkeit
basiert, die wir haben, die ist komplett kaputt, aber damit können
wir arbeiten, und wir
verbessern das irgendwie, wenn wir die Rotation
durchgehen und
umgestalten Also nur ein paar
abschließende Rückblicke. Stellen Sie sicher, dass wir unsere Berechnung
für unseren Exponentialwert
durchführen , und dann nehmen wir
diesen Wert von eins weg. Es ist also eins minus unserer
Exponentialrechnung hier, und das ist das Ergebnis, das
wir für unseren Zug Alpha wollen Aktuelle Geschwindigkeit, Zielgeschwindigkeit, idealerweise wirst du
auf Null gesetzt Wir berechnen das hier, multiplizieren sie wieder miteinander
und wir erhalten hier eine schöne Bewegung, die von der Bildrate
unabhängig ist fühlt sich also immer noch
an und funktioniert sehr ähnlich wie das,
was wir zuvor hatten Möglicherweise
müssen Sie die Geschwindigkeit jetzt ein
wenig anpassen , aber wir sind dem, was wir hatten,
sehr nahe Rotationen sind kaputt,
was, wie gesagt, zu erwarten
ist, weil wir hier
eine sehr einfache Berechnung verwenden hier
eine sehr einfache Berechnung auf der Zielgeschwindigkeit
basiert und diese
einfach mit dem Neigungsfaktor
multipliziert, und jetzt wird die
Zielgeschwindigkeit oder die aktuelle Geschwindigkeit, tut mir leid, auf ganz
andere Weise behandelt Aber damit
haben wir die Bewegung verbessert. Es ist eine wirklich gute
Grundlage, um loszulegen, und dann können wir
direkt mit der Rotation Ich weiß diese
ziemlich schweren Themen zu schätzen während wir das durchgehen, hoffe
aber, dass wir uns zwischen den Themen etwas Zeit
nehmen, wieder eine
Pause einlegen, wann immer
Sie es für
nötig halten , und versuchen Sie wirklich zu verstehen, was
wir getan haben und warum diese Änderungen funktionieren werden Ich habe versucht, die Mathematik
und das, was dahinter steckt, zu erklären. Einige der Dinge sind
wirklich schwer zu vermitteln ohne praktische Erfahrung mit
dem Quellcode zu haben. Eine weitere Sache
ist, dass Sie
in den Unreal Engine-Quellcode springen und die Ler-Funktion
in C plus Plus
finden könnten in den Unreal Engine-Quellcode springen und die Ler-Funktion in C plus Plus
finden Und auch wenn
Sie C Plus
Plus nicht vollständig verstehen, ist das in Ordnung Das meiste davon ist für Menschen
sehr gut lesbar. Die Kommentare sind alle da. Es erklärt Schritt für Schritt, was mit der
F-Interp-Funktion passiert Schritt, was mit der
F-Interp-Funktion Und manchmal tauche ich einfach auf diese Weise in
den Quellcode ein, da alles
leicht verfügbar ist wirklich nützlich sind, werden Sie
anfangen, einige der Einschränkungen zu verstehen ,
die sich ergeben, wenn Sie nur die neu erstellten,
vordefinierten Funktionen
verwenden , die von der Unreal Engine
bereitgestellt werden soll nicht heißen, dass sie schlecht ist, wie ich bereits erwähnt habe, sie
hat ihre Anwendungsfälle, aber wir finden diese Randfälle, in denen
sie einfach nicht funktioniert, und wir müssen unseren eigenen
Code erstellen
18. 17 - Verbesserte Rotation: Bewegung eingerichtet. Wir müssen jetzt dasselbe
für unsere Rotation tun. Wir wollen immer noch Teil
des Flugzeugs sein. Wir werden mit der Funktion zur Drehung des
Griffs beginnen. Ich werde hier ein sehr
ähnliches Update machen. Das ist eine weitere
nette Sache, mit der wir anfangen
können,
den Code
etwas einheitlicher zu gestalten , da die Logik dahinter sehr ähnlich
sein wird. Tatsächlich können wir hier also
unsere ersten Schritte unternehmen. Wir werden das nach unten verschieben. Wir werden das aushängen
und
alles behalten, worauf wir später noch
zurückkommen könnten, aber wie du schon gesagt
hast, werden wir das bis zum Ende einfach komplett
loswerden Jetzt
wollen wir als Erstes unsere Sequenz bekommen. Wir können dasselbe wieder tun. Also nehmen wir einen Sequenzknoten
und fangen an, ihn sauber und ordentlich zu halten
, weil wir dafür
ziemlich viel
rechnen müssen ziemlich viel
rechnen Also werden wir dafür sorgen, dass unser Code sauber und
ordentlich Jetzt gibt es noch ein
bisschen mehr, was wir für
die Rotation tun müssen , weil
es,
wie ich schon sagte, zuvor ein
willkürlicher Wert war, der einfach
mit der aktuellen Geschwindigkeit
multipliziert wurde, ohne dass wirklich etwas aktuellen Geschwindigkeit
multipliziert anderes berücksichtigt Also werden wir ein
bisschen klemmen und aufräumen, um das Ganze auch
etwas raffinierter zu gestalten Was wir wollen, ist, dass wir
unser derzeitiges Tempo beibehalten. Wir werden die aktuelle
Geschwindigkeit erreichen, die wir haben, also werden wir
sie immer noch ungefähr auf derselben Grundlage aufbauen, aber mit einigen Änderungen. Die Art und Weise, wie wir
das machen werden, ist von der aktuellen Geschwindigkeit aus. Wir wollen ein
sogenanntes Map Range Called verwenden . Dadurch wird ein
Wertebereich einem anderen zugeordnet, was sich perfekt für die Umrechnung der Geschwindigkeit
in einen bestimmten Neigungswinkel Im Bereich A wird
unsere Bewegungsgeschwindigkeit negiert. Wir klicken also mit der rechten Maustaste und
suchen nach der Bewegungsgeschwindigkeit, weil sie
von unserer übergeordneten Klasse aus aufgerufen wird, der tatsächlichen Zielgeschwindigkeit, der Höchstgeschwindigkeit, mit der wir uns bewegen können, also erhalten wir
die Bewegungsgeschwindigkeit Wir werden das mit minus eins multiplizieren
. Fühlen Sie sich frei, sich
beim Durchgehen etwas Zeit zu lassen. Also das wird unser in Bereich A
sein. In Bereich B wird es einfach
die Bewegungsgeschwindigkeit sein ,
also unverändert dort Und nochmal, ich gebe mir einfach
ein bisschen mehr Freiraum, da wir hier unten
noch mehr Zeug brauchen Dann
benötigen wir einen neuen Wert für unsere maximale und minimale
Neigung, die wir erreichen wollen. Das ist also der Punkt, an dem wir eigentlich kein
bisschen Kontrolle bekommen. Wir können also sagen, dass wir entweder wollen
, dass es gleichzeitig um
maximal 15 Grad
geneigt werden kann oder um
25 Grad oder was auch immer Sie
in der Kategorie Rotation wollten. Und noch einmal, wenn Sie
Kategorien haben, ist das in Ordnung. Wenn nicht, schnappen Sie sich einfach einen
beliebigen Wagen, den Sie haben. Ich nehme
meinen Tilt-Faktor, dupliziere ihn und
nenne ihn Max Tilt. Klicken Sie auf Kompilieren, und ich
denke,
ich gebe dem standardmäßig einen
Maximalwert von 15, sodass es in beiden Fällen auf eine
Drehung um 15 Grad geklemmt wird Sie könnten eine minimale Neigung erstellen, die minus 15 wäre, aber ähnlich dem, was wir hier
gemacht haben, nehmen
wir stattdessen einfach unsere
maximale Neigung und multiplizieren
diese mit minus eins Und das wird
unsere Überreichweite A sein, und Sie werden sehen,
wie das alles funktioniert. Hoffentlich, wenn Sie sehen,
dass sie zusammenkommen. Ich
nehme unsere maximale Neigung und dann ist das unsere außerhalb der Reichweite B. Also nehmen wir
unsere aktuelle Geschwindigkeit, unabhängig von unserer aktuellen Geschwindigkeit,
wie sie berechnet wurde,
wenn sie irgendwo
zwischen Null und
negativ unserer maximalen
Bewegungsgeschwindigkeit liegt wie sie berechnet wurde, wenn sie irgendwo
zwischen Null und . Ich glaube, das waren 1.000. Dann
wird unsere maximale Neigung zwischen
Null und minus 15 liegen, basierend
auf einer Art Prozentzahl,
einem einheitlichen Wert, der ungefähr der Geschwindigkeit
entsprechen würde ungefähr der Geschwindigkeit
entsprechen Und umgekehrt,
wenn wir uns nach rechts bewegen, nehmen wir
unsere maximale Bewegungsgeschwindigkeit, Null auf positive 1.000, und ich wähle einen
Neigungswert von 0-15 Auf diese Weise können wir also tatsächlich
klemmen,
anstatt einfach eine völlig willkürliche
Drehung in beide Wir orientieren uns dabei
konkret unserer aktuellen Geschwindigkeit und bilden dann
die tatsächlichen
Geschwindigkeiten ab, die wir erreichen können Das macht es wirklich
einfach, es zu aktualisieren. Wenn wir schon immer sagen wollten, mehr Tilt
haben, aber die Geschwindigkeit gleich lassen, dann können wir das einfach erhöhen. Ich könnte sagen, dass
Sie jetzt bis zu
25 Grad neigen können, anstatt nur um 15. Zum Testen werde
ich es wohl bei 15 belassen,
aber damit können wir sehr einfach
herumspielen. Wir wollen das nicht zu einer Variablen heraufstufen. Was auch immer das
berechnet, wir werden es auf eine andere Variable hochstufen Ich nenne das Target Tilt. Es ist sehr ähnlich wie
das Erste, was wir während der Bewegung gemacht haben ,
unsere Zielgeschwindigkeit berechnet haben. Und dann setze das auf
Null, verschiebe das nach oben. Und wir werden hier wahrscheinlich ziemlich viel Zeit investieren
müssen, um das
lesbarer zu halten, nur weil in dieser lesbarer zu halten, nur weil Funktion
viel mehr Mathematik
vor sich geht Die Rotation ist einfach
immer etwas komplizierter und kniffliger als Berechnung von Bewegungen
oder allgemeinen Positionen oder sogar
Skalenversätzen Skalenversätzen Nun, das
Ziel-Alpha ist sich tatsächlich so ähnlich, dass ich ein bisschen faul
sein werde Ich werde
wieder zur Griffbewegung zurückkehren. Ich werde mir den ganzen
Code hier holen, Strg C drücken, also werde
ich all diese Knoten hierher holen. Das Einzige, was wir nicht
wollen, ist der Schritt Alpha. kommen wieder
rein in die Rotation und wir werden das gleich
auf einen Wert setzen. Das Einzige, was wir vielleicht tun
möchten, ist, dass ich unseren Ziel-Tilt in
die Kategorie Rotation
verschieben werde . Ich werde das tatsächlich umbenennen
, weil wir ein paar etwas andere
Namenskonventionen haben. Also nehme ich die Interp-Geschwindigkeit der
Rotation und ändere sie auf
Tilt, weil wir entschieden haben
, dass alles andere eingestuft wird eher als
kippend als rotierend Ich werde die Interp-Geschwindigkeit
der Neigung durch Ziehen steuern. Und stecke das da ein. So können wir die Geschwindigkeit der
Bewegungsinterps
am Anfang loswerden Geschwindigkeit der
Bewegungsinterps
am Anfang Aber abgesehen davon
machen wir genau das Gleiche. Wir nehmen unsere
Tilt-Interp-Geschwindigkeit multipliziert mit den
G-Welt-Delta-Sekunden, multipliziert mit minus Eins, erhalten die exponentielle Rendite,
und dann
erstellen wir das wieder, und dann
erstellen wir das wieder, unsere Zerfallskurve Also nehmen wir all
diese Werte weg von einem. Das Ergebnis davon wird
dann eine weitere neue Variable sein, also werden wir sie
zu
einer anderen Variablen
heraufstufen und diese dann Tilt Alpha nennen. Weil wir dasselbe noch einmal machen
wollen werden. Wir werden das an unseren eigenen Interpolations
- oder LOP-Knoten anschließen , über den wir
die volle Kontrolle haben werden Also werden wir das einfach wieder nach oben verschieben und
versuchen, die Dinge etwas
aufgeräumt zu halten Ich denke, nur aus Gründen der Sauberkeit und des Platzbedarfs werde ich
das jetzt einfach löschen Wir müssen nicht Schritt für
Schritt vorgehen , wie
wir es früher getan haben. Wir werden hier einfach nichts
aus dem alten Code verwenden. Also werden wir
einen weiteren Sequenz-Pin erstellen. Wir wollen unsere
nächste Stufe der Logik durchführen. Dieser ist sehr
einfach. Also wieder sehr ähnlich der dritten Stufe
in unserem vorherigen Code. Wir werden
unsere aktuelle Neigung festlegen. Und ich denke, wenn wir es uns jetzt ansehen, werden
wir hier wahrscheinlich
anfangen, Werte zu verwechseln. Also max bis wir wollen
und wir
verwenden derzeit den Tilt-Faktor, ich glaube,
wir werden es verpassen. Also werde ich diesen einen
Tilt-Faktor in Current Tilt
umbenennen . Und dieses Wort
verliert langsam jede Bedeutung. Das habe ich ein
paar Mal zu oft gesagt. Das ziehen wir rein
und stecken den Execution-Pin ein. Und wieder der Wert, den
wir hier eingeben wollen, um sicherzustellen,
dass er keinen Standardwert mehr hat,
also setzen wir ihn auf Null. Dieser Wert wird auf der
Grundlage einer anderen Schleife berechnet. Also nochmal dasselbe,
eine schwebende Schleife. Und nochmal das Gleiche.
Also nehmen wir
unseren aktuellen Tilt, unseren Target Tilt und unseren
Alpha. So nett und einfach. So ziemlich, wie ich schon sagte,
die Bewegung, aber jetzt hängt alles mit Rotation
oder Neigung zusammen. So kannst du das
Muster sehen. Wir konnten tatsächlich
im Grunde den gleichen Code verwenden. Also
verstehst du das nicht einmal. Sehr einfach,
es wiederzuverwenden und neu zu erstellen. Wir mussten den ersten Teil
der Rotation hier oben
etwas komplizierter gestalten
, aber ansonsten war er sehr ähnlich Also können wir das
Gleiche noch einmal machen. Wir wollen einen weiteren Pin,
und dieser wird tatsächlich diese Werte verwenden
und die Rotation einstellen. Also nochmal das Gleiche.
Diesmal wollen
wir den Funktionsaufruf Set Actor
Rotation verwenden. Also schließen wir das hier und kommen später wieder hoch und machen ein bisschen Ordnung mit ein
paar Umwurzelungen Wir teilen den
Strukturstift auf, wie wir es zuvor getan haben. Wir nehmen unseren
aktuellen Neigungswert und setzen ihn in
den Wert ein, dass wir
das auf der Rolle machen. Und das ist so ziemlich alles, aber wir haben wieder die
gleichen Schritte. Stellen Sie also das Ziel ein, legen Sie den Alphawert fest, stellen Sie den aktuellen und verwenden Sie dann den
aktuellen Wert als Wert. Ich werde jetzt einfach
reinkommen, wie ich bereits erwähnt habe, wir werden ein bisschen
aufräumen, weil es etwas eng wird und schwer zu Ich denke, das ist in Ordnung, wenn
ich nicht
zu viel Zeit damit verbringe , die Knoten
auszudrucken,
aber das reicht aus, um die Dinge voneinander zu
trennen Und wie ich bereits erwähnt
habe, möchte ich nicht viel Zeit damit verbringen, meinen Code zu kommentieren Nicht das Nützlichste, was man im Stream oder in einem Video
sehen kann. Aber wenn du etwas Ähnliches
machen möchtest,
nur eine Kleinigkeit
, die du
zwischen den Themen mitnehmen kannst, vielleicht nochmal, pausiere den Inhalt und sag
einfach, dass er zur Aufgabe gehört, um sicherzugehen, dass du
verstehst, was passiert. Lesen Sie den Code und die Rotation
und sehen Sie, ob Sie
sich selbst ein paar gute Kommentare geben können , um genau zu beschreiben,
was hier passiert, warum wir die
Entfernungsklemme verwenden und solche Dinge. Und das Wichtigste ist, dass, wenn
Sie in ein
oder zwei Monaten zurückkommen und
sich den Code auf einen Blick ansehen müssten , es viel einfacher
ist, zu erkennen,
was
gerade passiert, da ich ihn noch einmal , es viel einfacher
ist, zu erkennen,
was
gerade passiert, durchgehen
und eingehend lesen müsste . Aber lassen Sie uns einfach weitermachen und überprüfen, ob alles funktioniert. Ich denke, das Wichtigste, was wir haben ist
unsere maximale Neigung auf 15 eingestellt, also sollten wir in beiden Richtungen nur eine Neigung von 15
Grad sehen. Und natürlich
negieren wir das einfach aufgrund
der Bewegungsgeschwindigkeit Bewegungsgeschwindigkeit liegt immer noch bei 1.000, was ich für völlig in Ordnung halte Wenn es sich
etwas langsamer anfühlt, können
wir später zurückkommen und den Wert
erhöhen Die Interp-Geschwindigkeit, ich denke, wir wollen das
ein bisschen verlangsamen Ich denke, wir werden
das auf drei statt auf
zehn reduzieren , weil unsere
Abklingkurve ein
bisschen anders funktionieren wird als das, was wir mit F Interp zwei
machen und dann Zielstrom und Alpha sollten
Zielstrom und Alpha alle zur Laufzeit
eingestellt werden, also sollten sie bei
Null beginnen, was perfekt ist Und dann verwenden wir
das hier einfach. Also das sollte, glaube
ich, jetzt funktionieren. Also, wenn wir wieder reinkommen, drücken Sie
Play. Ja, da haben wir's. Ja, ich glaube, es
sieht anders aus, aber wir können sehen, dass es
sehr ähnlich ist. Ich glaube, ich bevorzuge es irgendwie, wie
das aussieht. Es ist viel mehr, es fühlt sich
nur ein bisschen raffinierter an.
Das ist also ziemlich gut. Und wie ich bereits erwähnt habe, kommt hier
jetzt die
Flexibilität ins Spiel. Wenn du
die Geschwindigkeit ändern wolltest, dann war
das vielleicht zu langsam Wir können
das erhöhen. Also gehen wir hier
wieder in den Spielmodus zurück. Also werden wir
dich
wieder ein bisschen
schneller zurechtbringen . Also das ist in Ordnung Und wenn Sie dann,
wie ich bereits erwähnt habe, wenn Sie sich nicht sicher sind,
was etwas
tut oder in welche Richtung
ein Wert gehen sollte, wenn Sie es wirklich drastisch machen, eine wirklich große Änderung vornehmen
möchten Und Sie können sehen
, das ist fast so, als würden wir zurückschlagen,
wenn wir loslassen Der Zerfall findet also
viel schneller statt und wir
schlagen zurück Also das sieht vielleicht ein
bisschen netter aus. Also vielleicht habe ich mich geirrt, vielleicht wäre es
besser gewesen, zu einem höheren
Wert zu gehen als zu einem
niedrigeren, nett und einfach zu testen, aber
das ist die Hauptsache Versuchen Sie,
die Art und Weise, wie Sie
über Ihre eigene Codebasis denken,
mit einzubeziehen die Art und Weise, wie Sie
über Ihre eigene Codebasis denken, Wenn Sie
die Dinge
später einfach aktualisieren und optimieren können, ist es
wahrscheinlicher, dass Sie das Spiel verfeinern
und verbessern Wenn es wirklich
schwierig ist, mit deinem Projekt zu arbeiten, viel weniger wahrscheinlich, dass
du es
verfeinern willst Verbringen Sie diese Zeit damit, das Spiel zu
verbessern. Also eher eine Designsache , über die
es immer
Spaß macht, darüber nachzudenken. Die letzte Sache ist die maximale Neigung. Wenn wir also die maximale Neigung wählen, wenn ich etwas viel Größeres mache, etwa 45 Grad, nur um
den Unterschied zu zeigen , den wir
erreichen können, wenn wir schwimmen, können
Sie sehen, dass wir, wenn die Höchstgeschwindigkeit
erreichen, wir die Höchstgeschwindigkeit
erreichen, den höheren
maximalen Neigungswinkel erreichen. So
kommt das also ins Spiel. Wahrscheinlich möchten Sie nicht, dass es sich so stark
dreht, aber vielleicht möchten Sie es
um etwas mehr erhöhen, vielleicht mehr als 25, damit es
optisch auffälliger wird. Aber das Wichtigste, was
wir bei der vorherigen
Implementierung haben , ist, wie Sie gesehen haben. Es wurde nicht wirklich eine
spezifische Berechnung durchgeführt, um einen bestimmten Drehwinkel zu erreichen ,
der auf der
Geschwindigkeit oder so etwas basiert. Es ging einfach so weit wie möglich innerhalb einer
bestimmten Zeit. Wohingegen wir jetzt ein bisschen Kontrolle
haben. Abhängig von unserer aktuellen Geschwindigkeit können
wir genau kontrollieren, wie viel wir rotieren. Und dann ist es wirklich
wichtig zu überprüfen, dass ich einige Konsolenbefehle
einfüge, um die Feinde loszuwerden. brauchen wir nicht. Flieg einfach
weiter in uns rein. Ich gehe in den
Spielmodus. Ich gebe mir den Stat
FPS-Konsolenbefehl, damit wir sehen können, dass ich mit 120 FPS
laufe. Ich habe mich
direkt auf 30 runtergesetzt. Und wieder sollten wir
sehen, dass wir
einen viel weniger angenehmen
Rahmen bekommen ,
aber wir haben immer noch
nur eine Drehung um 25 Grad, und wir erreichen es
mit dem, was wir
hoffentlich gleich sehen sollten ,
ungefähr mit der gleichen Geschwindigkeit. Wenn ich das jetzt auf 60 erhöhe, erreichen
wir nur dieselbe Drehung,
dieselbe Art von Pitch
Tilt oder Roll Tilt, tut mir leid. Ich mache das in etwa
der gleichen Zeit. Und wenn wir dann auf 120 steigen oder tatsächlich, machen wir das Ganze
einfach zu Ende Ich sage etwa 600, also
komme ich auf etwa 300 FPS. Sieht flüssiger aus, aber die Bewegungen laufen mit derselben
Geschwindigkeit ab, und die Rotation benötigt dieselbe
Anzahl von Frames oder Sekunden,
um dorthin zu gelangen Wir haben also das
Problem mit der Unabhängigkeit
der Bildrate, das wir zuvor hatten, jetzt vollständig behoben Problem mit der Unabhängigkeit
der Bildrate, das wir zuvor hatten, Denken Sie daran, dass die Bewegung nicht wirklich ein
großes Problem
war,
aber bei der Rotation gab es
ein Problem, bei dem wir
zwar aufgrund der Logik, die die
F-Interfunktionen verwenden,
mit
bis zu Sekunden multiplizierten aufgrund der Logik, die die
F-Interfunktionen verwenden,
mit
bis zu Sekunden .
Denken Sie daran, dass wir den Flügel quasi in den Boden drehen konnten ,
weil
die Drehung nicht festgeklemmt
war Die unterschiedlichen Bildraten wirkten sich unterschiedlich
darauf aus. Also haben wir dieses Problem jetzt vollständig
gelöst. Wir mussten
etwas knietief in die Mathematik
eintauchen und
nutzten dabei
die rudimentärere, nutzten dabei
die rudimentärere vereinfachte Lurk-Funktion Aber indem wir den Regen mit unserem eigenen Code ein
wenig genommen haben, haben
wir jetzt
eine ganze Reihe von
Problemen gelöst , die mitgeliefert
wurden. Sie werden wahrscheinlich viele Spiele finden weil viele
Spiele auf der
Grundlage von
Beispielinhalten,
Produktcode und ähnlichem veröffentlicht werden auf der
Grundlage von
Beispielinhalten, . Damit ist der Test abgeschlossen.
Gleiche Bewegungsgeschwindigkeit. Wir haben die gleichen
Rotationsgrenzen. Es gibt keinen Flügel, der
durch den Boden ragt. Die Exponentialformel
gibt uns die mathematisch
korrekte Interpretation bei jeder Bildrate Ich hoffe, dass detailliertere
Inhalte wie dieser Ihr Gehirn nicht völlig eingefroren und Sie davon abgehalten haben, Schritt zu halten Das war wirklich das
Ziel der Themen ,
als ich sie erstellt
habe. Ich wollte versuchen, die
Leute dazu zu bringen , mehr
über ihre Codebasis nachzudenken und was unter der Haube passiert und nicht einfach nur mitzumachen. Hoffentlich ist das
jetzt so weit, dass Sie
die
Vorteile dessen erkennen können , was ich
von Anfang an erwähnt habe .
Das dauert viel länger, als es hätte tun können, und ich hätte einfach
viele
der trivialen Informationen herausschneiden können oder was vielleicht wie
triviale Informationen aussah, aber ich denke, Sie
hätten viele
der Informationen verpasst Lernpotenzial und das tatsächliche Verstehen
dessen, was Sie tun Das Ziel hier ist, dass du dir hoffentlich so etwas ansehen
kannst, dir
ersparst, noch zwei
oder drei andere Tutorialserien
oder Kurse
anzuschauen oder drei andere Tutorialserien oder was auch immer der
Fall sein mag, weil du
tatsächlich viel mehr praktische
Erfahrungen mit den Systemen machst tatsächlich viel mehr praktische und
Dinge reparierst , die es sogar in
den offiziellen
Lerninhalten von Epic gibt . Hoffentlich hat das
einen Wert. Wenn Sie also jetzt wirklich damit
beginnen möchten, Ihr Projekt zu verfeinern, haben Sie hier wahrscheinlich ein allgemeines
Verständnis dafür bekommen allgemeines , was
wir tun werden Wir haben unser Projekt ziemlich starr
und solide organisiert . Wenn Sie also anfangen
möchten, zwischen den Themen zu
experimentieren, sollten Sie hier vielleicht ein wenig
auf die Bremse treten. Nochmals,
das ist kein Rennen Wir streben nicht danach
, das Projekt so schnell wie möglich abzuschließen. Unser Ziel ist es, Sie zum Verlassen zu bewegen, verstehen, was
Sie tun und wie das, was
Sie bereits gelernt haben, erweitern können. Machen Sie also vielleicht etwas Einfaches, auch wenn es nur
in Ihren eigenen Code einfließen soll.
Schauen Sie, ob Sie jetzt kommentieren
und beschreiben können , was Ihr
Code tut , indem Sie
einige gute Kommentare verwenden oder die Variablen kategorisieren Wenn Sie bemerkt haben, dass Sie eine lange Liste von Variablen haben
und eine Möglichkeit sehen,
diese zu verbessern, dann
fangen Sie an, Kategorien
zu Ihren Variablen hinzuzufügen, einfache Dinge, um
Ihr Projekt strukturiert, aufgeräumt und einfach zu handhaben. Denken Sie daran, dass das Hauptziel darin besteht Sequenzen Ihre Ablaufsteuerung sind, um ihn lesbarer zu machen, wie normaler
Skriptcode oder geschriebener Code Gute Kommentare,
erläutern die Absicht anstatt nur die Variable
zu beschreiben Dinge wie Sie könnten
einfach einen Kommentar mit der
Aufschrift Interpolation Alpha haben ,
aber ein guter Kommentar wäre, Werte für die
Unabhängigkeit der Framerate auf der
Grundlage
von Interpolation Alpha zu
berechnen , Dinge wie diese, um Ihnen quasi einen Deskriptor zu geben, auf einen
Blick darüber, was
Sie tun Damit ist das Bewegungssystem jedoch
produktionsbereit Bewegungssystem jedoch
produktionsbereit Wir haben eine flüssige,
kontrollierte, von der Bildfrequenz unabhängige Bewegung und
Rotation für den Spieler Das ist
die schwerste
und
komplexeste Klasse, die wir in dem
Projekt haben Als Nächstes werden
wir versuchen,
Gegner
während des Spiels dynamisch zu spawnen , anstatt sie einfach manuell zu
platzieren, was für ein
vollständiges Spiel natürlich
etwas restriktiv sein wird für ein
vollständiges Spiel natürlich
etwas restriktiv
19. 18 - Feindlicher Spawner: Zeit, uns mit der Automatisierung
des Spawnens unserer Feinde zu befassen. Wir werden das von Anfang an
flexibel gestalten. Das wird zunächst für
Gegner funktionieren, aber wir werden es nur ein bisschen
zukunftssicher machen,
also funktioniert es mit Dingen
wie Hintergrundobjekten oder allem anderen, das im Laufe der Zeit erscheinen
muss. Feinde nicht mehr manuell
platzieren, was der
erste wichtige Schritt sein wird. Um zu beginnen, gehen
wir in unseren Blueprint-Ordner und
erstellen ihn einfach in einer neuen Ordnerstruktur Also drücke ich Strg+Shift
und N für einen neuen Ordner,
diesen nenne ich Spawners Rechtsklick, wir gehen
zur Blueprint-Klasse und wollen unsere Standard-Schauspielerklasse erstellen
. Wie ich bereits erwähnt habe,
ist dies nur ein Container. Es hat eine Transformation, einen
Platz in der Welt, und dann können wir
unsere Logik hier ablegen. Wir geben diesem den Namen BP Underscore Spawner Also, wie ich schon erwähnt habe, ein bisschen
vorausschauend planen. Wir werden nicht spezifizieren, dass dies nur für Feinde sein wird, und wir werden möglicherweise andere
Spawner haben, die
ein Kind dieser Klasse
mit Erbschaft sein werden ein Kind dieser Klasse
mit Darin wollen wir
einfach
direkt zu unserem Event-Graph gehen direkt zu unserem Event-Graph Es gibt nichts, was wir
visuell hinzufügen müssen , um dies darzustellen. Ich denke, in diesem
Fall können wir dass
der Akteur eine Überschneidung darstellt, und die meisten Dinge hier
sollten responsiv sein
, also sollten wir die Ereignisse nicht ständig
überprüfen und aktualisieren, damit wir diese beiden
Funktionsaufrufen loswerden können Wir können unsere Kernlogik aus einer benutzerdefinierten Funktion ableiten.
Ich verschiebe das einfach. Wir werden hier eine neue
Funktion erstellen, und ich nenne sie Spawn-Schauspieler Also nochmal, alles, was
wir tun, während wir das durchgehen und planen, versucht, das sehr allgemein zu
halten Wir sagen nicht,
Hintergrundfigur spawnen,
Spawn aufnehmen, Feind spawnen Alles, was wir angeben müssen, ist ein Argument die Art
des Akteurs
, den wir spawnen wollen, und wir werden wahrscheinlich eine zufällige Rotation,
einen Offset, einen Standort
und solche Dinge benötigen einen Offset, einen Standort
und Wir können das
nett und generisch machen
und alles
sehr wiederverwendbar machen Also versuche ich immer, im Voraus zu planen. Denken Sie daran, faul zu denken, das Programm einmal zu
planen und es so
oft wie möglich zu verwenden. Innerhalb dieser Funktion
ziehen wir vom Ausführungs-Pin ab, und wir haben tatsächlich eine eingebaute
Funktion in Unreal, die Spawn Actor aus der Klasse
heißt Wenn wir diese Funktion verwenden, das Wichtigste, was wir, ist
das Wichtigste, was wir,
wie ich bereits erwähnt habe, eine Transformation, also wo sie erscheinen soll
und
in welcher Art von
Klasse wir spawnen wollen Im Moment könnten das Dinge wie unser Feind
sein,
aber auch das
wäre zu spezifisch Wenn wir hier also die lila Stecknadel markieren und mit der
Maus darüber fahren, können
wir sehen, dass
sich das nur speziell auf die Art des Schauspielers bezieht Diese lila Stecknadeln sind also die eigentlichen
Klassenreferenzen selbst, kein Beispiel in der Welt Wenn wir diese blauen Stecknadeln haben, ist das eine tatsächliche Instanz
, die es auf der Welt gibt. Wir können uns die
lila Stecknadeln quasi als Hinweis
auf den Ort innerhalb
unserer Ordnerstruktur vorstellen . Also werden wir diese generische Typisierung verwenden
. Wir werden
von hier aus ziehen und
das Ganze tatsächlich zu einer Variablen heraufstufen. Wir geben diesem den
Namen des Schauspielertyps. Machen wir uns
das jetzt zunutze, da wir es mit jeder Art von
Akteur in unserem Projekt füllen
können , egal ob das ein
Feind ist, ein Pickup, ein Hintergrundstück, wenn wir sie
hinzufügen, was auch immer wir wollten, wir können dieser Funktion jetzt sagen, dass sie das an einem bestimmten Punkt
spawnen soll dass sie das an einem bestimmten Punkt
spawnen Die wichtigsten Dinge, die wir enthüllen
wollen, sind die Details der Spawn-Transformation Wenn wir also schreiben,
klicken Sie darauf,
teilen wir die Struktur Pi Wir belassen die
Spawn-Transformationsskala bei 11 und eins Im Allgemeinen versuchen wir, diese nicht
zu überschreiben. Wenn alles korrekt
eingerichtet wurde, wie bei diesem Projekt, sollten alle Ressourcen zunächst die
richtige Größenordnung haben. Also behalten wir das bei
und gehen einfach davon aus, dass die Assets importiert wurden
und wie vorgesehen funktionieren. Sie haben zwar die Möglichkeit, die Rotation nach dem
Zufallsprinzip oder zu verschieben, aber ich werde das
vorerst sauber halten, und wir können jederzeit zurückkommen
und das später überarbeiten Stattdessen klicke ich mit der rechten Maustaste und suche nach Get
actor rotation Der Grund dafür ist ,
dass wir
das direkt anschließen können. Und wo auch immer wir unseren Spawner
drehen, wir haben die volle Kontrolle über
den Editor, also ist das jetzt eher
ein Editor-Tool. Wenn ich möchte, dass das Dinge seitwärts
spawnen soll, muss
ich nur daran denken, den eigentlichen Spawner zur Seite zu drehen Eine Alternative wäre
, dies
einer Variablen auszusetzen und die Rotation manuell einzufügen
,
aber ich finde, das kann eine sehr nette Art sein Es ist für mich nur ein bisschen
intuitiver, solange es nicht
zu restriktiv ist, was meiner Meinung nach in diesem
Fall in Ordnung sein sollte. Für den Standort
ziehen wir von hier ab und
fügen einen Plus-Pin hinzu. Für diesen Fall ist möglicherweise ein
wenig Randomisierung, gewisse Varianz und ein gewisses Maß an
Offset Wenn wir mit der rechten Maustaste klicken, können wir nach dem Standort des G-Schauspielers
suchen. Also nochmal das Gleiche,
wir werden
die allgemeinen Eigenschaften von dem Ort verwenden, an dem sich der Spawner befindet, sodass das unser
Ausgangspunkt sein wird Nun zu dieser Art von Spiel,
weil wir wissen, dass wir nur von
oben nach unten gehen, brauchen
wir keine
Randomisierung auf der Z, und wir wollen wahrscheinlich unser gesamtes Spawnen außerhalb
des Bildschirms machen ,
was bedeutet, dass wir
auch
keine Randomisierung auf der X-Achse benötigen keine Randomisierung auf der X-Achse Wir könnten also mit der rechten Maustaste
auf diesen zweiten Vektor-Pin klicken und die Struktur teilen Wir ziehen hier von unserem
Y-Pin und möchten den ausgewählten
Knoten verwenden, den wir zuvor gesehen haben. Wir wollen nicht Float auswählen. Wir wollen diesen hier
mit dem einzigartigen Symbol haben. Dadurch erhalten wir den Platzhalter
, den wir zuvor verwendet haben. Wir ändern dies in einen booleschen Wert, also entweder randomisieren oder nicht, und ich werde den Index
hier auf eine neue Variable hochstufen, und wir geben dieser Variablen den Namen add random offset auch hier daran, dem einen Kleinbuchstaben B zu
geben. Wenn wir uns dafür entscheiden,
einen zufälligen Offset hinzuzufügen, möchten
wir innerhalb eines Bereichs eine
Art Gleitkommawert
angeben Art Gleitkommawert Und wieder haben wir
gesehen, wie das geht, also erweitern wir jetzt einfach die Funktionen
und Ansätze
,
die wir bereits in der Vergangenheit
gewählt haben Wenn das stimmt und wir einen zufälligen Offset
hinzufügen, ziehen
wir von hier aus
und verwenden Random Float in Funktion „Random Float in
Range“, die
wir zuvor gesehen haben Und davon
wollen wir nur einen Abstand, also einen minimalen und
einen maximalen seitlichen Abstand
, den wir anwenden können Wenn wir hier also unseren
maximalen Gleitkommawert ermitteln
und
diesen Wert zu einer Variablen heraufstufen, geben wir dieser einfach
den Namen Offset-Distanz Das Minimum ist, wie
wir bereits gesehen haben, bei Geschwindigkeiten und ähnlichen
Dingen
einfach
umgekehrt negativ, also können wir den Luftwiderstand
in der Offset-Distanz kontrollieren, das eins
multiplizieren und dann das
Ergebnis hier eintragen Wenn wir also einen Abstand
von sagen wir 100 Einheiten festlegen
und möchten, dass dies
auf beiden
Seiten
von der Bildschirmmitte passiert , würden
wir diesen spawnenden
Akteur in der Mitte
des Bildschirms platzieren und den Wert 100
in die Offset-Entfernung eingeben. Das heißt, es kann
entweder -100,
positive 100 oder
irgendeinen Wert Wenn wir uns dafür entscheiden,
die Variable nicht verfügbar zu machen und wir
den zufälligen Offset nicht aktiviert haben, fügen
wir einfach false hinzu Wir werden also Null
zu unserer Gesamttransformation hinzufügen,
was bedeutet, dass der Schauspieler
genau dort erscheint, wo wir ihn platziert haben Also relativ einfach, aber es ist immer noch eine Art Entwicklertool, wir aufbauen können,
wenn mehr Komplexität erforderlich ist, aber es gibt uns eine gewisse Flexibilität und Variation in unserem Projekt, wodurch die Dinge
generell interessanter und unterhaltsamer
aussehen. Etwas, das ich noch nicht gezeigt habe
und das ich hier vorstellen möchte, weil wir im Begriff sind,
einen sehr rudimentären Entwickler zu einen sehr rudimentären Das ist etwas, das innerhalb von
Unreal wirklich nützlich ist innerhalb von
Unreal wirklich nützlich Andere Engines machen ähnliche Dinge, und das ermöglicht es den
Leuten,
die Variablen außerhalb
der Klasse zu sehen die Variablen außerhalb
der Klasse Wenn wir im Moment zum
Beispiel eine
unserer Spawner-Klassen nehmen und sie einfach in der Welt
ablegen und
sicherstellen, dass wir alles
kompiliert und gespeichert haben, können
wir hier sehen, dass
die ausgewählten Objekte,
keine der
Variablen, die wir
gerade erstellt haben ,
tatsächlich Wäre nicht
in der
Lage, manuell pro Instanz einzugeben Wenn wir also drei
oder vier davon hätten, könnten
wir uns nicht
entscheiden, ob dieser eine gewisse Randomisierung und
eine eindeutige Distanz und dieser beispielsweise keine
Randomisierung hat Wir haben derzeit nur einen
Ort, an dem wir das ändern können, und das ist nur
hier in der Grafik Also würde es entweder diesen
booleschen Wert bekommen und ihn ausschalten, und dann ist das für alle ein oder
aus Und ebenso für die Entfernung. Die wirklich nützliche Möglichkeit
, dies zu überschreiben sind
diese Symbole hier. Sie haben sie vielleicht noch nicht
berührt, aber wenn wir sie anklicken,
erscheint ein kleines Augensymbol. Standardmäßig sind sie geschlossen
und wir können das Auge öffnen. In anderen Sprachen wird
das als
Veröffentlichung von etwas bezeichnet . Es ist
anderen Klassen zugänglich und außerhalb dieser Klasse
lesbar und beschreibbar unwirklichen Plan heraus macht
dies
die Variable hier nur im Wesentlichen
außerhalb der
Klasse editierbar außerhalb der Wenn wir also
erneut zu unserem Viewpoint gehen und dieselben
Objekte ausgewählt haben, können
Sie sehen, dass
wir in
der Standard-Dropdownliste Zugriff auf den Akteurtyp
haben, den wir
erzeugen möchten wir
erzeugen Hier
könnten wir also anfangen,
solche Dinge zu tun, es könnte ein feindlicher Spawner sein Wir werden das nicht tun, aber das könnte
ein Spieler-Spawner sein Wir haben also bereits eine
gewisse Flexibilität
bei der Frage, was diese
hervorbringen werden Und weil die Gegner vielleicht zufälliger sein wollen, könnten
wir diese
Option auf „Wahr“ setzen, um einen zufälligen Offset
in beide Richtungen
hinzuzufügen, einen zufälligen Offset
in beide Richtungen
hinzuzufügen,
und wir könnten ihn, wie gesagt, auf
vielleicht 100 Einheiten links und
rechts vom Spawner so nett und einfach,
wie Sie gesehen haben, es ist kein sehr komplexes Setup, aber wir haben bereits
ein gewisses
Maß an Flexibilität und Freiheit
bei der Verwendung Wenn
wir das also im Moment zu
Beginn des Spiels hinzufügen und es
einmal aufrufen würden, wäre
ein Feind für unseren Spieler keine große Herausforderung. Wir wollen also
etwas kontinuierliches Spawnen hinzufügen. Wir werden Dinge wie Delays
und Loops vermeiden , da das unübersichtlich und
unflexibel wird Sie haben vielleicht schon einmal
etwas Ähnliches gesehen, bei dem
ich zu Beginn des Spiels wieder nur einige der Dinge visualisieren möchte ,
die ich
in vielen Projekten gesehen habe Vielleicht hast du so etwas wie, wir kommen beim ersten Mal rein und wir werden einmal einen Schauspieler hervorbringen.
Dann fügen wir eine Verzögerung Eine Verzögerung ist also nur ein
zeitgesteuerter Warteprozess. Wir warten,
sagen wir, 3 Sekunden. Bevor wir das nächste Ding machen und dann wieder Schauspieler hervorbringen. Und du könntest versucht sein, hierher
zu kommen
und vielleicht nach jedem
Mal, wenn das getan ist, zu
versuchen, einen Weg
zu finden, dich an sich selbst zu erinnern Es wird chaotisch werden. Am Ende siehst du,
wie
Leute solche Dinge tun , wir machen eine
Endlosschleife im Hintergrund
und du hast
diese Endlosschleife, und du hast
diese Endlosschleife in der die Leute sagen, dass wir,
nachdem wir das gestartet haben, weitere 3 Sekunden warten
und den Spawn-Schauspieler erneut aufrufen werden und den Spawn-Schauspieler erneut aufrufen Also werden wir
diesen Code im Anfängerstil vermeiden. Was wir stattdessen verwenden wollen,
sind sogenannte Timer. Diese sind viel sauberer
und wir haben viel mehr Kontrolle darüber, ob
und wann sie aufgerufen werden also nach unserem Start-Pin, Wir wollen also nach unserem Start-Pin,
dem Ausführungs-Pin, eine Funktion namens I valid
finden. Wir wollen diese Option mit dem
Fragezeichen unten. Damit wird geprüft,
ob ein anderes Objekt oder ein anderer Akteur aktuell
gültig ist, also es
existiert, und ob
es nicht zur
Müllabfuhr zur Reinigung geschickt wird Müllabfuhr zur Reinigung ,
wenn es zerstört wird
oder so? Aus dem Eingabeobjekt, also dem Ding, das wir überprüfen
wollen, ob es existiert, ziehen
wir von hier und verwenden die eingebaute Funktion, die Spielfigur „Spieler abholen Das ist also wieder nur eines dieser Dinge,
die es zu berücksichtigen gilt. Es passiert in vielen
Spielen für neue Entwickler , in denen du ein Spiel wie dieses
gemacht hast und die Feinde den Spieler
zerstört haben. Aber selbst wenn du
das Spiel über den Bildschirm siehst oder einfach nur auf die Credits wartest
oder was auch immer danach passiert, kannst
du sehen, wie der
Feind immer noch
hineinspawnt oder auf den Spieler schießt,
quasi ein Hund, der sich
auf einer Leiche stapelt Es sieht einfach ein
bisschen heftig aus, und das liegt normalerweise daran,
dass in der Mitte des Spiels nicht überprüft wird, ob die Spieler tatsächlich als tot oder
nicht mehr
verfügbar eingestuft wurden Was wir tun werden, ist, wenn der Spieler aus dem Spiel
entfernt wurde, müssen keine Feinde
mehr erscheinen, also werden
wir aufhören Wenn das stimmt, also wenn der
Spieler immer noch gültig ist, werden
wir hier
eine Funktion aufrufen, nämlich den eingestellten Timer
anhand des Funktionsnamens Wir wollen diese Option hier haben, und das Erste, was wir hier
angeben können, ist die Uhrzeit. So lange
werden wir also warten, bis diese Funktion, die wir gleich
erstellen werden, aufgerufen wird. Für die Zeit selbst können
wir also von hier aus ziehen und nach einem weiteren
zufälligen Float in der Reichweite suchen. Und ein kleiner Trick
, der sehr nützlich sein kann, wenn
Sie nicht nur das Minimum und das
Maximum
haben wollen das Minimum und das
Maximum
haben oder so etwas einfach umgekehrt zueinander Wir können einen
sogenannten Vektor
zwei D verwenden . Wenn wir also
eine neue Variable erstellen, nennen
wir diese Variable Spawn-Intervalle Und wir
lassen das fallen und suchen
hier
und nicht nach einem Vektor
, der ein Dreipunkt-Fließwert ist, wir werden auch nach einem Vektor
suchen Wir wollen diesen
hier unten haben, den Vektor zwei D. Und wenn wir auf Kompilieren klicken, können
wir sehen, dass das alles nur zwei
Fließkommawerte sind, wobei der X-Wert unser Minimum und der
Y-Wert ein Maximum sein wird. Also könnten wir das auf
ein Minimum von
3 Sekunden setzen , bevor
etwas erscheint, und auf ein Maximum von sechs Und wir können später zurückkommen
und das anpassen. Wir können steuern, das in
das Diagramm ziehen, rechten Maustaste auf den Strukturpin klicken, den
Strukturpin hier
teilen, und wir können Minimum, Maximum sagen Also eine nette, saubere, ordentliche Art, die
Timing-Funktion einzurichten Für den Namen der Funktion haben wir hier
unseren Spawn-Schauspieler. Zu einer Sache
tendiere ich immer wieder,
zum Teil, weil ich faul bin und
keine Lust habe, Dinge zu tippen,
aber auch, um
Rechtschreib- oder Tippfehler zu vermeiden Ich drücke F
zwei, um das umzubenennen, N C zum
Kopieren und dann NV hier drüben, um es einzufügen , um sicherzustellen, dass wir dieselbe Schreibweise und
dieselbe Großschreibung
haben ,
um Fehler im
Namen zu vermeiden, da hier
Groß- und Kleinschreibung beachtet wird und genau dieselbe
Schreibweise erforderlich ist. Wir werden das nicht auf Looping
setzen, aber wenn Sie
eine Funktion hätten, bei der Sie möchten, dass sie ständig
weiterläuft, könnten
Sie sie auf Looping setzen, und sie würde einfach
immer weiter laufen und sie
im Grunde aufrufen. Um ein bisschen
mehr manuelle Steuerung zu wollen. Ich werde dafür sorgen, dass
das nicht angekreuzt ist. Und was wir tun können,
ist, wenn wir uns
den gesamten Code schnappen , einschließlich
des gültigen ,
denn
wenn Sie darüber nachdenken ,
gibt es keinen Grund, warum
die Spielfigur nicht wirklich ein gültiges
Objekt
wäre Er wird immer
existieren, wenn wir auf Play drücken. Also werden
wir stattdessen rechten Maustaste auf einen
dieser Knoten klicken und das Ganze zu einer Funktion
zusammenfassen. Wir geben dem den Namen
Call Spawn Aca Timer. Wir
verschleiern
hier also die Logik ein bisschen die Logik ein Also, auch hier sind die Schritte
etwas klarer und leichter zu verstehen, wenn
wir unseren Code durchgehen Und die Art und Weise, wie wir
damit umgehen wollen , ist, dass wir uns wahrscheinlich sofort
einige Feinde schaffen wollen. Anstatt also auf der
Grundlage eines Timers zu spawnen, können
wir dies zunächst umgehen Also fangen wir damit an, direkt
einen Schauspieler zu spawnen. Wir werden das auf
unsere Hinrichtungsnadel legen. Und wieder,
ich denke nur an die Reihenfolge der Logik in unserem Code. So können wir Dinge wie immer
überarbeiten. Wir werden anfangen zu
spielen und wir werden sofort einen Schauspieler
hervorbringen Was das bewirken wird, es
wird hier auftauchen. Wir suchen dann
unseren Darstellertyp aus , falls
wir einen Satz haben, wählen eine Position und einen Offset, falls ein Offset angewendet werden
soll, und wählen die Rotation aus und
spawnen das an einem Punkt Und danach können wir hier mit einem fast
automatischen Looping beginnen einem fast
automatischen Looping Wenn wir also wollten, dass
das so weitergeht, könnten
wir unseren
Core-Spawn-Aktor-Timer nehmen und ihn einfach hier einschalten Und was das jetzt
bewirken wird, ist, dass das rein geht, und das ist
hier wichtiger, denn zur Laufzeit,
das ist der Ort,
an dem etwas nach dem ersten oder zweiten Spawn der
Spieler zerstört worden sein könnte Also dieser, den ich für
uns mache, ist ein gültiger Scheck, ein wirklich einfacher,
billiger Check, um
sicherzugehen , dass der Spieler noch im Spiel
ist Und wenn das der Fall ist, lassen
wir es zu es einen weiteren Akteur hervorbringt, also verwenden wir im Grunde die
Spawn-Actor-Funktion, diese
Funktion nach
einer bestimmten Zeit oder einem bestimmten
Zeitintervall erneut
aufrufen einer bestimmten Zeit oder einem bestimmten
Zeitintervall Nun, das ist etwas, was
ich sehr gerne mache, und das ist völlig optional Aber weil wir, wenn wir die Funktion „Zeit nach
Funktionsnamen
festlegen“ verwenden , nicht doppelt klicken und
herausfinden können , was das
eigentlich aufruft, müssen
wir
unsere Funktionsliste durchsuchen und den passenden Namen finden. Was ich sehr gerne mache, ist
, die Funktion hier drüben und sie einfach unter dem
eingestellten Timer nach dem Funktionsnamen abzulegen. Das heißt, wenn ich in Zukunft meinen
Code
durchsehe, wenn ich an diesen Punkt komme
und merke, dass ich hier etwas
an dieser Funktion
korrigieren oder ändern muss, kann
ich einfach
auf diesen Knoten doppelklicken, und das bringt mich zu dem, was
diese Funktion aufruft. Also nur ein wirklich
kleiner Tipp, aber ich finde, das kann wirklich nützlich
sein, besonders wenn
Sie zurückkommen, um Dinge zu optimieren, wenn das am Ende
nicht flexibel genug war, wir mussten
etwas entfernen, einfach eine nette Art zu navigieren. Aber das ist so ziemlich
alles, was wir brauchten. Das ist ein
netter, selbstgekapselter, selbstgesteuerter Spawner mit gewissen Flexibilität in Bezug auf die verschiedenen Spielertypen
, in denen wir spawnen können, wo sie spawnen werden und ob
eine
Randomisierung selbstgesteuerter Spawner mit einer
gewissen Flexibilität in Bezug auf
die verschiedenen Spielertypen
, in denen wir spawnen können,
wo sie spawnen werden und ob
eine
Randomisierung angewendet wird. Wir könnten auch runterkommen und die Spawn-Intervalle offenlegen . Wir könnten also für jeden
anderen Akteur, jeden anderen Spawner
unterschiedliche Zeitintervalle haben, wann die Dinge ihn spawnen sollten Also stellen Sie sicher, dass wir
kompilieren und speichern. Eine Sache, die ich
hinzufügen möchte, bevor wir das tatsächlich testen, ist, wenn wir
zum Komponentenbereich gehen, werden
wir
hier etwas hinzufügen, ich werde nach der Pfeilkomponente
suchen. Hier gibt es also tatsächlich
eine Komponente, die wir verwenden
können, bei der es sich
nur um einen visuellen Pfeil handelt. Wir können die
Farbe ändern, wenn Sie die Farbe aus verschiedenen
Gründen ändern möchten. Aber die Hauptsache ist,
dass wir auf einen Blick nur
wissen, welcher Weg vorwärts geht, also wird standardmäßig immer vorwärts
gezeigt Wenn wir also auf Kompilieren und
Speichern klicken , um
zur Hauptebene zurückzukehren, können
wir sehen, dass die Feinde
hier tatsächlich in die falsche Richtung schauen
werden Also werde ich einige
davon
loswerden , wir werden sie einfach
mit einem nach dem anderen testen. Achte darauf, dass es
sich nicht mit dem Boden überschneidet, sonst können sich die Feinde
nicht bewegen Und dann können wir
das einfach um 180 Grad auf dem Z drehen. Und du kannst sehen,
dass das jetzt auf unseren Spielerstart zeigt ,
was bedeutet, wenn wir
das auf unsere feindliche Klasse setzen, könnten
wir dem eine zufällige
Entfernung zu beiden Seiten geben, und da sind Spawnintervalle in
Ordnung Wir können auf Play drücken und das bringt sofort
einen rein Dann sollten
wir innerhalb von drei bis 6 Sekunden einen weiteren
Spawnen sehen, und los Unser zufälliger
Spawning-Akteur funktioniert also korrekt. Durch die Bereitstellung der Rotation,
die ich erwähnt habe können
wir genau sehen, in welche
Richtung dieser Spawnen wird Das Hauptproblem, das wir jetzt
haben, ist natürlich, dass wir sehen können, wie sie auftauchen Deshalb wollen wir
das ein
wenig nach hinten verschieben , sodass sie außerhalb des Bildschirms
erscheinen. Sie werden diese Animation machen und
dann werden sie in
dem angegebenen Intervall erscheinen Wenn du eine
etwas andere Position haben möchtest oder wenn du mehr davon haben möchtest, könntest
du es so gestaffeln, sodass wir
mehrere Spawner haben könnten Ihr könntet verschiedene
Offset-Distanzen und
verschiedene
Spawn-Intervalle angeben , und ihr könntet sie auf
diese Weise ein wenig Nochmals, um das Gameplay und die Interaktion noch
interessanter Ich denke, im Moment
könnten wir wahrscheinlich
mit nur einem Spawner
für unsere Feinde davonkommen mit nur einem Spawner
für unsere Wenn wir also herausfinden
oder entscheiden, dass Laufzeit
nicht genug
gespawnt wird, können
wir zurückkommen und weitere
hinzufügen oder mit diesen
Spawnintervallen
herumspielen mit diesen
Spawnintervallen
herumspielen Also noch ein bisschen
Experimentieren oder Hausaufgaben, die du dir selbst machen
kannst Sie können hier einige einfache
Dinge tun, z. B.
den Spawner duplizieren und
verschiedene Konfigurationen ausprobieren, wie ich Probiere verschiedene Spawn-Intervalle und
verschiedene Offset-Entfernungen aus, verschiedene Offset-Entfernungen aus, aktiviere oder deaktiviere Und wenn du
den Inhalt bisher
verlassen und deine eigenen
unterschiedlichen Feindtypen
erschaffen hast, hast
du idealerweise den Inhalt bisher
verlassen und Feinde, die sich
nur vorwärts oder
rückwärts oder von einer Seite zur anderen bewegen,
was auch immer der Fall sein rückwärts oder von einer Seite zur anderen bewegen,
was auch immer der Fall Versuche vielleicht,
verschiedene Spawner
für verschiedene
Gegner hinzuzufügen , nur um zu sehen, wie du dieses einigermaßen
flexible System wirklich einfach nutzen
kannst dieses einigermaßen Und das ist die Hauptsache hier. Wir schauen uns an und denken
darüber nach, wie wir unser System
entwickeln. Hätte
eine Schauspielerklasse speziell für das
Spawnen von Feinden Wir hätten in
die Klasse kommen und die Logik hier fest programmieren können, um
gezielt Feinde zu spawnen Wir hätten dann dasselbe für
einen anderen Feindtyp
oder die Hintergründe tun
müssen einen anderen Feindtyp ,
wenn wir dazu kommen Im Grunde also wieder eine Menge
doppelter Arbeit, mehr Dinge, die schief gehen
und mehr Bugs behoben werden müssen. Bei diesem
Ansatz können wir später für die
Hintergründe,
verschiedene Feindtypen, Bosse,
was auch immer ihr verwenden
möchtet,
wiederverwenden verschiedene Feindtypen, Bosse, was auch immer ihr verwenden
möchtet,
wiederverwenden
20. 19 - ProjectileBase: jetzt zu einem
der spaßigen Teile übergehe, ist
es an der Zeit,
etwas Feuerkraft hinzuzufügen Das wird wieder eine
Projektilklasse sein die
Spieler als auch für die Gegner funktionieren wird Wie zuvor werden wir schon früher vorausschauend denken und dies
an die Farben und den Schaden anpassbar
machen, dies
an die Farben und den Schaden anpassbar
machen, an auf das intelligente
Design
konzentrieren und spätere Duplikate
sparen Also können wir den
BP-Unterstrich Sponerbse belassen ,
falls du noch hier bist Wir werden in
unseren Blueprints-Ordner gehen. Ich gehe hier zurück in den Blueprints-Hauptordner Wir werden einen neuen Ordner erstellen,
also die Shift-Taste in N drücken, und diesen
einen nennen wir Projektile Im Moment stehen die Chancen gut,
dass bei diesem Projekt
immer nur ein Projektiltyp herauskommt Wie ich bereits erwähnt habe, werden
wir versuchen so flexibel
wie möglich zu
gestalten Aber auch hier gilt: In
fortgeschritteneren Versionen oder
Blitzlichtversionen dieses Projekts möchtest
du vielleicht Dinge
wie Heimraketen,
Laser, Schrotflinten,
Granatenexplosionen und Daher können wir das
Projektil
, das wir haben, möglicherweise nicht immer wiederverwenden Wir gehen
also immer noch davon aus, dass wir vielleicht später darauf
aufbauen möchten,
auch wenn wir dies für
dieses kleinere Projekt nicht tun Also werden wir
wieder mit der
rechten Maustaste hier in den neuen Ordner klicken. Wir werden eine neue
Blueprint-Klasse erstellen. Auch hier wird es
sich um einen einfachen Schauspieler handeln, und wir werden diesem
den Namen
BP Underscore-Projektil geben BP Underscore-Projektil Wir werden das Wort
Base
nur noch einmal ans Ende setzen, falls
wir es etwas später um
ähnliche, aber etwas
einzigartige Kinderversionen erweitern
wollen etwas später um
ähnliche, aber etwas einzigartige Kinderversionen In unserer neuen
Schauspielerklasse wollen wir
zunächst nur ein neues statisches Netz erstellen. Also werden wir eine neue Komponente
hinzufügen, ein statisches Mesh, und wir können
diese direkt auf das
Standard-Szenenstammverzeichnis ziehen . Also nochmal, das machen wir
zur neuen Root-Komponente. das statische Netz ausgewählt ist, gehen
wir
zur rechten Seite. Ich habe hier das
SM-Underscore-Projektil bereitgestellt, also wählen wir dieses aus Und das wird unser
Bild des Projektils sein. Auf der linken Seite gehen wir
zurück zu den Komponenten. Wir können diese Zeile
wieder löschen, und wir können
hier sehen , ob wir nach dem
Wort Projektilbewegung suchen Wir haben unsere Komponente zur
Projektilbewegung. Unreal hat
dafür ein integriertes System , um einen
Teil des Setups zu vereinfachen Nun, wir werden das nicht wirklich
verwenden, weil
es auch hier schön ist, die volle
Kontrolle über unsere eigene Logik zu Lass mich
dir nur zeigen, wie das funktioniert. Wenn wir also bei aktivierter Einstellung auf Kompilieren und
Speichern klicken, wollen
wir hier im Detailbereich auf
die
rechte Seite gehen und die
Projektilbewegung ausgewählt haben Wir wollen die
Gravitationsskala auf Null stellen. Sonst werden wir mit der Zeit
etwas abfallen. Und wir geben ihm die
anfängliche Bewegungsgeschwindigkeit von 300. Wenn wir reinkommen und auf Kompilieren klicken, gehen
wir
in unseren Viewpot und lassen das einfach in
das Level fallen Nun, ich werde nicht auf Play drücken, weil wir wollen, dass sich
das tatsächlich bewegt Aber das
funktioniert im Grunde so, dass wir auf Simulieren klicken
und wir werden sehen, dass es bei etwa 300 Einheiten
losgeht. Also funktioniert es. Es ist nett
und einfach einzurichten. Aber wie ich bereits erwähnt habe, gibt es einen Grund, warum wir das
nicht verwenden werden. Und das
liegt hauptsächlich daran, dass die Komponente Netzwerkreplikation
beinhaltet,
Dinge, die wir
wirklich nicht benötigen. Auch hier sind viele physikalische
Berechnungen nicht erforderlich für
das, was
wir tun werden, nämlich den Umgang mit der Schwerkraft, die wir ausdrücklich deaktiviert haben,
aber sie ist immer noch da. Es ist auch ein
bisschen unflexibel. Wir wollten Dinge wie
Beschleunigung, im Laufe der Zeit,
Homing hinzufügen , all das ist irgendwie an die
Epix-Implementierung gebunden , die längste Zeit Ich glaube, die längste Zeit hat Homing nicht
richtig funktioniert Es gibt einige Umgehungsmöglichkeiten, die
Sie erzwingen können, und die Beschleunigung funktioniert
definitiv nicht Es ist sehr schwierig,
wenn Sie Wert
auf Geschwindigkeit legen und etwas ein
bisschen karikaturhaft aussehen
lassen wollen Wert
auf Geschwindigkeit legen und etwas ein
bisschen karikaturhaft aussehen
lassen und
von 100 Geschwindigkeitseinheiten
dann mit der Zeit auf 600 hochfahren
und dann wieder runterfahren Es ist sehr schwierig,
die Geschwindigkeit dieser
Komponenten zur Laufzeit zu kontrollieren die Geschwindigkeit dieser
Komponenten zur Laufzeit zu Im Grunde genommen ist
das die Beschleunigung, der Geschwindigkeitswert
für
das Projektil, wenn man es
bei 100
bewegten Einheiten spawnt ist
das die Beschleunigung, der Geschwindigkeitswert
für
das Projektil, wenn man es , bis man
es zurücksetzt oder zerstört Aus diesem Grund
werden wir
diesen Schauspieler loswerden, und zwar nur aus
diesem Grund Ich zeige Ihnen lieber, wie
wir eine
sehr ähnliche und viel
einfachere Logik
für unsere eigene Projektilbewegung implementieren können sehr ähnliche und viel
einfachere Logik für unsere eigene Projektilbewegung Nur um Sie wissen zu lassen
, dass ich mir dessen bewusst bin, dass es existiert, werden wir es
trotzdem löschen Wir werden diese Komponente
loswerden
und im Wesentlichen unsere eigene, maßgeschneiderte
Version
herausbringen, die speziell für das geeignet ist, was wir in unserem Projekt benötigen. Wenn wir also
zum Ereignisdiagramm übergehen, werden
wir hier
den Standard verwenden. Wir werden
unser Gesetz abschaffen, damit es zu Überschneidungen kommt. Und denken Sie daran, was ich bereits
gesagt habe: Wir können Venti verwenden, und das ist wieder einer dieser
Fälle, in
denen wir wollen, dass das im Laufe der
Zeit mit einer einfachen
Bewegungslogik reibungslos abläuft Zeit mit einer einfachen
Bewegungslogik Also
wir wollen, dass das auf Eventk läuft. Interesse
geweckt und wollte mir
den Quellcode der Unreal
Engine ansehen , so funktioniert dort sogar die
Projektilbewegungskomponente Projektilbewegungskomponente Das läuft auf Venti, um die Dinge ständig auf dem neuesten Stand zu halten, unabhängig vom
Framework
und angenehm und reibungslos Die Logik, die wir
dafür brauchen, ist wirklich einfach. Wenn wir also von
unserem Ausführungs-Pin ziehen, suchen
wir nach dem lokalen Offset für
den hinzugefügten Akteur. Dadurch wird sichergestellt, dass sich
die Position
des Projektils im Verhältnis zu
seiner eigenen Rotation
vorwärts bewegt Verhältnis zu
seiner eigenen Rotation
vorwärts Eine weitere wirklich nette
Sache ist, dass wir nur angeben müssen in welche Richtung wir schauen
sollen,
wenn wir anfangen, es zu spawnen. Und durch die Verwendung dieser Funktion wird sichergestellt, dass
es sich immer in die richtige Richtung
bewegt Wir teilen die
Struktur hier auf, nur weil wir
wissen, dass wir wollen
, dass sie sich nur auf der X-Achse,
vorwärts und rückwärts,
bewegt Aber du könntest definitiv wieder
reinkommen und eine Seitwärtsbewegung machen ,
wenn du es zu
einem zielsuchenden Projektil oder
etwas Ähnlichem machen einem zielsuchenden Projektil oder
etwas Ähnlichem Alles vom Delta X. Wir werden das zu einer
Variablen heraufstufen, sodass wir einen Float bekommen, und das nennen wir Bewegungsgeschwindigkeit Klicken Sie auf Kompilieren und
wir geben dem Ganzen einen Standardwert von etwa 2000
Einheiten oder vielleicht 2.500. Wir können später zurückkommen und das
ändern, wenn sich herausstellt, dass das
zu schnell geht. Dann
müssen wir natürlich nur herkommen. Dann nehmen wir unsere Bewegungsgeschwindigkeit. Wir multiplizieren das
mit unseren Delta-Sekunden, dass, wie bei
der Bewegung des
Flugzeugs, alles unabhängig von der
Bildrate ist, und geben das Ergebnis hier ein. Und das ist so ziemlich alles. Wir haben eine von der Framerate unabhängige
Projektilbewegung, die sich in die
Richtung bewegt, in der sie erscheinen, sodass sie sowohl für den Spieler als
auch für den Feind angenehm und
leicht zu bedienen ist,
unabhängig davon, wie das ursprüngliche Flugzeug vor einer einfachen,
schnellen Implementierung steht. Sie ist jedoch
anpassbar, falls wir das später erweitern
müssen In den vorherigen Themen
zum Thema Gegner im Visier
habe ich also erwähnt, dass das
Projektil sein eigenes Kollisions
- und Schadenssystem
handhaben würde , und genau das werden
wir jetzt implementieren. Nachdem das statische
Netz ausgewählt ist, gehen
wir nun zu
den Kollisions-Voreinstellungen Und wir wollen das
Preset hier von Block
All auf Overlap oder Dynamic ändern .
Also lassen wir das fallen. Wir finden die
Überlappung oder Dynamik
und können sehen, was das mit den Kollisions-Voreinstellungen macht Der Hauptgrund ist
, dass das Projektil Dinge nicht physisch
herumschieben
sollte Das kann zu Situationen führen,
in
denen Dinge fehlerhaft aussehen wir uns nur bewusst
sein
müssen , dass sie etwas
berührt haben Und wenn du
zurückgeschubst oder die Feinde mit Projektilen bewegt werden, kann
das für den Spieler etwas
seltsam aussehen Wenn wir
Knock-Back als Feature hinzufügen wollen, ist
das völlig in Ordnung, aber wir machen das per Code,
sodass wir die volle Kontrolle haben Wenn sich zwei
Dinge physisch mit der
Blockierungsfunktion
überschneiden, sieht
es im Allgemeinen mit der
Blockierungsfunktion
überschneiden, sowieso nicht nach
Knock Back Es sieht so aus, als ob zwei Dinge
darum kämpfen ,
denselben Raum zu bewohnen, und es ist einfach nicht
angenehm, sich das anzusehen Das Projektil
muss nur etwas aufspüren und treffen,
und wenn das passiert, Schaden
anrichten Keine Physiksimulation
oder ähnliches. Wir werden das Gleiche tun
wie zuvor. Wir werden nach
unten scrollen. Wir finden den Event-Bereich
und möchten hier die On-Komponente hinzufügen, um
den Funktionsaufruf Overlap zu starten. Wenn sich diese Überschneidung also mit etwas anderem überschneidet, so wie
wir es zuvor getan haben , müssen wir
einige Informationen herausfinden und schauen, ob Schaden angerichtet
wird. Wir nehmen hier den Schauspieler,
also den anderen Schauspieler, wieder
wie zuvor, wir werden das zu einer Variablen
heraufstufen und diese
eine Überschneidung als Schauspieler bezeichnen. Und das
aus demselben Grund wie bei den Feinden. Wir werden einige Informationen
damit abgleichen wollen . Wir wollen hier nicht dauernd an diesem Pin
ziehen, also verwenden wir eine Variable, die
wir als Referenz gespeichert haben. Das Erste, was wir meiner
Meinung
nach berücksichtigen wollen, ist, ob das, was wir
überlappt haben , als das Ding referenziert wird ,
das Sponda ist,
also der Eigentümer Wenn
der Feind zum Beispiel feuert
und dieses Projektil als feindliches Projektil eingestuft wird, wollen
wir nicht, dass es dem
Flugzeug des Feindes Schaden zufügt Und wenn der
Spieler ein Projektil abfeuert, wird
dieses ebenfalls als Projektil der Schicht eingestuft Wir wollen uns natürlich nicht selbst
Schaden zufügen. Das Erste, was
wir tun können, ist unseren überlappenden Akteur zu
ermitteln und dann zu überprüfen, ob das wieder einem bestimmten
Akteurtyp
entspricht Wenn das also gleich ist und
wir nach einer anderen eingebauten
Tracking-Variablen suchen können , die standardmäßig von
der Unreal-Engine
bereitgestellt und verfolgt wird, können
wir sie genauso
gut verwenden Wir werden nach dem Besitzer von G
suchen. Wann immer also etwas in die Welt
gebracht wird, ihr sofort das
Konzept gegeben, was es besitzt,
was es hervorgebracht hat.
Also können wir Also können wir sagen, wenn
das Ding, das wir
überlappt haben , auch der Besitzer ist, dann
überspringen wir es einfach, Schaden anzurichten Der Hauptgrund dafür ist
, dass wir
unseren Spawnpunkt vielleicht
direkt in der
Mitte des Flugzeugs wählen möchten unseren Spawnpunkt vielleicht direkt in der
Mitte des Es wird also
einen sehr kurzen Moment geben in dem sich das Projektil
, das der Spieler spawnt, für einen Moment
im Flugzeug Wenn das der Fall ist,
ignorieren
wir
hier einfach die erste Überschneidung, wir werden nichts tun Also ziehen wir hier einen Zweig
, der unser bedingter Ablauf ist, also werden wir prüfen, ob wir
auf der Grundlage dieses Ergebnisses etwas
tun sollten . Und wenn das stimmt, dann können wir im Grunde einfach überspringen, wir
werden überhaupt nichts tun. Aber ich lese sie generell
gerne, weil ich Dinge gerne außerhalb
der Truppe mache, wo es möglich
ist wo es möglich Das ist eine persönliche Präferenz. Auch hier
werden verschiedene Programmierer immer
unterschiedliche Vorlieben haben, was die Art und
Weise angeht, wie sie Dinge angehen Aber mir wäre es lieber, wenn mein
tatsächlich finalisierter Code, das Ding, das
die Hauptfunktionalität erfüllt,
wahr wird. Ich werde
also tatsächlich einen etwas anderen Checkout
machen ich wollte zuerst nur den
lesbareren Weg zeigen,
aber mit einer sehr kleinen Änderung, nach der wir tatsächlich
suchen können, ist nicht gleichwertig also ein Ausrufezeichen
und Gleichheit angeben, wird wir also ein Ausrufezeichen
und Gleichheit angeben, wird der Überlappungsfaktor als
ungleich Wir stecken das
hier ein und das macht
jetzt die umgekehrte Prüfung Das ist also die Überprüfung, ob
das Ding der Besitzer ist, und das überprüft jetzt, ob
das Ding es dann nicht ist Also, wenn wir das stattdessen einstecken, bekommen
wir hier dieses Ergebnis. Wir sagen also, wenn der
Überlappungsfaktor nicht der Besitzer ist, und so führe ich meinen Code am
liebsten aus,
dann können wir unsere
Schadensanwendung ausführen Eigentümer , wenn
das nicht das Objekt
ist, das Also noch einmal, einiges davon
dient wirklich nur dazu, die unterschiedliche Art und Weise zu zeigen
, wie Sie über
Ihren Code nachdenken können und
wie Sie
mehrere Ansätze haben können, um dasselbe Problem zu
lösen, auch wenn es nur
darauf ankommt, wie der Code gelesen wird. Und das ist jetzt nett und einfach. Wir können unseren
Überlappungsaktor wieder verwenden, Control, das hineinziehen, es von diesem Pin ziehen, und das haben
wir schon einmal gemacht. Wir werden
das Anwenden von Schaden
als globale Universalfunktion bezeichnen . Die, die auf jede Art von Schauspieler angewendet
werden kann. Das können wir also
in die richtige Stecknadel gießen. Wenn das Ding, das wir
getroffen haben,
nicht unser Besitzer können wir es beschädigen. Ich denke, standardmäßig gebe
ich einen Standardwert von 20, also geben
wir hier 20 ein. Wir werden das
zu einer Variablen heraufstufen. Denken Sie auch hier daran, dass, wenn Sie hier
einen Wert eingeben, bevor Sie
ihn zu einer Variablen heraufstufen
, dieser Wert in dieser Variablen
bereits gespeichert ist. Und die Hauptsache ist, dass
wir keine magischen Zahlen wollen. Ich werde diesen
nur in Projektilschaden umbenennen. Klicken Sie auf Kompilieren und
überprüfen Sie einfach, ob wir die Zahl
20 hier eingegeben haben
sollten Wenn wir das erledigt haben, möchten
wir idealerweise damit beginnen, einige Sound
- und Partikeleffekte
abzuspielen , die für das Projektil
spezifisch Ich habe statt
einer vollständigen Explosion einige
wirklich kleine Funken erzeugt,
nur um anzuzeigen, dass
etwas auf
eine Oberfläche getroffen ist , anstatt tatsächlich eine Explosion
auszulösen Um das zu tun, werde ich dasselbe Konzept verwenden ,
das ich
bereits erwähnt habe Ich werde C innerhalb
des Ereignisdiagramms drücken ,
ohne dass etwas ausgewählt ist. Ich drücke einfach C,
um einen neuen Kommentar zu erstellen, und ich gebe hier
ein großes To-do-Zeichen, und dann sagen wir einfach
so etwas wie Effekte implementieren. Das werden wir
etwas später in
unserem Polish Pass tun . Das ist in Ordnung. Nein, das wird
uns nur daran erinnern, wieder hierher zu kommen. Wie ich bereits erwähnt habe, gebe ich dem
normalerweise
eine Art gelbgrüne Farbe nur um mich daran zu erinnern und mich wirklich gegen andere Dinge , die in der Grafik erscheinen könnten Aber was wir
auf jeden Fall tun wollen,
ist, dass wir, sobald wir unsere Effekte
gespielt haben, sicherstellen wollen, dass das Projektil aus
dem Spiel
entfernt wird Also werden wir
aus der Hinrichtungsnadel ziehen, dem
Zerstörer suchen und uns selbst
loswerden Das Projektil hat seinen Zweck erfüllt, also kann
es verschwinden. Und
das ist so ziemlich alles Also werden wir überprüfen,
was wir überlappt haben. Wenn es nicht der Besitzer ist, werden wir Schadensersatz
anrichten Also, das ist ein wirklich sicherer Anruf. Sie fragen sich vielleicht, was passiert,
wenn ich auf die Seitenbegrenzung oder so etwas wie einen Boden treffe, den ich hineinlegen
kann, oder einen Pickup
oder so Nun, falls das passiert
und sie nicht
die Funktion zum Einschalten von Schäden haben ,
die wir zuvor gesehen haben, können wir hier
den Schaden sehen Sie haben das nicht
in ihrer Codebasis implementiert ,
dann ist das völlig in Ordnung. Sie werden
diese Informationen erhalten, aber sie haben
kein Gesundheitssystem oder
sonst etwas, mit dem sie sich befassen müssen. Es ist also quasi eine sehr,
sehr billige Wegwerfnachricht Wir werden keine
Leistungsprobleme bekommen, es sei denn, wir machen etwas wirklich drastisch
Schlimmes damit, und es wird nichts
bewirken Ich werde weder
die Böden noch die Wände
oder so etwas zerstören . Es ist also eine nette sichere Funktion. Wir müssen nichts
über den anderen Schauspieler wissen. Solange wir etwas
angefasst haben,
können wir einige allgemeine
Informationen darüber herausfinden. Und wenn wir denken, dass
wir vielleicht versuchen wollen , Schaden
anzurichten, dann ist
das völlig in Ordnung. Wir können einfach diese Nachricht senden. Die letzte Sache ist also, das wiederverwendbar
zu machen. Das ist der Schaden, der
auf ziemlich universelle Weise verursacht wird. Wir wollen sicherstellen
, dass unsere Projektile Farbe des Schützen
entsprechen, sodass der Spieler blaue
Projektile abfeuert und die Gegner grüne Projektile oder was auch immer ihr
anpassen möchtet Deshalb kehren wir hier zu
unserer Startfunktion zurück . Wir wollen das nur einmal machen , wenn das Projektil erscheint. Wir wollen uns tatsächlich unsere Komponente
schnappen. Wir können etwas Code die Komponenten erstellen, die
wir bereits haben, also ziehen wir ihn
in den Event-Graph, und wir werden
von hier aus nach Create Dynamic
Material Instance
suchen . Wir haben hier also nur diese
eine Option. Und das ist einer der Vorteile
der Verwendung von Materialinstanzen gegenüber
unserem Mastermaterial Der Basis-Shader-Code ist
in der Material-Instanz enthalten, wir können sie in
eine dynamische Version umwandeln und wir können
ihre Eigenschaften tatsächlich zur Laufzeit aktualisieren Wir wollen hier den
Rückgabewert nehmen, also die dynamische Version,
die erstellt wird, wir wollen sie zu einer Variablen heraufstufen
, und wir nennen das
Material R. Es ist
also nur ein Verweis
auf unser Material Auf dieser Grundlage können wir unseren Code erstellen , um einige
der Kerneigenschaften zu ändern. Die Hauptsache, wenn Sie mehr darüber
wissen möchten , ist, dass
Sie nur
die Namen der
Variablen kennen müssen , mit denen Sie arbeiten
können. Und
das ist wirklich einfach. Wenn wir uns das statische Netz schnappen, zeigen wir Ihnen
einfach ganz schnell
einige der anderen Dinge, die Sie tun können, sobald Sie
eines gelernt haben , das ich gleich mit Ihnen
durchgehen werde. Wenn wir auf das Projektil mit dem
MI-Unterstrich doppelklicken, wissen
wir, dass dies
unsere materielle Instanz ist Dadurch wird das Asset für uns geöffnet. Und im Grunde alles, was ich Ihnen
hier gezeigt habe , denken Sie daran, ich gesagt habe, dass ich dieses große,
einigermaßen anpassbare Material
erstellt habe . alles, was in
unserem Abschnitt hier genannt wird ,
kann im Code zugegriffen werden. Sie können also die
Spiegelung zur Laufzeit ändern,
wenn Sie möchten, dass die
Dinge
glänzender und möglicherweise nasser aussehen glänzender und möglicherweise Sie können zur
Laufzeit die Textur, die Farben, die Überschreibungsfarben und
die
Emissionseigenschaften ändern ,
wenn Sie das Objekt zum Leuchten bringen möchten.
Du wolltest es tun Solange Sie die Benennung
und die genaue Schreibweise kennen, können
Sie diese ändern und
beeinflussen. Die Art und Weise, wie wir etwas wirklich
Einfaches
tun können , um diese Art von
Untätigkeit zu zeigen , besteht darin, dass wir uns
unsere Materialreferenz holen wollen Und noch einmal, persönliche Präferenz, ich lasse mir immer einen neuen Knoten
von hier holen, aber Sie könnten einfach
die Informationen aus
dieser
Materialreferenz finden , die Sie gerade zu einer Variablen
heraufgestuft haben zu einer Variablen
heraufgestuft Ich nehme hier unsere
Variablenreferenz und
möchte daraus den eingestellten
Vektorparameterwert ermitteln. Also ist es diese Option hier. Wir sehen, dass dies unter
die Kategorie Material fällt, also suchen wir nach
dem Richtigen. Auf diese Weise können wir in diesem Fall die Farbe
eines Vektors festlegen. Also stecken wir das
in den Ausführungsstift. Der Vektor, den wir ändern wollen wird die Farbe sein,
also die Emissionsfarbe Und auch hier können wir immer
einfach nach cs checken. Das nennt man Emissionsfarbe, das ist
also die Farbe, nach der
ich suche Und die neue Farbe, die ich mir
wünsche, wird auf dem
Schauspieler
basieren, der sie hervorgebracht hat Wenn es also ein grüner Feind ist, mache ich es
vielleicht grün. Wenn es unser Spieler ist,
mache ich es blau. Wenn du einen roten Feind
hast, solltest du ihn vielleicht rot
machen. Lassen Sie uns einfach überprüfen
, ob das funktioniert. Wenn wir das in
etwas ganz Offensichtliches ändern, machen
wir es
vorerst gelb, klicken auf Kompilieren, Speichern. Das werden wir erst erleben,
wenn wir mit dem Spielen beginnen. Also können wir
das in das Diagramm einfügen und hier
auf Simulieren klicken. Wir sollten sehen, wie das
anfängt zu leuchten. Ein weiteres Problem, das
ich hier wohl habe betrifft
das
MI-Underscore-Projektil Ich möchte sichergehen, dass
das angekreuzt ist. Aber ich muss auch sicherstellen,
dass eine gewisse Emissionseigenschaft hat. Also werde ich
reinkommen und sicherstellen, dass der Standardwert für die
Emissionseigenschaft hier zehn ist. Denn auch hier
multiplizieren wir es gerade, jede Farbe mit Null
lässt es nicht leuchten Wenn wir also
erneut auf Play drücken oder simulieren, können wir tatsächlich sehen, dass das jetzt gelb geworden
ist Wenn ich also nur ein bisschen näher heranzoome, drücke
ich auf Simulieren, damit wir
das Ganze sehen können und wir
ein gelbes, leuchtend gelbes Projektil haben Die einzige Änderung, die Sie vornehmen
möchten, ist
das Material zu öffnen und dafür zu sorgen dass es
so stark leuchtet, wie
Sie Sie können es viel
übertriebener machen, sodass wir
ein sehr helles,
leuchtendes Projektil machen können, ganz Also werde ich das auf 100
setzen, damit es sehr, sehr gut sichtbar ist Und das ist
so ziemlich das, was wir hier tun. Also nehmen wir diese
Eigenschaft beim Namen und setzen sie auf einen
neuen Wert, nett und einfach Etwas anderes, das
Sie vielleicht tun möchten, ist, einige
mehr leuchten zu lassen als andere Also
musste ich hier nur die Emissionsstärke manuell bearbeiten Also könnten wir
stattdessen einfach zeigen, wie wir dieses System nutzen
können Wir können die
Materialreferenz duplizieren, und dieses Mal werde
ich einen Skalarwert festlegen Die Werte, mit denen
wir arbeiten, werden, obwohl sie als Gleitkommazahlen
bezeichnet werden, ,
wenn wir
mit Materialien arbeiten leider Skalare
genannt Das liegt daran, dass sie zu skalierbaren
Floats gemacht wurden. Wir können sie zur Laufzeit ändern. Also versuche einfach, dich daran zu erinnern. Es ist eine etwas neue Terminologie, aber die, die Sie lernen
müssen, um speziell mit Materialien zu
arbeiten. Also nehmen wir
unseren Skalarwert. Diesen habe ich
Emissionsstärke genannt. Also werden wir
das anschließen. Wir werden unsere Emissionsstärke herausfinden Und dann kannst du das
auf den Wert ändern , den
du haben möchtest Also könnten wir standardmäßig etwas wirklich
Dummes daraus
machen , wie 1.000 1.000 waren vielleicht
ein bisschen extrem, aber es zeigte das
allgemeine Konzept Ich setze
das auf 100 zurück. Ich finde, das sieht
ziemlich cool aus als etwas emittierende
Eigenschaft
für ein Projektil, das
sich ziemlich schnell bewegt Möglicherweise müssen wir das betonen, um es
sichtbarer zu machen. Wie bei allem wollen
wir nicht, dass dies wieder magische Variablen sind. Wir könnten das nur
hier direkt im Code ändern . Also werden wir unsere Farbe
zu einer Variablen
heraufstufen , die wir verfolgen und später verwenden
können. Wir geben diesem einen
Projektil die Farbe unseres Werts wegen. Also der
Fließkommawert hier. Wir machen daraus
eine Variable und nennen das eine
Projektil-Emissionsstärke Das gibt uns also eine
gewisse Flexibilität, wenn wir anfangen, sie
in unseren übergeordneten Klassen,
dem Feind oder dem Spieler, zu spawnen dem Feind oder dem Nun, einige von euch
haben vielleicht bemerkt, dass es noch
ein anderes Problem gibt , das wir noch nicht
wirklich angesprochen Und das heißt, dass die
Projektile potenziell für immer im Weltraum
fliegen können , wenn sie überhaupt
nichts treffen Ich habe überlegt, ob Dinge
auf den Boden und die Wände treffen, ich habe gesagt, dass sie sich einfach von selbst
reinigen Eine sehr billige
Wegwerffunktion abfeuern, die völlig in Ordnung ist, um Schäden an der Wand
anzubringen, was im Grunde ignoriert
wird, aber wir haben nicht bedacht, was passiert, wenn sie gar nichts
treffen Im Moment
werden sie einfach in die Ewigkeit fliegen und Erinnerungen
auffressen auffressen Es gibt also zwei Dinge
, die wir tun könnten. Erstens: Wenn wir uns
unser Haupthaus hier schnappen, können
wir jedem Schauspieler, mit dem wir zusammenarbeiten
, ein Leben lang schenken . Also werde ich das einfach im Detailbereich finden
. Wir können hier lebenslang suchen, und wir können dem
eine anfängliche Lebensdauer geben. Wenn wir wissen, dass das definitiv nicht
länger als, sagen
wir, 10 Sekunden auf dem Bildschirm zu sehen sein wird, dann können wir dem
eine Lebensdauer von zehn Sekunden geben Und wenn es nach dieser Zeit
nichts berührt, wenn wir hier nicht die
Zerstörungsfunktion aufrufen, wird
es einfach automatisch
zerstört Das Problem dabei ist
, dass wir am Ende einige Projektile haben, die sich
etwas langsamer bewegen als andere, oder wir werden sie verwenden
und sie vielleicht später recyceln,
was bedeutet, dass wir
sie einfach verstecken und später
wieder ins Spiel bringen können sie einfach verstecken und später
wieder ins Spiel bringen Und natürlich wollen wir nicht, dass
unsere Projektile nach 10 Sekunden
zufällig vom Bildschirm verschwinden Also werde ich diesen Ansatz eigentlich nicht verwenden. Eine andere Sache, die Sie vielleicht
sehen, ist auf der Eventi, eine ständige Überprüfung, ob es sich
derzeit außerhalb der
Kamera oder außerhalb der Zone Und wir werden
etwas Ähnliches machen, aber ich wollte mich wieder
auf gute Programmierpraktiken konzentrieren auf gute Programmierpraktiken Wie gesagt, einige
Dinge
können und sollten definitiv auf Tick stehen, aber das gehört nicht zu dem, was
wir tun werden, ist eine neue Funktion
namens Out of Bounds Check zu
erstellen Und das wird nur eine sehr
, sehr einfache Mathematik sein. Also klicken wir mit der
rechten Maustaste und
suchen nach der Position des G-Aktors, der Position des Projektils
an seinem aktuellen Punkt Wir ziehen
von diesem Knoten und
nehmen einen weiteren Vektor
weg. Also
subtrahieren wir hier einen Knoten
und können etwas verwenden, das als Player-Kamera-Manager bezeichnet wird das als Player-Kamera-Manager Wenn wir uns also den
Player-Kamera-Manager besorgen, können
wir feststellen, dass das Vorgefertigte immer irgendwie referenziert wird und sich sowieso
im Unreal-Speicher befindet, irgendwie referenziert wird und sich sowieso
im Unreal-Speicher befindet,
also können wir genauso gut diese Werte
verwenden , die für uns bereits existieren Und vom
Player-Manager, dem Ding, das gerade die
aktuelle aktive Kamera verfolgt, können
wir die Kameraposition abrufen Das wird also der
aktuelle Standort der Kamera sein, auf die
wir schauen. Also können wir diese beiden wegnehmen und das ergibt einen neuen
Vektor, eine Entfernung für uns. Daraus können wir hier
vom Vektor-Pin ziehen, und wir wollen
die Vektorlänge nehmen. Wenn wir also nach der Länge suchen, können
wir die Vektorlänge ermitteln. Dadurch wird dies für uns in
einen Fließkommawert umgewandelt , der uns im Wesentlichen eine
geradlinige Entfernung gibt. Wir wissen also genau, wie viele
Einheiten in einer geraden Linie unser aktuelles Projektil von unserer Kamera entfernt
ist Das funktioniert unabhängig
von der Richtung, was ein weiterer
sehr
nützlicher Aspekt dieses Ansatzes ist ,
was bedeutet, dass es für Projektile
funktioniert , die in jede
Richtung und jeden Winkel
fliegen Und was wir dann tun wollen,
ist,
von unserem Hinrichtungsbolzen aus zu ziehen und einen Ast zu bekommen Du hast genug Platz
, um damit zu arbeiten. Und wir
werden im Grunde sagen, wenn diese Vektorlänge
größer oder gleich
einem bestimmten Wert ist , dann werden wir diesen Akteur
zerstören. Also sage ich mehr als oder
gleich, um zu
berücksichtigen, ob es diesen Wert überschreitet. Wenn das stimmt, werden wir
das hier einbauen, die Dinge hier ein bisschen
aufräumen. Und ich gebe
das, ich denke, ein Wert von 3.500 Einheiten funktioniert Das liegt also ungefähr außerhalb
der Kamerazonen. Wir können ein bisschen
wissenschaftlicher sein und versuchen, das später zu testen. Wenn Sie feststellen, dass
Dinge zu früh vom Bildschirm verschwinden, möchten Sie diesen Wert einfach
erhöhen, und wenn die Dinge
zu lange dauern, können Sie ihn
verringern. Aber ich denke
, das wird definitiv funktionieren Es spielt keine Rolle
, ob sie
ein paar Sekunden länger existieren ,
als sie sollten. Die Hauptsache ist, dass wir nicht
wollen, dass sie einfach magische Weise vom
Bildschirm verschwinden und verschwinden Und wir wollen nicht, dass
Hunderte und Hunderte von Projektilen
minutenlang existieren Das ist eher das Problem, das
wir zu lösen versuchen. Wenn das stimmt, dann
ziehe ich von hier ab, ich sage
Schauspieler zerstören, nur damit wir das Projektil
aus dem Speicher löschen
können So nett und einfach. Wie immer, keine magischen Zahlen,
also werde ich
runterkommen und
das auf variabel hochstufen. Wir nennen das so etwas
wie Außerirdische Entfernung. Und auch das
macht es nett und einfach, dass wir immer
sofort wieder hierher kommen können Und wenn wir
Probleme haben , bei denen wir das ändern,
erhöhen oder verringern
mussten , haben wir jetzt einen
schönen, leicht zu findenden Ort,
an dem wir diese Änderung vornehmen können. Im Moment haben wir diese Funktion noch nicht
aufgerufen, also
ist es sehr einfach, ein
Problem zu lösen oder zu übersehen, zu übersehen, dass wir die Funktion nicht einfach
machen können Wir müssen das auch nennen. Wir wollen das nicht
nur einmal anrufen. Natürlich würden wir das nicht
zu Beginn des Spiels tun wollen. Und wie ich bereits erwähnt habe, wollen
wir das nicht ständig auf Eventi
machen ständig auf Eventi
machen Stattdessen werden
wir vom Ausführungspin aus tun ,
nachdem wir den Skalarparameter hier gesetzt
haben, werden wir wieder
Timer verwenden Diese sind sehr, sehr flexibel. Also suchen wir nach derselben Funktion
, Timer
nach
dem Funktionsnamen eingestellt ist. Die Funktion, die wir wollen
,
wird offensichtlich unsere Sperrfrist überprüfen Also nochmal, ich
werde
das umbenennen , es tatsächlich umbenennen,
aber drücken Sie Strg C,
Strg V, um es einzufügen, und wir könnten einstellen, dass es
vielleicht einmal pro Sekunde wiederholt Denken Sie also daran, dass, wenn
wir das mit Tick
machen würden, dies
möglicherweise 120
Mal pro Sekunde überprüft würde, basierend
auf meiner aktuellen Bildrate. Das ist also ein bisschen
übertrieben. So präzise
müssen wir es nicht machen Das einmal pro
Sekunde zu tun, wird die Leistung des Spiels nicht massiv erhöhen ,
und
das bedeutet, dass wir
immer noch in relativ
kurzen Iterationen oder
Intervallen nach Projektilen suchen relativ
kurzen Iterationen oder , die nicht auf dem Bildschirm sein müssen Wie ich bereits erwähnt
habe, ist es nicht so, dass ein Projektil mehrere
Sekunden länger in der
Nähe ist, dass Hunderte von
Projektilen
120 Mal pro Sekunde überprüft werden .
Falls sie noch existieren sollten,
wäre das
ein .
Falls sie noch existieren sollten, wäre Wir wollen sicherstellen, dass
dies kontinuierlich,
also mehr als einmal, aufgerufen
wird , also setzen wir es auf Looping Also einmal pro Sekunde wird
das jetzt aufgerufen. Wir haben eine
Endlosschleife dieses Timers
, bei der immer wieder überprüft wird das Projektil an der Kamera
befindet und ob es technisch gesehen nicht sichtbar ist Also können wir das testen.
Wenn wir eines davon anschließen, machen
wir vielleicht ein
paar davon
und klicken auf Simulieren, damit wir sehen
können, wie es losgeht. Und Sie können sehen, wie
einer von ihnen
tatsächlich das feindliche Flugzeug getroffen hat,
sodass es tatsächlich das feindliche Flugzeug getroffen hat, durch den Aufprall zerstört wurde. Aber der andere feuert
ab, und ab einer gewissen Entfernung sehen
wir ihn nicht mehr. Wenn ich also von hier aus auf
das
Flugzeug drücke, ist die Hauptsache,
wir haben sie nicht einfach durch die Kamera
verschwinden sehen , das wollen wir vermeiden. Aber wir wissen aus den vorherigen
Tests, dass sie
gelöscht werden , wenn wir
das im Simulationsmodus testen Natürlich
fliegen sie davon und tauchen außerhalb
der Kameraansicht wieder auf Das ist also eine nette,
saubere Art, das zu tun. Das wird keinen großen
Mehraufwand bedeuten. Dies würde definitiv keine Leistungsprobleme
verursachen. Es ist hier eine relativ einfache und leichtgewichtige
Berechnung. Ich denke, es ist viel sicherer als Lifetime zu
verwenden,
weil wir nicht wissen wie lange oder wie schnell sich
alle Projektile bewegen
werden und wie
lange sie auf dem Bildschirm sein könnten Und das ist billig genug, um
diese Berechnung durchzuführen , sodass es zu keinen Leistungseinbußen kommt. Und ich wollte
nur einen einfachen
Vergleich zeigen , wo wir Tick verwenden
könnten und wo
wir Tick vermeiden würden. Denken Sie daran, wenn wir mit diesen Dingen
spielen, kommen Sie
immer wieder rein und löschen Sie
die Schauspieler, die Sie möglicherweise
nicht mehr verwenden. Die wollen wir nicht bei uns
behalten. Wir werden sie etwas später über
eine Feuerfunktion Also noch einmal, wenn du immer noch mit diesen Dingen
herumspielst, gerne
verschiedene Geschwindigkeiten und Farben ausprobieren , um zu
sehen, ob du irgendwelche der
anderen Eigenschaften
in der Material-Instanz
beeinflussen möchtest irgendwelche der
anderen Eigenschaften
in der Material-Instanz
beeinflussen in der Material-Instanz Sie heraus, ob Sie herausfinden können,
wie Sie einige
der anderen Skalarwerte
oder Vektorparameter ändern der anderen Skalarwerte
oder Vektorparameter Auch hier ist die Hauptsache, Sie brauchen
nur ihren Namen und die genaue Schreibweise, und schon geht es
Ihnen gut Sie können die Werte nach
Belieben ändern . Eine weitere
coole Herausforderung. Nein, du fühlst dich hoffentlich mit einem
Teil des Programms
wohler. Um die Beschleunigung im Laufe der Zeit
mit vielleicht einer Art
von Interpolation hinzuzufügen mit vielleicht einer Art
von Interpolation Sie können diese Ansätze dem anderen
Code entnehmen, den wir Und es ist eines der
schönen Dinge, die ich
bereits erwähnt habe , wenn es darum geht
, unseren eigenen Code zu implementieren. Es ist einfach etwas, das mit der Komponente der
Projektilbewegung fast unmöglich
ist mit der Komponente der
Projektilbewegung Wenn Sie also möchten, dass es sich von einer langsameren Geschwindigkeit bewegt und mit der
Zeit schneller oder rückwärts beschleunigt, können
Sie es sehr schnell
fliegen und dann langsamer werden,
ohne an Dynamik zu verlieren Sie könnten sich auch Dinge wie
das
Zielsuchen Projektilen mit
ähnlichen Techniken ansehen und sich im Laufe der Zeit gegenseitig auf ein
bestimmtes Ziel zusteuern Ich habe schon erwähnt, dass ich
empfehlen würde,
die aktuelle Klasse so zu lassen die aktuelle Klasse Wenn Sie diese Tests machen und einige
dieser Experimente ausprobieren Ich würde immer empfehlen, das
zu duplizieren, was Sie haben, und zu versuchen,
Ihre eigene Version daraus Es ist jedoch eine großartige Art
zu lernen. Ich möchte Sie
nicht davon abhalten neue Dinge auszuprobieren,
aber
in den zukünftigen Themen werden
wir diese Projektile natürlich genauso
verwenden, wie sie sind Ich würde also empfehlen,
auch diese Version
zu haben , damit wir
das Projekt gemeinsam abschließen können
21. 20 - ProjektilFeuerFeind: Damit die Dinge tatsächlich ihre Projektile
abfeuern. Wir werden das
nochmal machen, nett und aufgeräumt. Eine Feuerfunktion in der Basisklasse, die
von den Kindern bei Bedarf angepasst gleiche Muster, das wir
schon einmal verwendet haben, also werden wir am Ende
die gleiche Funktionalität haben wie unser Beispielprojekt, an dem wir gerade arbeiten, aber wir verfolgen einen etwas
anderen Ansatz Also zunächst nur zur Erinnerung: Falls Sie irgendwelche
Projektile
herumliegen hatten , würde ich
empfehlen, diese zu löschen Bevor wir beginnen, werden
wir all
diese bei Bedarf dynamisch zur
Laufzeit spawnen diese bei Bedarf dynamisch zur
Laufzeit Wir werden
in unserer Basisflugzeug-Klasse beginnen. Wenn wir also zur Basis der
Kernebene gehen und unsere erste
Implementierung genau hier
durchführen, werden
wir hier eine Funktion
namens fire erstellen. Wir werden
etwas sehr Ähnliches tun, wie wir es
mit unserer feindlichen Spawner-Klasse gemacht haben mit unserer feindlichen Spawner-Klasse Wir ziehen an der Hinrichtungsnadel
und suchen nach dem
Spawn-Darsteller
aus dem Wir können es noch einmal,
wir ziehen von
hier aus und wir werden
das zu einer Variablen hochstufen Und falls wir das später
ändern wollen , denke
ich, dass wir nur
eine einzige Projektilklasse haben eine einzige Projektilklasse Falls wir aber
unterschiedliche Projektile haben wollen, werden
wir das fördern, damit Wir werden es in
Projektilklasse umbenennen. Belassen Sie dies als
Standarddarstellertyp, klicken Sie auf Kompilieren, und das ist in Ordnung Wenn wir jetzt auf Compile klicken, erhalten
wir die
Fehlermeldung, dass wir einige
zusätzliche Informationen angeben
müssen . Wir benötigen die TransponPIN. Wir können zwei Dinge tun. Wir können den Strukturstift
teilen. Und wenn Sie
das komplett leer lassen möchten, können
wir auf Kompilieren klicken und der Fehler
wird dadurch behoben. Jetzt
drücke ich in Dead auf Control. Es gibt noch eine andere Sache
, die wir hier tun können. Was den Spawn-Ort angeht, müssen
wir
genau wissen , wo
unsere Projektile
entstehen sollen unsere Projektile
entstehen sollen Und eine Möglichkeit,
dies zu tun und das Ganze
etwas visuell zu gestalten , besteht darin, eine neue Komponente
hinzuzufügen Ich gehe
in den Viewpot. Ich werde
eine neue Komponente hinzufügen und die
Szenenkomponente einfach hier auswählen Eine Sache, die ich hätte
tun sollen, ist, das bereits das Mesh
auszuwählen, aber
das ist völlig in Ordnung. Ich möchte, dass diese Szenenkomponenten immer dem folgen, was mit dem Mesh
passiert. Also nehme ich das und lasse es
wieder
fallen und konzentriere mich dabei auf Hierarchie, sodass die
neue Szenenkomponente ein untergeordnetes Element des statischen
Netzes ist. Um das klarzustellen, wenn
du das wirklich willst, könnten
wir das umbenennen
, und ich nenne dieses eine Projekt
unseren Spawn-Standort Wenn wir uns also unsere Hierarchie
ansehen, haben
wir eine ziemlich genaue Vorstellung davon,
wofür diese verschiedenen Komponenten verantwortlich sind Nun,
das muss nicht visuell sein, aber was wir damit
machen können ist, dass
wir es jetzt bewegen können und direkte Kontrolle
darüber haben wo das
Projektil erscheinen soll Wir könnten das etwas vor
dem Flugzeug haben. Nun, wie ich schon
erwähnt habe, möchten
wir vielleicht nur etwas
innerhalb des Flugzeugs ist, damit es nicht so aussieht,
als würde es wie Zauberhand aus dem Nichts
erscheinen Wenn ihr
mit
der Position eures
Projektil-Spawn-Standorts zufrieden seid und wir erneut auf Kompilieren klicken, bekommen
wir im Viewpot tatsächlich dieses schlechte Blueprint-Ergebnis dieses schlechte Blueprint-Ergebnis, aber das ist völlig
in Wir wollen einfach zurück
zu unserer Feuerfunktion. Wir werden kontrollieren, ob
das Projektil am Boden
landet Ich werde von hier
aus nach
etwas suchen, das sich Get
World Transform nennt Also wollen wir diese Option nur
hier mit der grünen Funktion? Get World transform wird
die Transformation
dieser spezifischen
Komponente in der Welt im
Verhältnis zur Rotation und
allem, was passiert ist, bereitstellen dieser spezifischen
Komponente in der Welt im . So können wir sicherstellen, dass das Projektil nach vorne
gerichtet ist Wir schließen das an,
klicken auf Kompilieren
und wir können sehen, dass die Probleme jetzt behoben
sind. Ich wollte nur etwas anderes
zeigen, und ich denke, es könnte sich tatsächlich lohnen,
das hier von
einem Schauspieler auf eine spezielle
Projektilklasse umzustellen einem Schauspieler auf eine spezielle
Projektilklasse Wenn wir hier einfach zu
unserer Projektilklasse zurückkehren, doppelklicken
wir, um die Basisklasse zu
öffnen, und stellen
einfach sicher, dass wir hier
zwei Dinge angezeigt haben. Wir wollen also, dass die
Projektilfarbe,
die
Emissionsstärke des Projektils
und vielleicht auch die Geschwindigkeit der
Projektilbewegung sichtbar werden die
Emissionsstärke des Projektils und vielleicht auch die Geschwindigkeit der
Projektilbewegung Geschwindigkeit der
Projektilbewegung Wir stellen sicher, dass diese drei öffentlich sind
. Du kannst immer wieder zurückkommen, ich
versuche , den
Grundstein für dich zu legen. Du kannst zurückkommen und, sobald du gesehen hast, was
wir tun werden, alle anderen Änderungen vornehmen
, die du willst. Sind völlig optional, aber ich denke, diese drei eignen
sich gut zum Testen. Und wenn wir auf Kompilieren und Speichern klicken, kehren
wir zu
unserer Plane-Basisklasse und zur Fire-Funktion zurück. Da dies nun standardmäßig auf einen generischen Akteur eingestellt
ist, gibt es keine offengelegten Daten. Jetzt können wir mit
Hilfe einer bestimmten Eingabe unserem Projektil mit dem Unterstrich
BP suchen Wir wollen die Basisoption verwenden, wir müssen sie
aufklappen und
den Klassenreferenztyp auswählen ,
nicht den Objekttyp Das wird uns nur sagen, dass sich
einige Dinge ändern
müssen. Möglicherweise haben wir einige im Wesentlichen
defekte Verweise oder Links zu verschiedenen Klassentypen, und das ist völlig in Ordnung. Wir sagen, ändere diese Variable. Wir lassen das sein Ding machen. Es wird wirklich nichts kaputt machen
,
weil wir zu diesem Zeitpunkt sowieso nichts
Bestimmtes verwenden . Wir hatten nur einen generischen Schauspieler.
Wir können das also schließen. Und was ich zeigen wollte
, ist, dass wir, wenn wir mit der rechten Maustaste auf
den Spawn-Akteur klicken und hier
die Option „Node aktualisieren“ wählen hier
die Option „Node aktualisieren oder sicherstellen,
dass wir zuerst auf Compile
klicken ,
die Eigenschaften sehen sollten , die
wir gerade veröffentlicht haben, und ich habe gerade erkannt, wo
das Problem liegt Es gibt noch einen weiteren Schritt, den
man leicht übersehen kann. Und wir
gehen zurück zur Projektilbasis. machen sie nicht nur öffentlich, Wir machen sie nicht nur öffentlich,
sondern brauchen noch ein weiteres
Kästchen Also nur ein paar der Dinge, die du über Unreal wissen
musst, und du wirst das
nachholen, während du gehst Also für die Bewegungsgeschwindigkeit und die anderen beiden, die
wir angezeigt haben, wollen
wir hier auch
diese Option wählen, nämlich beim Spawn anzeigen
im Detailbereich Also müssen wir das
für jeden von ihnen tun, also schnappen Sie sich Ihre Variable und
kreuzen Sie dann die Option Expose on Span an Ich würde vorschlagen, dass es
diese Eigenschaft einfach verfügbar macht , wenn wir
diese Klasse irgendwo erzeugen Es ist auch sehr wichtig, dass
wir sicherstellen müssen, dass wir in
der
Projektilklasse kompilieren und speichern Andernfalls werden wir das
nicht sehen, wenn wir zu
unserer Flugzeugbasis zurückkehren nicht sehen, wenn wir zu
unserer Flugzeugbasis Und Sie können jetzt sehen, dass der
Hauptgrund, warum wir das wollten, darin
besteht, dass wir ausdrücklich
die
BP-Unterstrich-Projektilbasis und
nicht einen generischen Akteur verwenden werden die
BP-Unterstrich-Projektilbasis und nicht einen generischen Wir haben diese
Eigenschaften jetzt veröffentlicht, was wirklich nützlich ist Das gibt uns die
Möglichkeit,
die Farbe basierend auf
der Klasse, in der wir das spawnen
werden,
sowie der Bewegungsgeschwindigkeit,
der Emissionsstärke
und ähnlichen Dingen zu ändern die Farbe basierend auf der Klasse, in der wir das spawnen
werden, sowie der Bewegungsgeschwindigkeit,
der ,
je nachdem, wie du es möchtest. Mit deinen Projektilklassen. In der Basisklasse ist das alles
einmal erledigt. Wir möchten, dass dies
leicht wiederverwendbar ohne dass
Sie sich mit dem Code befassen Also werden wir diese magischen Zahlen natürlich nicht verlassen Stattdessen werden wir jede
dieser Variablen zu einer Variablen heraufstufen. Wir werden die erste Stufe
heraufstufen und
diese eine
Projektilbewegungsgeschwindigkeit nennen diese eine
Projektilbewegungsgeschwindigkeit Und dann werden wir natürlich dasselbe
tun. Wir werden die
Projektilfarbe
und die Emissionsstärke der Projektile auf
ihre eigenen Eigenschaften anpassen . Und
das ist alles startklar Das bedeutet, dass wir
diese eine wiederverwendbare Funktion jetzt sowohl
in der Spielerebene
als auch im Spielerfeind haben können diese eine wiederverwendbare Funktion , und alles, was wir für jede Klasse anpassen müssen , ist, wie schnell sich die
Projektile bewegen sollen Ich erinnere mich, dass in
dem Beispielprojekt der Feind
langsamer abgefeuert wird als der Spieler, und wir können die Farbe ändern,
je nachdem, wer
das Projektil spawnt. Das bedeutet, dass wir nicht viele verschiedene
Arten
von spezifischen Projektilen benötigen von spezifischen Wir können einfach unsere
Projektilbasis nehmen und einige wirklich
einfache rudimentäre Änderungen pro
Flugzeug vornehmen Flugzeug Die eine wirklich wichtige
Sache, bevor wir von hier aufbrechen, dass wir bei
der Kollision, die wir hier machen, an die Funktionalität
denken ,
wo wir sagen, wenn wir uns
im Moment überschneiden, unser eigener Besitzer, dann
wollen wir keinem Schaden zufügen. Wir müssen sicherstellen, dass die
Sache, die die Klasse hervorbringt, was wir jetzt auf
der Flugzeugbasis tun, tatsächlich die Information darüber
weitergibt, wer
der Besitzer ist Information darüber
weitergibt, wer
der Besitzer Eine weitere Sache
, die wir hier im Spawn-Akteur
auf der Flugzeugbasis
angeben können hier im Spawn-Akteur
auf der , ist
der Besitzer einfach Also, nett und einfach, wir
können an dieser Stecknadel ziehen
und nach einer G-Referenz
suchen, um sie zu verkaufen Oder Sie geben einfach
das Wort Zelle ein und Sie werden sehen, dass Sie hier einen
Verweis auf sich selbst erhalten. Damit stellen wir jetzt
nur sicher, dass
das Flugzeug, das
dieses Projektil erzeugt, wenn
diese Funktion aufgerufen wird, sich selbst als
Besitzer des Projektils kennzeichnet und
sicherstellt, dass es sich selbst keinen So sauber und sauber,
wir können zuschlagen und stapeln, speichern und schon kann es losgehen Wir sind jetzt also an einem guten
Punkt angelangt, an dem wir
die vereinfachte
Version von Schießen hinzufügen können , was unsere feindliche Klasse
sein wird Bevor wir das tun, denke ich,
gibt es noch eine weitere Variable die beide Klassen nutzen
können, und das ist die
Feuerrate, also wie oft das Flugzeug feuern kann Also werden wir hier unten eine neue
Variable erstellen. Der erste wird
vom Flugtyp sein, also drücken Sie auf einem der
anderen Flüge Control ID, und ich nenne diesen einen
Feuerrate. Es kompiliert. Ich denke, nur um
sicherzugehen, dass wir nicht vergessen, das später einzustellen
, werde
ich es einfach auf Null setzen, und wir werden sicherstellen
, dass wir das für jede Ebene ändern und wir werden sicherstellen
, dass wir das für jede Ebene ändern
. Und die andere Sache
, von der ich denke, dass sie
später in unseren beiden Klassen sehr nützlich sein wird, ist ein Vektor zwei D für die minimale und
maximale Feuerrate. Wir haben also eine gewisse Randomisierung. Also werde ich eine neue
Variable erstellen. Wir wollen, dass das wieder ein Vektor zwei D ist. Aber vorerst nennen
wir das einfach maximale Feuerrate von einer Minute. Wir wollen den Vektor zwei
D, den wir zuvor hatten, und auch hier können wir
diese vorerst bei Null belassen. Wir werden später zurückkommen und diese
ändern. Und dies ist einer der Fälle
, in denen wir viele
ähnliche Variablen
für ein System erhalten . Deshalb möchten wir sie vielleicht in
eine Kategorie einteilen, speziell für Projektile oder Kämpfe oder was auch immer
Sie möchten Wir könnten auch
eine Gesundheitskategorie oder so
etwas haben eine Gesundheitskategorie oder so
etwas Wie ich bereits erwähnt habe, werde ich das nicht
weiter auf dem Bildschirm machen, da es nur eine anstrengende
Arbeit im Hintergrund ist, aber es könnte definitiv
helfen, da wir
viel mehr Variablen bekommen , wenn
wir die Klassen einzeln
herausbringen. Das ist
aber in Ordnung. Das ist gut für einen Basisarbeitspunkt, also können wir jetzt in
unsere feindliche Klasse gehen, also gehen wir in den Kern. Spielt Feind und wir wollen zu Beginn des Spiels eine Sequenz
erstellen. Der Grund dafür
ist, dass wir jetzt eine
Art schlammige Logik bekommen eine
Art schlammige Logik Wir machen ein paar
verschiedene Dinge bei der Initialisierung unserer Klasse, was völlig in Ordnung ist, aber wir können die Dinge einfach wieder aufräumen Ein schneller Trick dabei
ist, dass wir
den Ausführungs-Pin nach dem übergeordneten Aufruf und dazwischen
das,
was wir bereits tun, abziehen können den Ausführungs-Pin nach dem , und wir rufen hier einen
Sequenzknoten Und das verbindet
automatisch die Logik, die wir haben,
ohne etwas davon zu unterbrechen also ist Null im Grunde
unsere Initialisierung für
die generische Randomisierung Wir könnten also einen Kommentar haben, der
besagt, Werte hier randomisieren. Dann werden
wir als Nächstes unsere Feuerdaten einrichten wollen unsere Feuerdaten einrichten In der Tat wird dies also
immer noch auf gewissen Grad an
Randomisierung
basieren Also
klicke ich mit der rechten Maustaste und erhalte
die Eigenschaft Feuerrate Also wollen wir hier
die Feuerrate festlegen, und sie wird wieder
auf einen zufälligen Float in der Reichweite gesetzt . Wir stecken das ein, und
dieser zufällige Float ist natürlich der Minmax, den
wir gerade erstellt haben Also ermitteln wir die
Min-Maximal-Feuerrate, teilen den
Struktur-Pin auf, wie wir es
zuvor gemacht haben , und stecken sie hier Also Minimum, Maximum
für das X und das Y. Also noch eine nette, einfache
Randomisierung, sodass nicht
jeder Feind mit exakt der gleichen
Geschwindigkeit feuert, und es wird sonst sehr
repetitiv und langweilig aussehen repetitiv und langweilig Wenn wir auf Kompilieren klicken, wollen wir
nur sichergehen, dass auch für
die gegnerische Klasse eine
Minimax-Feuerrate festlegen, die meiner Meinung nach vielleicht irgendwo
zwischen Auch hier kannst du all
diese Werte nach Belieben anpassen, und dann wird die
Feuerrate
speziell zwischen diesem Bereich eingestellt speziell zwischen diesem Bereich Dann, ausgehend von der zweiten Ausgabe und jetzt, wo wir unsere
Randomisierung durchgeführt haben, können
wir tatsächlich damit beginnen,
die Feuerfunktion so einzurichten , dass sie aufgerufen werden
soll Also werden wir wieder den Timer
nach Funktionsnamen einstellen
verwenden ,
wir ziehen von hier aus. Wir werden den eingestellten
Timer anhand des Funktionsnamens verwenden. Natürlich werden wir die Feuerfunktion
aufrufen. Das haben wir
in unserer Basisklasse erstellt, und die Zeit wird
unsere Feuerrate sein. Also werden wir die Feuerrate ermitteln, die
wir gerade zufällig ausgewählt haben, und wir werden sicherstellen, dass sie auf Looping eingestellt
ist Das wird also so lange
gefordert , wie der
Feind im Spiel ist Die Randomisierung stellt sicher, dass jeder Feind mit seiner
eigenen zufälligen Geschwindigkeit feuert Einige werden etwas
aggressiver und andere gemächlicher Eine weitere Sache für die Gegner ist, dass,
wenn sie vom Bildschirm
fliegen und der Spieler sie verfehlt, wie bei den Projektilen, sie sich auch selbst
reinigen sollten Also gehen
wir zur Projektilklasse über, und ich werde hier die exakte
Logik der Grenzüberschreitungen anwenden. Wir können das alles kopieren, Strg NC
drücken und zurück
in die feindliche Klasse gehen Wir werden eine neue
Funktion erstellen. Nochmals, wir werden das einfach als
Out-of-Bounds-Check bezeichnen Und wir fügen das hier einfach
in die Grafik ein. Also ein bisschen Vervielfältigung. Und auch hier
könnten Sie anfangen, Dinge
wie die Verwendung von
Komponenten in Betracht wie die Verwendung von zu ziehen, wäre hier eine
wertvolle Sache. Wenn Sie sich
mehr mit
der Programmierung beschäftigen, werden Sie vielleicht feststellen , dass das Konzept oft auf Vererbung
statt auf Zusammensetzung Bezug genommen wird Komponenten wie diese verwendet werden. Ein bisschen außerhalb des Geltungsbereichs dieses wirklich einführenden Systems. Bei einigen Dingen werden wir die geringfügige Abkürzung
nehmen, aber das ist immer noch kein schlechter
Ansatz, nur ein kleines bisschen Doppelarbeit Aber die
Out-of-Band-Checkvariable hier, die wir aus der anderen Klasse
kopiert haben die wir aus der anderen Klasse
kopiert , existiert hier
offensichtlich nicht, also klicken
wir mit der
rechten Maustaste und erstellen eine Variable Und bei dieser haben wir
einfach auf Compile geklickt. Wir werden den Standort
des Feindes
von der Kamera aus überprüfen . Für die Entfernung außerhalb der Grenzen können
wir einen ähnlichen Wert verwenden Ich denke, 3.500 hat ziemlich gut
funktioniert. Wir wollen nur
sichergehen, dass wir Feinde im
Auge behalten , die den Spielbereich
verlassen, und wenn wir bemerken
, dass sie einfach verschwinden, möchten
wir
das vielleicht irgendwie anpassen Jetzt, wo das fertig ist
, wollen wir zurück zu unserem Event-Graph
gehen Vielleicht möchten wir anfangen, die
Dinge ein wenig aufzuräumen und Dinge
einfach zu verschieben
, um uns Raum zu verschaffen Die Hauptsache dabei ist, dass wir hier ein anderes Mal
einrichten könnten, also könnte das unsere Logik sein, um die wiederkehrenden
Funktionen
einzurichten Also erstellen wir ein weiteres TO nach dem
Funktionsnamen für dieses. Das wird unsere
Grenzüberschreitung sein,
und wir sollten
das vielleicht einmal pro Sekunde machen Also legen wir hier eine Zeit fest,
aber einmal pro Sekunde. Wir werden das auf
variabel hochstufen. Und ich werde diesen so einstellen, dass er außerhalb
der Gültigkeitsdauer aufgerufen wird Wie zuvor klicken wir auf Compile. Wir wollen sichergehen, dass
wir dem einen Wert geben, so dass es die 1 Sekunde hat, und wir setzen das auf
Looping, also läuft es kontinuierlich, bis es aus dem Spiel entfernt
wird So wie ich es in
der Vergangenheit auch getan habe. Ich glaube, ich werde
hier klicken und die Feuerfunktion finden. Also werden wir einfach
FireFunction aufrufen. Wir
werden es nicht wirklich benutzen. Es ist nur so, dass wir, wenn
wir noch einmal überprüfen wollen was in
dieser Funktion passiert, einfach hier doppelklicken können. Ich werde den Sperrscheck machen, den Namen herausfinden
und sicherstellen, dass wir ihn in
unserer Zeit hier drüben
ausfüllen und ihn dann einfach wieder aus demselben
Grund ziehen Nur für den Fall, dass ich
sehen möchte, was passiert, kann
ich einfach doppelklicken
und den Code genau sehen Wie ich bereits erwähnt habe, nur
eine persönliche Präferenz, aber etwas, das ich immer
in meinem eigenen Code mache. Eine letzte Sache, glaube ich, haben wir
vergessen, weil wir ein bisschen die Projektilklassen
getauscht haben.
Wenn wir zu der Basisklasse zurückkehren, in der wir
die Feuerfunktion implementiert haben,
wenn wir hier unsere
Projektilklasse nehmen, können
wir sehen, dass die
Klasse auf „Keine“ gesetzt ist Wenn wir das jetzt versuchen würden,
würden wir keinen
der Gegner dazu bringen, etwas
abzufeuern,
weil ihnen nicht die spezifische Klasse zugewiesen wurde,
die sie
abfeuern sollen etwas
abzufeuern,
weil ihnen nicht die spezifische Klasse zugewiesen wurde,
die sie abfeuern Im Moment haben
wir also nur eine,
nämlich die Basisklasse. Aber wenn wir daraus einige
untergeordnete Klassen machen würden, könnten
wir auch diese
einzigartigen Versionen verwenden. Also haben wir das als Standard Projektilbasis gesetzt,
weil das im Moment das Einzige ist,
womit wir arbeiten müssen Klicken Sie auf Kompilieren und Speichern.
Und dann wirst du beim Feind
sehen, dass sich Dine
automatisch verbreitet Also haben wir hier auch die
Projektilklasse eingestellt. Drücken Sie auf Kompilieren und Speichern und wir
können den feindlichen Schießvorgang verschachteln. Also nichts besonders ausgefallenes,
aber sie sind es in der Tat. wir feuern, können wir
sehen, dass wir das mit unterschiedlichen Geschwindigkeiten und
Geschwindigkeiten erreichen. Wir haben also ein etwas
einzigartiges Gameplay von
den verschiedenen Feinden. Wir sollten auch dafür sorgen, dass nach einer bestimmten Anzahl von Treffern Spieler
nach einer bestimmten Anzahl von Treffern aus dem Spiel
entfernt wird, sodass der Schaden automatisch
wirksam wird. Wir haben also dafür gesorgt, dass alles so funktioniert, wie es beabsichtigt ist, zumindest für die feindliche
Klasse, was großartig ist. Das Letzte, was mir
da auffällt, ist, dass es wahrscheinlich ein bisschen
schnell
gehen wird, und das ist in Ordnung. diesem Grund haben wir festgelegt, dass all diese Werte veröffentlicht werden, sodass sie leicht angepasst und
geändert werden können, basierend auf Spieltests, Feedback und dem allgemeinen Spielfeld,
das Sie möglicherweise anstreben Ich denke also, dass
wir beim Feind
seine Projektile
nur ein
bisschen verlangsamen seine Projektile
nur ein
bisschen werden, weil es viele davon
geben wird Der Spieler
möchte wahrscheinlich schneller feuern, und die Gegner können
etwas entspannter sein Also setzen wir das auf
etwa 1.500. Und wenn wir das Gefühl haben, dass das zu langsam ist. Also wähle ich
hier in der feindlichen Klasse die Geschwindigkeit der
Projektilbewegung aus
und
reduziere sie auf 1.500 Wir können auch die Farbe ändern. Meine Feinde sind also grün.
Ich werde mir eine Farbe holen, die dem feindlichen Stil hier etwas näher kommt
. Du solltest in der Lage sein, den Farbwähler zu
benutzen damit wir in die Farbe gehen können, den Farbwähler
holen und du kannst auch auf den Teil
der Ebene klicken , der der Farbe entsprechen
soll Für mich funktioniert das nicht. Das ist
die Auswahl des statischen Matches. Also nehme ich einfach eine Farbe, die
dem Flugzeugkörper
ungefähr ähnlich ist . Das wäre völlig
in Ordnung, denke ich. Wenn
wir also wieder auf Kompilieren klicken, bewegen sich Projektile mit unterschiedlichen
Geschwindigkeiten, und sie
repräsentieren tatsächlich die Farbe des Schiffes, das
sie abfeuert Sie können auch Dinge
wie die Emissionsstärke ändern ,
wenn Sie nicht möchten, dass sie leuchten oder wenn Sie möchten, dass
sie mehr oder weniger leuchten Aber das ist alles. Das sind also
die Feinde, die eingerichtet und erledigt sind. Nur eine kleine Nebenaufgabe für dich Pausiere den Inhalt
zwischen den Themen erneut
und fange vielleicht an, dir
verschiedene Variablen anzusehen , von
denen du denkst, dass für die minimale
und maximale Feuerrate funktionieren
könnten. Vielleicht spürst du nicht
genug Unterschied zwischen den verschiedenen
Gegnern, wenn sie erscheinen. Vielleicht änderst du die Farbe, die verschiedenen Arten
der Bewegungsgeschwindigkeit, den verursachten Schaden,
enthülle andere Variablen, spiele mit
all den Werten herum, von denen du jetzt weißt, dass
du Zugriff darauf hast Als Nächstes werfen wir einen Blick auf die Funktion „Spielerfeuer“. Es wird
etwas anders sein, ein bisschen praxisorientierter,
aber ihr seht, dass wir
bereits über eine wirklich
gute Grundlage verfügen, auf aber ihr seht, dass wir
bereits über eine wirklich
gute Grundlage verfügen der wir aufbauen können.
22. 21 - ProjectileFire-Spieler: Kann jetzt direkt
dazu übergehen,
den Spieler auf
ähnliche Weise wie der Feind zu feuern Wir werden also einen
Teil dieser Basislogik,
die
Eigenschaften der freiliegenden Projektile, wiederverwenden die
Eigenschaften der freiliegenden Projektile, und eine etwas
verfeinerte
Kontrolle darüber haben , ob und wann der
Spieler schießen soll Wenn wir also reingehen und den Player
BP Underscore Plane öffnen , haben
wir hier zwei verschiedene
Optionen Zum einen könnten viele
Leute die Kernfunktionen außerhalb
von Funktionen einfach in ihren
Hauptereignisgraphen ablegen Kernfunktionen außerhalb von Funktionen einfach in ihren
Hauptereignisgraphen Ich
wollte aber noch etwas anderes vorstellen, ist dass wir unsere
eigenen benutzerdefinierten Diagramme erstellen können. Das Standardereignisdiagramm
enthält also Dinge
wie Begin Play, Eventi, diese
Dinge,
die
standardmäßig in
die Engine integriert sind. Vollkommen in Ordnung Eine Sache, die ich sehr gerne
mache, ist, dass wir hier
diese Plus-Taste drücken können und wir können ein völlig neues Diagramm
erstellen. Ich werde den Namen
dieser neuen Grafikeingabe angeben. Und hier werden
wir unsere gesamte Logik einsetzen, die
speziell auf dem Empfang von Eingaben für den Spieler basiert. Also haben wir später wieder angefangen, Dinge
hinzuzufügen, wie eine Neustarttaste oder eine Menütaste oder verschiedene
Arten von Power-Ups und so.
All diese Eingaben
könnten
hier an einem schönen, praktischen Ort verfolgt werden . Um die
Feuereingabe zu registrieren, werden
wir endlich ein Eingabeereignis
verwenden. Wir haben also bisher
nur
die Variablen verwendet , die in Dingen wie
dem IA-Unterstrich in
unserer Handle-Bewegung
gespeichert sind dem IA-Unterstrich in , die
wir hier gesehen haben. Das ist also unser Beispiel nur den zurückgegebenen
Float-Wert
verwenden Innerhalb des Eingabediagramms klicken
wir mit der rechten Maustaste und suchen nach IA underscore Fire Und wir sehen, dass wir hier
die Option haben, wir wollen
dieses Ereignis, das zurückgegeben wird, tatsächlich nutzen dieses Ereignis, das zurückgegeben wird, Wenn also der
Feuerknopf gedrückt wird, können
wir bewirken,
dass aufgrund des ausgelösten Ergebnisses
der empfangenen Eingabe etwas
passiert . Das Erste, was
wir immer in
Betracht ziehen wollen , ist, dass wir
sofort Feedback haben wollen, was eher dem Spieldesign
und
der Theorie entspricht,
ist, dass der Spieler, wenn er etwas
drückt, Erwartung hat, sofort
Feedback zu erhalten. Es gibt keine Verzögerung zwischen dem Drücken
von etwas
und dem, was passiert. Aus diesem Grund wollen
wir sicherstellen, dass
etwas passiert,
sobald die Eingabe eingegangen ist . Wir haben also eine Menge
verschiedener Ereignisse,
die hier ausgelöst werden, und wir wollen
zunächst einmal von Started Gebrauch machen. Wir wollen also sicherstellen
, dass die Feuerfunktion sofort beim Start aufgerufen
wird. Wir werden hier die
Feuerfunktion aus unserer übergeordneten Klasse
aufrufen . Wir können sehen, dass dies
die Basisklasse ist. Started wird
sofort aufgerufen
, sobald der Tastendruck erkannt wird und der
Befehl abgeschlossen wird
ausgelöst , sobald die
Taste losgelassen wird. Wir können also diese verschiedenen
Phasen
des Tastendrucks nutzen , aber das
Wichtigste ist vorerst, dass sofort
Feuer ausgelöst wird. Nachdem die erste
Auslösefunktion aufgerufen wurde, ziehen
wir
vom Ausführungspin und
setzen einen weiteren Timer anhand des Funktionsnamens. Die Funktion
wird natürlich Feuer sein. Hauptsächlich nur aus Gewohnheit hier. Ich werde einfach
die Feuerfunktion duplizieren , die wir
bereits haben, und wieder setze
ich sie einfach
unter den Timer ,
weil wir wissen, dass wir das hier verwenden. Die Zeit
dazwischen
ziehen wir von hier aus und ich werde
unsere Feuerrate ermitteln. Also werden wir den Wert für
die Feuerrate ermitteln. Und ich denke, für den
Spieler, obwohl ich gesagt habe, wir vielleicht die Randomisierung
in Betracht ziehen sollten, ist
das jetzt wieder so eine Sache, wenn man Dinge
eher von einem Designprinzip aus Wir
wollen das wahrscheinlich festlegen,
anstatt ein
Minimum und ein Maximum festzulegen.
Der Spieler wird erwarten, dass Feuerrate bei
jedem Schuss und jedes
Mal, wenn er das Spiel spielt, seine Feuerrate bei
jedem Schuss und jedes
Mal, wenn er das Spiel spielt, dieselbe sein
sollte Es sei denn, du machst so
etwas wie einen Roguec, bei dem
du dem Spieler ausdrücklich sagst, dass die Feuerrate aufgrund deines Charakters oder zufälliger Statistiken deines Charakters oder zufälliger Statistiken unterschiedlich sein kann Bei dieser Art von Spiel erwarten
sie, dass es
sich immer gleich anfühlt, sodass
sie sich an die Mechanik gewöhnen und
lernen können , wie man spielt Wenn wir also auf Kompilieren klicken, nehmen wir die Feuerrate und
setzen sie auf 0,2. Wir werden dafür sorgen, dass wir es auf Looping
setzen. Wir
sagen also im Grunde, dass wir Feuer drücken, und wenn Sie dann die Taste
gedrückt halten, rufen
wir
diese Funktion auf,
sodass Sie weiter feuern, wenn
Sie gedrückt halten Dann können wir
wieder hierher zurückkehren und diese
fertige Funktion
jetzt nutzen. Wie ich bereits erwähnt habe, wird
dies aufgerufen wenn Sie die Taste loslassen
, die Sie gedrückt halten. also fertig sind,
können wir tatsächlich einen
anderen Teil der eingebauten
Time-of-Funktionalität nutzen , und das ist eine wirklich nette Art Ihren Code
wieder sauber und aufgeräumt
zu halten Sie haben vielleicht in anderen
Beispielen gesehen, dass dies
mit einigen Verzögerungen
auf die Eventik geworfen wurde , was sehr verwirrend sein kann,
wenn Sie darüber nachdenken, eine
Eventik und eine Verzögerung
zusammen auszuführen Eventik und eine Verzögerung , im Wesentlichen Logik zu
kombinieren, die dazu gedacht ist,
ständig in einem bestimmten Intervall zu laufen, und dann auch
zu versuchen, dies zu verzögern, während sie ständig ausgeführt wird. Also werden wir solchen
schlampigen Code vermeiden. Wir werden stattdessen
eine Funktion namens Clear
Tir anhand des Funktionsnamens finden eine Funktion namens Clear
Tir anhand des Funktionsnamens Also werden wir diese Funktion hier verwenden, und das ist wirklich
nett und einfach. Wir holen uns hier
unseren Feuernamen, also holen wir uns den Text hier und
fügen ihn dann hier ein. Wir haben jetzt also die
vollständige Kontrolle darüber , wann das angefangen hat
und wann es endet. wir also zum ersten Mal den Feuerknopf
drücken, rufen
wir
die Feuerfunktion auf. Wir werden dann auch
sicherstellen, dass wir uns daran erinnern solange wir die Taste
gedrückt halten Aber wenn wir jemals
wollen, dass das aufhört, werden wir, sobald wir erkennen, dass die
Taste losgelassen wurde, diesen Funktionsnamen löschen, also diese Timer-Funktion Also wird es das finden, weil sie
den gleichen Namen haben. Es wird
das Looping hier abbrechen
und das bedeutet, dass wir
nicht mehr feuern werden Wir haben also nicht überall Kabel
,
Dinge, die versuchen,
sich beim Event aufzuheben. Es ist nur ein einziges Feuerereignis, und wir fügen nur alle 0,2 Sekunden einen
Stapel hinzu. Rufen Sie eine wirklich einfache Funktion auf. Also nochmal, sehr geringer Overhead, sehr gut für die
Leistung, sehr sauber zu lesen und viel
einfacher zu verwalten. Und was den Spieler angeht
, bleiben hier nur ein
paar Dinge übrig. Die Feuerfunktion
ist also relativ einfach. Wir wollen
hier nur auf die Klassendetails
eingehen und einige
ähnliche
Änderungen vornehmen wie zuvor. Ich denke also, dass die Geschwindigkeit der
Projektilbewegung 2.500 für den Spieler in Ordnung ist Das Emissionsmittel zu lassen
ist völlig in Ordnung. Und wir werden einfach
die Farbe ändern. Meine Spieler haben
eine bläuliche Farbe, also gehen wir.
Damit gerade hier. Vielleicht versuche,
das ein bisschen besser abzugleichen. Wie ich bereits erwähnt habe, können
Sie auf Ihrem System möglicherweise
mit dem Farbwähler durchkommen Aber für mich ist das
nur die Auswahl von Schwarz. Also werde ich das einfach manueller einstellen
. Wir können dann auf Kompilieren, Speichern klicken und dann können wir reingehen
und das Ganze testen. Da hast du's. Der Spieler
hat also kontinuierliches Feedback zum Drücken der Taste. Dies wiederholt sich kontinuierlich, bis wir
den Feuerknopf loslassen Also, wie ich schon erwähnt habe,
wirklich nett und sauber. Wenn du es
noch nicht gesehen hast, werde ich keine speziellen Tutorials
finden, um sie aufzurufen, aber schau auf YouTube etwas
wie Unreal Engine,
Blueprint Fire Functionality
oder Gunfire Logic, so
etwas Generisches
und sieh dir das Ergebnis an, das du bekommst Haltet Ausschau nach
solchen, die euch
in die Eventi bringen, und lasst einige Verzögerungen
aufgrund der Feuerrate ausgleichen und seht, wie sie
Dinge wie Tore verwenden, um
das Aufrufen
der Feuerfunktion zu unterbinden, wenn eine Taste
gedrückt oder losgelassen wird. Und dann vergleichen Sie das mit dem, was
wir hier gerade gemacht haben, mit zwei wirklich einfachen Aufrufen, um die Funktion zu starten und
die Funktion im Laufe
der Zeit zu beenden Wie ich bereits erwähnt habe, bei den epischen Beispielen
und
so weiter nicht darum, andere Leute oder Projekte herauszufordern Explizit. Mcde ist definitiv
nicht immer der beste, aber es dient nur dazu,
Sie zum Nachdenken anzuregen und tatsächlich zu kritisieren,
was Sie sehen, während Sie lernen, denn
eines der schlimmsten Dinge
, die Sie tun können, ist einfach
alles blind zu verfolgen und einfach anzunehmen, dass es immer
der beste oder einzige Ansatz ist Es wird immer verschiedene Möglichkeiten geben, ein Problem
anzugehen, und ich möchte Sie nur dazu
bringen,
darüber nachzudenken , ob das, was Sie in Ihren Projekten
tun oder was Sie online sehen,
eine Möglichkeit ist , die Sie in
Ihre eigenen Projekte implementieren möchten , um sie überschaubar und
einfach zu handhaben. Das ist so ziemlich
alles für Projektile. Stellen Sie auch hier
sicher, dass Sie
überprüfen , ob alles mit den genauen Werten
gefüllt
ist , wenn
Sie zusätzliche Schritte zur Verbesserung Ihres Projekts Ich werde es mit dem
Beispielprojekt gleichsetzen ,
aber wir haben Probleme, die vielleicht nicht
sofort erkennbar sind, aber
sie sind definitiv da Zum Beispiel können wir Spam
tatsächlich schneller auf
die Feuerknopf klicken als die Feuerrate Das ist wirklich schwierig, weil
ich
die Feuerrate sowieso relativ
schnell eingestellt habe , aber Sie können sehen, dass
ich hier
schneller klicke , als wenn ich einfach gedrückt halten
würde. Überlegen Sie sich also
vielleicht, wie Sie das selbst beheben könnten. Ich werde diesen Prozess nicht
durchlaufen. Es
würde im Wesentlichen darum gehen, einen Wert auf
einem
separaten Timer zu verfolgen Wert auf
einem , wenn Sie die Taste
zum ersten Mal drücken. Sie das nächste Mal die Taste
drücken, wenn dieser niedriger als
die eingestellte Feuerrate ist, dann würden Sie den
Aufruf der Feuerfunktion einfach abbrechen. In diesem Fall ist es kein
so komplexes Projekt , dass ich wirklich denke, dass
es einen großen Unterschied macht. Und wie ich bereits erwähnt habe, ist
dieselbe Funktionalität in dem Beispielprojekt enthalten, mit dem wir sowieso
versuchen , die Parität Aber es ist einfach eine nette Art von Gedankenübung, um zu sehen, ob du darüber nachdenken
kannst, wie du eine ähnliche Logik
einbauen könntest,
aber den Spieler
daran hindern würdest , schneller zu klicken und zu
schießen als
die angegebene Feuerrate Unsere wichtigsten nächsten Schritte sind jedoch,
dass die Schiffe bewaffnet sind. Der Spieler und die
Feinde feuern beide, beide mit unterschiedlichen Farben und
unterschiedlichen Feuerraten. Sie können diese
Werte auch erneut anpassen. Wenn du feststellst, dass das
Spiel zu schwer oder zu einfach ist, ändere Dinge wie den Schaden, auf der Grundlage angewendet wird von
wo die Projektile
abgefeuert wurden, die Feuerraten und solche
Dinge Als Nächstes werden wir
wieder unseren generischen Actor-Spawner verwenden unseren generischen Actor-Spawner Und ich werde anfangen, einige Scroll-Hintergründe hinzuzufügen einige Scroll-Hintergründe , damit die Dinge für uns ein
bisschen interessanter aussehen bisschen
23. 22 - Scrollende Hintergründe: Es ist an der Zeit, dieses
Projekt ein bisschen weiter voranzutreiben und
es tatsächlich wie ein Spiel aussehen zu lassen Wir werden etwas Wasser hinzufügen,
einige scrollende Inseln,
und das tun wir, indem wir unser Spanus-System
wiederverwenden,
weshalb wir es so gebaut haben, dass ein so
generisches Setup Wir können jeden Kurs,
den wir
momentan haben, beenden Kurs,
den wir
momentan haben Klicken Sie mit der rechten Maustaste auf den Haupt-Tab und wählen Sie,
ob Sie andere Tabs schließen . Dadurch wird
alles gelöscht, in dem Sie sich
gerade nicht befinden , und dann
können wir den Player einfach schließen. Zurück in der Hauptansicht
wollen wir genau hier die
Schaltfläche Hinzufügen verwenden, und wir werden eine einfache Ebene
hinzufügen. Wenn wir also zu Formen gehen
und eine Ebene finden, wollen wir
nur, dass es
sich um eine ebene Fläche handelt. Wir
setzen die Position zurück,
also setzen wir sie auf Null,
indem wir genau hier auf die
Schaltfläche „Rückgängig“ klicken. Drücken Sie die Sperrtaste, um sicherzustellen, dass dies gleichmäßig
skaliert, und dann setzen wir
den Wert einfach auf etwa 80,
um sicherzustellen, dass wir
die gesamte Spielzone abdecken,
also alles, was wir sehen können Wir können den Boden auch
loswerden. Wir haben das bisher nur für den
Kontext
verwendet , damit wir
genau sehen können , wohin und
wann wir uns bewegen. Wir verwenden dieses Raster
hauptsächlich, um Bewegungen zu erkennen. Wir werden das nicht mehr brauchen,
also können wir
den tatsächlichen Standort
des Flugzeugs selbst loswerden . Wir wollen, dass das
Minus 4.000 auf Z ist. Und auch hier hängt es nur davon ab, wie ich meine Kamera eingerichtet habe, das Flugzeug und die feindlichen Standorte. Du wirst vielleicht feststellen, dass dein Level
ein etwas anderes Setup hat, aber wenn wir
vorerst von einem
ungefähr ähnlichen Projekt ausgehen, kannst du das später
anpassen Wenn wir so weit unten sind, bleiben die Schatten etwas
subtiler und wir haben Platz für die schwebenden
Inseln, weil einige der Objekte,
die ich zur Verfügung gestellt habe, absichtlich ziemlich groß
sind Vom Ordner aus gehen wir
zu unserem Assets-Ordner. Wir finden die Materialien
und wir können
den MI-Unterstrich Wasser finden den MI-Unterstrich Wasser und ihn einfach
ins Flugzeug ziehen Das wird
uns also ein nettes, einfaches, grundlegendes animiertes Wassermaterial Wie ich bereits erwähnt habe, müssen
hier möglicherweise
einige Details und Eigenschaften geändert werden, wie die Größe des
Flugzeugs oder der Standort. Sobald wir am Ende des Themas
angelangt sind, führen
wir jedoch eine vollständige Überprüfung und Verfeinerung am Ende des Themas
angelangt sind, führen
wir jedoch eine vollständige Überprüfung durch,
je nachdem, wie
die Dinge aussehen Wenn Sie Ihr Wasser erneut ändern
möchten, können
wir erneut auf den
MI-Unterstrich Wassermaterial doppelklicken Ziehe das hier in das Fenster. Das ist eine nette
Möglichkeit, die
Material-Instanz noch einmal zu nutzen. Wenn du feststellst, dass fließendes Wasser zu schnell
war oder dir die Farbe
nicht gefallen hat, können
wir dieses Live-Feedback
auch während des Spiels erhalten um genau zu sehen,
was
du mit Dingen wie
dem Tiefenverlust, der Entfernung, den verschiedenen Farbeigenschaften und ähnlichen
Dingen machen möchtest. So hast du die volle
Kontrolle darüber, wie
dein Wasser aussehen soll. Das werde ich so
lassen, wie es ist, aber nur um zu sagen
, dass diese Werte da
sind, falls
Sie sie anpassen möchten Als Nächstes wollen wir unsere Inseln
betrachten. Also gehen wir zurück
zu unserem Blueprints-Ordner. Wir werden hier einen neuen
Ordner erstellen. Wir werden diese eine Insel nennen. Innerhalb des Inselordners klicken
wir mit der
rechten Maustaste, gehen zur Blueprint-Klasse und
erstellen einen neuen Schauspieler Wir brauchen nur wieder etwas , das auf der Welt präsent ist, und wir nennen es
BP Underscore Island Innerhalb der Klasse, jetzt
ganz normal eingerichtet. Wir werden
ein neues statisches Netz hinzufügen. Wir legen dies als
Standard-Szenenstamm fest, also überschreiben wir hier den
Standard-Szenenstamm. Und wenn das statische
Netz ausgewählt ist, gehen
wir
zum Detailbereich. Wir werden den
SM-Unterstrich als Inselrunde finden, also die große, mit der
Sie beginnen können Wir können im Aussichtspunkt F drücken, um zu sehen, wie die
Insel aussehen würde Und dann wollen wir einfach
zu den Kollisionseigenschaften gehen zu den Kollisionseigenschaften und die
Kollisionsdetails hier aufnehmen Wir lassen das runter und
stellen es auf Kollisionsschutz ein. Wir werden die Option „Überlappungsereignisse
generieren“ ausschalten. Wir stellen nur sicher,
dass es keine physikalischen Daten gibt, es keine Überschneidungsprüfungen gibt. Das wird ein sehr
billiges Wegwerfobjekt sein,
das nur zur Veranschaulichung da ist Nun, bevor wir überhaupt anfangen, unseren Spawner zu benutzen, um sie auf die Welt zu bringen
, wissen
wir, dass das sehr repetitiv,
sehr langweilig aussehen
wird sehr Wir werden jedes
Mal dasselbe
statische Netz mit derselben Größe und derselben Rotation erhalten, wenn dieses Gehen wir zum Startspiel über und wir werden
das sofort lösen Ebenso
werden wir den Funktionsaufruf Actor Begin
Overlap loswerden Actor Begin
Overlap Wir wollen, dass der Startvorgang
hier ist, und wir können hier
einige einfache Dinge vom
Execution Pin aus tun . Zuallererst können
wir
die Skala des
Schauspielers ein wenig nach dem Zufallsprinzip die Skala des
Schauspielers ein wenig nach dem Zufallsprinzip Also nennen wir das Set
Actor Scale Three D. Und wir werden
das auf eine etwas seltsame Art und Weise machen Wenn wir aber mit der rechten Maustaste klicken und
nach einem zufälligen Float-in-Bereich suchen , können
wir diesen Bereich
erneut
auf der Grundlage eines Vektors von zwei D festlegen . Also
erstellen wir eine neue Variable. Wir nennen das
eine Min-Max-Skala. das nach unten fallen und suchen Sie den
Vektor zwei D. Er kompiliert und gibt hier
einige Werte für vielleicht etwa 0,8 bis 1,2 an. Geben Sie sie ein, wie
wir es zuvor getan haben. Sie können also sehen, dass wir wieder
an einem Punkt angelangt sind, an dem eine Menge Code sehr vertraut werden wird
. Und das ist die
Idee der Wiederholung. Wir werden dafür sorgen, dass Sie sich mit dem Projekt
und der Arbeit mit Unreal
wohler fühlen . Also teilen
wir die Struktur auf Wir setzen das in das
Minimum und das Maximum ein. Und wir können
hier einfach unseren Float-Wert
nehmen und ihn in einen Vektor umwandeln
. So wie das funktioniert, mag
es ein
bisschen seltsam aussehen , wie wir
einen Float oder einen Vektor verwenden. Ich werde
im Grunde nur sicherstellen,
dass X , Y und Z
das Ergebnis annehmen. Wenn hier also
1.1 ausgewählt wird, bedeutet
das, dass X, Y und Z
alle auf 1.1 gesetzt werden. Wenn Sie die Dinge
nun
in die Länge ziehen möchten , sollten Sie die Kontrolle verfeinern. Sie wissen natürlich, dass Sie den Struktur-Pin für
den Vektor aufteilen
können und vielleicht eine
zufällige Gleitkommazahl für X, Y und Z einzeln erstellen Das Problem, das ich dabei finde
, ist, dass Sie nicht wirklich genau kontrollieren können,
wie verhindern können, dass das Netz vollständig
ist Es kann sein, dass Sie am Ende
etwas haben, das wirklich seltsam und zerquetscht ist oder wirklich
seltsam und gestreckt Aus diesem Grund werde
ich es einfach einheitlich einstellen
,
also werden einfach alle
Achsen zusammen skaliert Dann können wir uns auch
unser statisches Netz schnappen. Wir fügen das in
das Event-Diagramm und nehmen hier
unsere Mesh-Referenz, also einen Verweis auf unsere Komponente, wir werden nach der Funktion
set static mesh suchen. Wir wollen diese
hier haben, die, die uns
die Mesh-Komponente gibt,
nur um sicherzugehen, dass Sie gesehen
haben, dass wir zu den Komponenten
Statisches Netz gehen und Statisches
Netz festlegen wollen . Nicht diesen hier. Dies aktualisiert tatsächlich
die Variable selbst, wohingegen die
Komponente, die wir haben, verwendet und über
unser Detailfenster hier
auf die Details zugreift. Also wollen wir vielleicht auch
das statische Netz, das
wir verwenden, zufällig anordnen Also können wir von
hier aus weitermachen. Sie haben wahrscheinlich eine Ahnung, wohin
das führt, denn auch hier haben
wir das
schon oft gemacht. Wir haben nur zwei verschiedene statische
Optionen für die Inseln Also werde ich einen ausgewählten Knoten
verwenden. Und weil wir nur
zwei haben, kann
ich mir das am einfachsten vorstellen,
wenn wir mehr hätten Vielleicht möchten
wir eine
zufällige Ganzzahl innerhalb eines Bereichs verwenden, und wenn wir fünf hätten, würden
wir einen Bereich von
0-4 oder eins, fünf, was auch immer wählen 0-4 oder eins, fünf, was auch immer Und je nachdem, was aus diesem
Ganzzahlbereich ausgewählt wurde , würde
es eines von vier
oder fünf verschiedenen Modellen auswählen Da wir nur zwei haben, verwende
ich einfach einen booleschen Ich werde hier einen
zufälligen Ball auswählen. Wir brauchen nicht einmal, dass
das eine Variable ist. Und dann
haben wir im Grunde eine 50-50-Chance, auf der großen
Insel oder der kleinen Insel zu
laichen Also, nett und einfach, wir müssen das
nicht zu komplex machen
, zumindest bekommen wir jetzt eine
gewisse Randomisierung Wir könnten dieselbe große
Insel dreimal hintereinander spawnen, aber zumindest wird der Maßstab auf jeder Insel etwas anders
sein Wenn nicht, dann wählen wir
vielleicht zufällig
zwischen der großen und
der kleinen Insel Und auch hier werden sie immer noch
eine
nette zufällige Skalierung anwenden Und dann werden
sie endlich alle immer noch gleich aussehen So können wir unsere
Rotationsdetails abrufen und
diese auch nach dem Zufallsprinzip sortieren Also ziehen wir aus
dem statischen Netz und ich werde
die festgelegte aktive Rotation finden diesem wollen wir uns nur
um die Z-Achse drehen ,
denn denken Sie
daran, das wird in der Welt nach oben
oder unten gehen. Also klicken wir mit der rechten Maustaste
und teilen die Struktur auf. Ich werde eigentlich nur ein bisschen faul sein und mir den zufälligen
Float in Reichweite schnappen. Dupliziere das hier,
wir
drehen es einfach um 0-360 Grad. Das ist also einer dieser Fälle, in
denen ich nicht glaube, dass es
irgendeinen Sinn hat , das tatsächlich
zu einer Variablen Ich denke, das ist ziemlich klar.
Wenn wir uns etwas ansehen, legen wir die Rotation der
Schauspieler fest und wir gehen von 0 bis 360, also das ist
offensichtlich, dass wir eine vollständige Rotation zulassen Ich würde also nicht wirklich empfehlen,
dies auf eine Variable hochzustufen Manche Dinge können
als magische Zahl in Ordnung sein, zumal wir
wissen, dass wir
das nicht aktualisieren oder optimieren werden. Ich kann mir keinen Grund
vorstellen, dass
wir das auf eine
andere festlegen wollen Wenn wir das
auf eine Variable hochstufen
, bedeutet das, dass wir nicht wieder in den Code
zurückkehren müssen. Und wenn wir
die Skala
komplett ändern wollten , ohne den Code selbst zu
finden, könnten
wir ihn auf
0,4 oder 2,5 setzen oder was auch immer wir wollen
, um die Skalierung wirklich zu übertreiben.
Das werde ich nicht tun Ich werde das bei 0,8 und 1,2 belassen. Also nur diese drei
Änderungen, wir werden etwas
haben, das jetzt viel zufälliger und ein bisschen
einzigartiger
aussieht zufälliger und ein bisschen , als wenn dieselben zwei Objekte in exakt
derselben Größe
und Drehung
auftauchen , wenn sie ins Spiel
gebracht werden Jetzt können wir mit
der Bewegung weitermachen. Deshalb haben wir den Eventic beibehalten Auch hier wollen wir eine schöne,
konsistente, reibungslose Bewegung, und mit etwas wirklich
einfacher Logik wird der Betrieb nicht
zu teuer werden Wir ziehen aus
der Hinrichtungsnadel und finden die Welt der
Werbedarsteller. Wir wollen den
hier haben? Addieren Sie den Actor World Offset für den gesamten
Schauspieler der Insel. Geben Sie uns etwas Spielraum
, denn wir müssen hier
einige Berechnungen für den Offset durchführen. Wir werden eine neue Variable erstellen. Ich werde wieder für die
Delta-Sekunden werben , nur um hier faul zu sein. Erhöhen Sie das auf eine Variable, damit
wir den richtigen Typ erhalten, und ich nenne das
eine Bewegungsgeschwindigkeit. Klicken Sie auf Kompilieren und wir setzen dies auf eine Standardeinstellung von
etwa 400 Geschwindigkeitseinheiten, aber wir werden
sicherstellen wollen , dass wir dem
einen negativen Wert geben,
also minus 400, um sicherzustellen, dass der Bildschirm nach unten
gescrollt wird Wir können
unsere Bewegungsgeschwindigkeit loswerden. Wir wollen nur
unsere Bewegungsgeschwindigkeit mit Delta-Sekunden multiplizieren Und das setzen wir hier
in unseren Wert ein. Mir wurde gerade klar, als ich mir das
ansah. Wir wollen hier keinen
Welt-Offset hinzufügen, also löschen wir ihn. Wir wollen eigentlich den lokalen Offset
hinzufügen. Also verwenden wir den lokalen Offset „
Akteur hinzufügen“. Teilen Sie die Struktur
p für das Delta auf, und dann fügen wir sie in unseren Delta X-Standort ein,
denn auch hier bewegen
wir das
auf dem X nur
vorwärts rückwärts über den Bildschirm Wir müssen nicht
mit irgendwelcher Physik oder ähnlichem rechnen oder
versuchen, im Laufe der Zeit irgendeine
Pseudo-Physik zu Wir verwenden also nicht
den Weltoffset. Wir können den lokalen Offset verwenden. Ich nehme, wo sich der
Schauspieler gerade befindet, und er addiert diesen
Wert einfach zu dieser X-Richtung. Der Grund, der mir in den Sinn kam, ist,
dass
wir, wenn wir zum
Shoot'em-Up-Tutorial zurückkehren, zu unseren Projektilen gehen
und eine Projektilklasse öffnen Wir können das Ereignis hier sehen. Das ist eigentlich dieselbe Logik , die wir verwenden, um unsere Projektile zu
bewegen Die Insel ist im Grunde
nur ein sehr langsames, sehr großes Projektil,
so wie wir unseren Code haben Auch dies ist tatsächlich
etwas, das denselben Code verwendet Sie nur daran, dass wir wieder ein bisschen
duplizieren,
und das könnte
in einem größeren Projekt sein, in
dem Sie anfangen, sich Dinge
wie Komposition
anzusehen, wo wir eine benutzerdefinierte
Bewegungskomponente
haben könnten,
die, weil sie so
ähnlich ist und wir
wirklich nur eine
Richtung oder eine Geschwindigkeit benötigen,
diese Werte in einer benutzerdefinierten Komponente
verfügbar
machen und das könnte
in einem größeren Projekt sein, in dem Sie anfangen, sich Dinge
wie Komposition
anzusehen , wo wir eine benutzerdefinierte
Bewegungskomponente
haben könnten ,
die, weil sie so
ähnlich ist und wir
wirklich nur eine
Richtung oder eine Geschwindigkeit benötigen, können und wir könnten sie den verschiedenen Akteuren zuweisen, die sie benötigen. Wie ich bereits erwähnt habe, liegt das etwas außerhalb des Rahmens für
den Inhalt, den
wir gerade durcharbeiten
,
aber es ist nur etwas, das wir berücksichtigen sollten. Dies ist nicht das Ende der Welt, also werden wir es so
lassen, wie es ist. Und jetzt können wir tatsächlich
anfangen, sie zu spawnen. Hier wird also die einfache
generische Actor-Klasse, die Spawner-Klasse
, die wir erstellt haben sehr nützlich werden Wenn wir also in
unser Level gehen, will
ich zuerst nur ganz schnell
testen, will
ich zuerst nur ganz schnell wie die Inseln aussehen
werden, also schnappe ich mir eine
der Inseln und lasse sie auf
das
Wasserflugzeug unten fallen auf
das
Wasserflugzeug unten Wir wollen uns eine ungefähre Vorstellung von
der Höhe machen, auf der wir das spawnen
wollen Auch hier wird es
auf ein paar Optimierungen ankommen. Ich werde jetzt einiges davon machen
, aber ich werde es wahrscheinlich außerhalb des Bildschirms verfeinern Also ich glaube, als ich eines davon
zum ersten Mal fallen ließ, war
es
dasselbe wie das Flugzeug
selbst, also -4.000 Also können wir
das als Grundlage nehmen. Wir werden den
Spawner wahrscheinlich an derselben Stelle platzieren. Wir wollen
sichergehen, dass das
weiter hinten von der Kamera ist weiter hinten von der Das
können wir jetzt also einfach testen. Wir schnappen uns
unseren Kamera-Schauspieler. Wir werden das hier anheften
und wir können anfangen, es zu optimieren und
dafür zu sorgen, dass alles außerhalb des Bildschirms
erscheint. Also für die große Insel hier, und vielleicht etwas
, vielleicht etwas
, wir bis zu einer Skala von 1,2 anheben können,
denken Sie daran, dass unsere Wenn wir also den
größten Inselschwamm haben, müssen
wir ihn
mindestens auf dem Punkt
11.360 auf dem X damit er bei Spondu nicht mehr
sichtbar Das ist also unser wesentlicher
Punkt, in dem wir
wollen, dass unser Insel-Spawner platziert Also, ich nehme
das hier, drehe die Null auf das Y, also
fangen wir in der Mitte an Was ich mit den ausgewählten machen werde,
ist, hier wieder in
den Blueprint-Ordner zurückzukehren Ich gehe zum
Spawner-Ordner. Wähle das aus. Und wenn Sie das bei der Inhaltsauslosung
ausgewählt haben, das
nur ein praktischer Tipp, den Sie
gleich hier sehen werden. Wir können mit der rechten Maustaste
auf diese Insel klicken. Wir gehen runter, um Actor zu ersetzen, und wir können das durch
das ersetzen, was wir derzeit in
unserer Inhaltsschublade ausgewählt
haben. Also werden wir
das umbenennen. Dieses Objekt, das wir sehen können, ist jetzt ein
BP-Unterstrich-Spaner Ich werde dieses in
Island Spawner umbenennen . Das ist also
klar, was das macht Und tatsächlich, wenn
es um die Benennung
geht, wird es langsam
ein bisschen schlampig werden wie wir Eigentlich
hätte ich das Spawner Underscore Island
nennen sollen,
weil wir Spawner Underscore Island
nennen sehen können, dass das Also können wir sie dann auch in Spawner Underscore
Enemy umbenennen . Es ist jetzt also ein bisschen klar, dass dies
unser feindlicher Spawner ist Das ist unser Insel-Spawner, und sie werden zusammengewürfelt Eine weitere Sache, die wir als Problem ansehen
können ist, dass das statische Netz
einfach die falsche Größe Ich glaube, ich
habe vielleicht eine
andere Anlage in Betracht gezogen , mit der ich zuvor
gearbeitet habe. Also wollen wir das vielleicht auf
etwa 120 auf allen Achsen
erhöhen , vielleicht sogar auf 160. Vollkommen in Ordnung. Hauptsache, das
deckt die gesamte Kamera ab. So können wir jetzt im Spielmodus sehen, dass das Wasser alles
bedeckt. Der Spawner wird sich direkt
außerhalb der Kamera befinden, sodass wir sicherstellen können, dass die
Inseln außerhalb des Bildschirms erscheinen Nun, eine wirklich wichtige Sache, die
ich kurz davor war, komplett zu verpassen, ist die Rückkehr
zur Spawner-Insel.
Als ich das optimiert habe, habe ich die Skala auf 1,2 eingestellt Jetzt wollen wir immer
sichergehen, dass wir sie einheitlich halten , denn in einem
Teil des Spawn-Codes nehmen
Sie möglicherweise die Ortsrotation des
Schauspielers
im Maßstab als den Punkt an, nehmen
Sie möglicherweise die Ortsrotation des
Schauspielers
im Maßstab als den an dem
spawnen Wir wollen also keinen Standard,
quasi einen voreingestellten Offset,
zur Skalierung von irgendwas
hinzufügen ,
also stellen wir einfach sicher, dass wir das wieder auf
eins Damit das dann beim Spawnen der Insel funktioniert
, werden
wir das hier
eintragen
und unsere Inselklasse auswählen wollen und unsere Inselklasse auswählen Wir wollen also, dass BP die
Insel unterstreicht. Wir werden einen zufälligen
Offset zulassen, also kreuzen wir das an. Wir geben einen
Offset-Abstand von, sagen
wir, 5.000
Einheiten auf beiden Seiten an. Denken Sie also daran, dass wir nur
die integrierte Funktionalität verwenden , die
wir bereits
implementiert haben , als wir bei der Erstellung unserer
generischen Spawner-Klasse ein
wenig im Voraus
planten . Und in den Spawn-Intervallen wollen
wir nicht, dass zu viele Inseln die Szene
überladen Also setzen wir das
auf etwa 5 Sekunden und alle 10 Sekunden Also 5-10 Sekunden, wir
sollten uns eine neue Insel besorgen. Ich habe nur eine
kurze Zusammenfassung des Grundes, warum wir hier
den Offset verwenden. Denken Sie daran,
wir haben in
unserer Spawn-Basis erstellt, wir haben unseren Zweig
auf dem Spawn gestartet oder
wir haben hier
eine boolesche Prüfung durchgeführt,
tut mir leid, ob wir einen zufälligen Offset zulassen Wenn wir nein sagen, würden wir die Insel einfach genau
an der Stelle
spawnen, an der sich der Spawner befindet, was bedeutet, dass wir nur
eine gerade Linie
mit konstanter Insel haben , was wiederum
ein bisschen seltsam wäre. Wenn wir ja sagen, wird
es
eine zufällige Gleitkommazahl innerhalb eines
Bereichs auswählen , was in unserem Fall, weil wir diesen Wert auf 5.000 gesetzt haben, was zwischen
5.000 auf dem Y
und negativen 5.000 auf dem Y liegen würde . Das sollte uns
also eine große
Variation in ihrem Startpunkt,
ihrer Skala, ihrer Rotation
und sogar dem Mesh geben Variation in ihrem Startpunkt, . Wir können das jetzt testen, wenn wir drücken, sollten wir innerhalb von 5 Sekunden
irgendwo sehen Ich werde
die Kamera sehr schnell loswerden. Im Spielmodus können wir das testen und einfach
ein bisschen warten, dann sollten wir sehen, wie die
Inseln anfangen zu spawnen Wir achten zum Beispiel darauf
, dass
sie nicht einfach
so entstehen, dass sie in die richtige Richtung
gehen, womit wir meiner Meinung nach ein Problem
haben könnten,
und auch darauf , dass sie
innerhalb des von uns angegebenen Offsets korrekt
spawnen innerhalb des von uns angegebenen Offsets .
Ich
sehe also nichts Es gibt eine sehr kleine Insel. Das mag
die 10 Sekunden gedauert haben, aber wir haben
da eine sehr kleine Insel , die gerade
von unten herausragt Es ist irgendwie komisch,
aber ich finde, das
sieht immer noch Und wir sollten
hoffentlich in den
nächsten Sekunden weitere Inseln sehen Okay, wir
haben tatsächlich viele
Inseln. Ein Problem, das
wir haben, ist , dass
sie sich aufgrund
ihrer zufälligen Rotation basierend auf
der Richtung, in der
sie entstanden sind, vorwärts bewegen . Also lass uns weitermachen. Ich glaube, ich habe vielleicht einen Teil
der Logik
durcheinander gebracht , als wir die
Bewegungslogik entwickelt haben. Und ich denke,
es geht wirklich einfach zurück zu dem, was wir uns
zuvor angesehen haben. Also zurück in der Inselklasse,
ich glaube, es war das hier, der lokale Offset gegen den weltweiten
Offset, den ich im Sinn hatte. Es wäre also schön, wenn
wir den Code behalten könnten, ähnlich wie beim
Projektil, und wir könnten
wahrscheinlich stattdessen den
Projektilcode ändern Aber ich denke, was
wir tun, nur um das nett und einfach zu halten, werden
wir das von unserem
lokalen Offset aus
ändern , denn denken Sie daran, wenn wir eine
lokale Addition oder
einen Offset zur lokalen
Position des Akteurs machen , wird
das
die aktuelle Rotation berücksichtigen ,
die er hat, weil wir drehen wollen
oder wenn wir um 180
Grad drehen, den anderen Die Richtung, dann lokal vorwärts,
hat sich geändert, also werden wir uns
in die andere Richtung bewegen. Aber wenn ich das gesagt habe, wurde mir klar, dass
wir
hier wahrscheinlich
etwas Saubereres tun könnten etwas Saubereres , indem wir uns auf die Hierarchie konzentrieren. Also nochmal, das ist
etwas,
bei dem ich das vor der Entwicklung
einfach übersehen habe. Und das bin ich, ich denke
quasi an Ort und Stelle, weshalb ich das hier
behalte, nur um Wege aufzuzeigen, wie wir verschiedene
Probleme auf verschiedene Weise lösen können. Ich bin also versucht, das zu tun , weil ich diese Logik beibehalten
möchte Ich möchte die lokale
Offset-Bewegung machen. Ich denke, wir werden stattdessen
eine neue Komponente hinzufügen. Wir werden eine
leere Szenenkomponente erstellen und dies
zur neuen Route machen. Die Szenenkomponente wird also der Weg
sein, dem wir gegenüberstehen, was in der Welt einfach immer vorwärts sein wird
. Und ich denke,
wir werden stattdessen unsere Rotation festlegen, aber wir werden nicht
die Rotation
des gesamten Schauspielers festlegen . Wir werden
die Szenenkomponente
immer nach vorne zeigen lassen . Und das ist nur ein
schönes Beispiel verschiedene Möglichkeiten, wie wir auch Hierarchien
verwenden können. Wir können unser statisches Match nehmen
und stattdessen die Rotation
festlegen. Dies ist auch etwas
, das wir noch nicht gesehen haben, sodass wir die
relative Drehung
unserer Komponenten relativ zu
ihrer übergeordneten Komponente festlegen können unserer Komponenten relativ zu , an
die sie angehängt sind. Aber genau
dieselbe Logik. Wir werden
das anschließen. nehmen diesen zufälligen Float
, den wir bereits haben, teilen den Strukturstift auf,
wie wir es zuvor gemacht haben. Stattdessen stecken wir das hier einfach
in das Z ein. Das bedeutet, dass wir
unsere Bewegungslogik
exakt beibehalten können . Und jetzt
ändern wir nicht die Rotation des gesamten Schauspielers und
die Art und Weise, wie er auftritt. Das zeigt immer noch
in dieselbe Richtung. Wir ändern nur die
Drehung des visuellen Elements. so, wie wir das von den Ebenen
getrennt haben , wo das visuelle Element nur der Flugzeugkörper
ist, aber die eigentliche
Kollision und worauf
alles beruht ,
ist diese Kollisionsosphäre. Wenn wir also wieder reingehen und spielen,
sollten wir sehen, dass das jetzt funktioniert Ein weiterer nützlicher Konsolenbefehl hier ist, dass wir
die Tilda-Taste drücken, Slow Mo
eingeben und dann
einstellen können , wie oft das
schneller sein soll Wenn wir das also
auf Slowmo Five setzen, können
Sie sehen, dass sich das Ganze fünfmal schneller
bewegt. Das ist
viel einfacher zu
testen und
zu sehen, viel einfacher zu
testen und
zu sehen ob die Inseln richtig
spawnen. Sie bewegen sich jetzt also
auf dem Bildschirm nach unten. Das sieht so aus, als ob es richtig
funktioniert. Wir haben den Test in Erinnerung, bei dem wir nicht
ständig Dinge spawnen werden Wenn der Spieler tot ist. Nochmals Konsolenbefehl, wir
können einen Neustart-Level eingeben, direkt zurück zu Slom Five
gehen, und wir können einige Tests durchführen,
nur um sicherzugehen, dass die Inseln einfach nur
sichergehen, dass wir unterwegs mehrere
Tests machen , dass die Inseln in Ordnung
sind Sie bündeln also eine
Menge, aber ich meine, auch hier kommt die
Randomisierung Das mag passieren,
aber es bietet eine nette Art von Abwechslung,
und ich finde, das
sieht ziemlich gut aus Vielleicht möchten wir eine
etwas größere Verzögerung zwischen den
ursprünglichen Inseln hinzufügen ,
aber ich denke, gerade für
diese Art von Projekt sieht
das ziemlich
cool aus und
einige Überschneidungen verleihen dem
Ganzen einfach zusätzliche Abwechslung. Eine andere Sache, die
du vielleicht machen möchtest, ist in der Spawner-Basisklasse Wenn wir hier reinkommen, werden
wir sofort Actor spawnen Also sollten wir einen haben.
Wenn wir nur auf Simulate klicken. Wir sollten es
einfach noch einmal überprüfen Ja, wir bekommen sofort einen,
was völlig in Ordnung ist. Ich dachte, dass
wir vielleicht schon eine anfängliche Verzögerung
hatten, aber ich denke, der einzige
Grund, warum wir es eine
Weile nicht
sehen, ist einfach, dass es eine
Weile nicht
sehen, ist einfach es ein bisschen dauert,
bis es auf dem Bildschirm herunterkommt Wir spawnen also sofort mit
einer Insel. Ich
frage mich nur , wo das gerade
ist Also, es dauert einfach besonders wenn es zuallererst einen
kleinen hervorbringt Es wird ein
bisschen länger dauern, es zu sehen,
bevor es im Frame erscheint.
Nicht das Ende der Welt. Nochmals, Randomisierung, da werden
Sie einige
unterschiedliche Ergebnisse haben Selbst bei der größeren
Insel
dauert es meiner Meinung nach eine ganze Weile, bis sie auf
dem Bildschirm angezeigt wird. Also vielleicht das, wozu ich
versucht wäre, und auch hier wird es darauf
ankommen, dass ich viel
reisen muss , um jetzt herumzuspielen Vielleicht waren wir ein bisschen zu besorgt darüber, wie weit das heute Morgen noch
entfernt ist Also bringen wir das ein bisschen
zurück
und nochmal, stellen sicher, dass jedes Mal, wenn Sie die Platte drücken, ein
Auge
darauf haben, dass nichts einfach reinkommt,
aber wir wollen, dass die Insel vielleicht ein
bisschen
früher auf dem Bildschirm zu ein
bisschen
früher auf dem Bildschirm Also, wie ich schon erwähnt habe, Versuch und
Irrtum, schauen, wie die Dinge laufen, behalten Sie die Ergebnisse
im Auge und
stellen Sie sicher, dass das Spiel gut
aussieht, während
Sie es durchspielen Also ich finde das ziemlich
cool. Hier sollten die Dinge allerdings
etwas interessanter werden. Du hast jetzt die volle Kontrolle über das Leveldesign, wo du die Dinge erscheinen lassen
wolltest,
die Geschwindigkeit, mit der sie sich bewegen
sollen, du hast wirklich nur die Spielweise und das
Aussehen des Spiels, das du hast, verfeinert Aussehen des Spiels, das du hast, Wenn Dinge auftauchen, kannst du
den Spawner einfach ein bisschen weiter nach hinten
bewegen Wenn Sie möchten, dass sie
früher erscheinen, könnten wir sie
etwas näher bringen Wenn das Wasser nicht die gesamte Sicht
verdeckt, vergrößern
Sie einfach das
Flugzeug, wie Sie es gerade gesehen haben. Und wenn die Inseln zu nah
sind, dann senke einfach die
Laichgeschwindigkeit und so Und das ist reine Iteration,
spielen, beobachten, anpassen, Es kommt selten vor, dass du beim ersten Mal
so perfekt hinkriegst. Sie haben gerade gesehen, dass ich selbst für
diese Demonstration hier
ein paar Dinge optimieren und ändern musste,
aber hier sollte
ein Teil des Spaßes beim Entwickeln
von Spielen
ins Spiel kommen, denn hier haben selbst für
diese Demonstration hier
ein paar Dinge optimieren und ändern musste,
aber hier dass ich selbst für
diese Demonstration hier
ein paar Dinge optimieren und ändern musste,
aber hier sollte
ein Teil des Spaßes Sie jetzt
viel mehr Kontrolle
darüber Sie jetzt
viel mehr Kontrolle das Endergebnis verfeinern Eine Sache, die ich
sagen würde, ist, dass es auch an
dieser Stelle lohnen wird, den Outliner im Auge
zu behalten, wie ich bereits erwähnt habe Wir haben ein paar Dinge, unsere Sperrvolumen
sind völlig in Ordnung Vielleicht
Dinge in Ordner zu legen wie bei der Beleuchtung
, die standardmäßig da war. Eine Sache, von der ich weiß, dass wir sie
nicht wirklich nutzen ist die Himmelskugel im Hintergrund.
Das ist ein altes Objekt. Es macht nichts. Wir können
die Himmelskugel loswerden. Man kann sehen, dass sich nichts ändert, nur um sicherzugehen, dass wir nicht
mehr Objekte im
Level haben , als wir brauchen. Alles andere ist in Ordnung. Dies sorgt für Licht und Atmosphäre
im Hintergrund. Aber Sie können gerne damit
herumspielen die Richtung
des gerichteten Lichts und dessen Stärke
ändern, um
die
Dinge heller und dunkler aussehen zu lassen. Fangen Sie auch hier an,
kreativ zu werden und mit
den verschiedenen
Eigenschaften und Details
zu spielen den verschiedenen
Eigenschaften und Details , damit das Spiel so aussieht, wie
Sie es sich vorgestellt haben. Das war's also für unser
Level. Die Dinge sehen
jetzt ein
bisschen lebendiger aus. Wir haben Wasserinseln,
Parallax De, mit denen du spielen kannst. Es fängt tatsächlich an, ein
bisschen wie ein Spiel
auszusehen Als Nächstes können wir mit dem ausgefeilten Pass beginnen, sodass sich die Dinge für den Spieler
wirklich interessant und visuell
viel
ansprechender anfühlen .
24. 23 - Niagara-Partikel: Ein Punkt, an dem wir
anfangen können,
das allgemeine Spielgefühl und die
Attraktivität für jemanden
zu verbessern das allgemeine Spielgefühl und die Attraktivität für jemanden Wir werden mit den
ausgefeilten Effekten beginnen und Dinge wie
Triebwerke, Explosionen und
Aufprall
hinzufügen, und das alles mithilfe der im Niagara-System
integrierten
Unreal-Engine im Niagara-System
integrierten Also
noch einmal ein kurzer Überblick über die Systeme und Emitter, mit denen wir uns in unserem Projekt
befassen werden Wenn wir zu unserem Projekt navigieren, in den
Ordner „Assets“ und „Effekte“
gehen, haben
wir unsere
Niagara-Systeme genau hier Aber öffne einfach eines
davon. Wir werden vorerst
die Pixel-Engine verwenden ,
nur um zu zeigen, womit
wir arbeiten. Wir befinden uns also im
Moment
in einem Niagara-System Systeme bestehen im Allgemeinen
aus einem und oft aus mehr
als einem Emitter Wir können hier sehen, dass die
orangefarbenen Felder mit den Registern
unsere Emitter sind , die die verschiedenen Punkte
unseres Gesamtsystems ausmachen Dadurch ist die Arbeit
mit Niagara viel
flexibler als mit dem älteren
Kaskaden-Partikelsystem Im neuen System ist es viel einfacher einige Basis-Emitter
zu erstellen, und dann können wir damit beginnen, sie
zusammenzufügen, um
daraus maßgeschneiderte und
einzigartige Systeme zu erstellen Auf wirklich vereinfachte
Weise können Sie sich das
als etwas wie ein
Flammenpartikelsystem vorstellen als etwas wie ein
Flammenpartikelsystem Möglicherweise haben Sie viele Emitter
, die sich darauf einlassen würden. Du hättest die Funken von der Spitze
der Flamme
kommen lassen. Du
hättest etwas Rauch Du könntest den
Verzerrungseffekt haben, und du hättest den
Hauptteil der Flamme und das Feuer selbst. All das könnten
einzelne Emitter sein , die ein großes System
aufbauen wichtig
zu beachten ist wichtig
zu beachten, dass Emitter wiederverwendbar sein
sollen Wir platzieren sie nicht direkt in unseren Entwürfen oder in
den Systemen, die wir innerhalb unseres Codes
oder des Levels selbst
verwenden und nutzen innerhalb unseres Codes
oder des Levels selbst
verwenden Wenn Sie versuchen
möchten, mit einigen der Systeme,
die ich
bereits bereitgestellt habe, herumzuspielen , können
Sie hier sehen, dass ich mehrere
habe Sie können ganz einfach
reinkommen und anfangen mit den
Eigenschaften der Emitter
herumzuspielen Wenn Sie sehen möchten, welcher
Teil für
einen bestimmten Effekt verantwortlich ist , der hier im Viewpot vor sich
geht , können wir
das
Häkchen hier entfernen. Wir können sehen, dass dies
nur eine Lichtquelle ist, also ändert sich nichts wirklich Wenn wir das wieder einschalten, aber dann den anderen Emitter ausschalten, können
wir sehen, dass dieser eindeutig derjenige ist,
der dort für
den
Partikeleffekt unseres Motors verantwortlich dort für
den
Partikeleffekt unseres Motors Wenn Sie also kommen und
versuchen
wollen, mit
Dingen wie der Farbe und
der Größe herumzuspielen, wissen Sie vielleicht
nicht sofort versuchen
wollen, mit
Dingen wie der Farbe und
der Größe herumzuspielen, genau, wonach Sie suchen,
was völlig in Ordnung ist Aber wenn wir uns nur einen kurzen Blick auf die bereitgestellten
Eigenschaften werfen, können
wir sehen, dass wir
die Farbe
wahrscheinlich anhand unserer
Skalierungswerte hier ändern könnten unserer
Skalierungswerte Dadurch entsteht hier die
gelb-orange Farbe. Wenn wir dem mehr Blau
geben, erhalten wir Laufe der
Lebensdauer des Partikels
eine andere Farbe. Es ist eine weitere großartige
Möglichkeit, sich an
einige der Systeme
in Unreal zu gewöhnen ,
einfach die Dinge zu finden, die für Sie
instinktiv Sinn machen, und mit den
Werten, die
Sie finden können, herumzuspielen und zu und mit den
Werten, die
Sie finden können, herumzuspielen und schwächen Du kannst auch verschiedene
Dinge wie
zusätzliche Geschwindigkeit hinzufügen , um diese
Reise weiter Und wie ich
bereits erwähnt habe, besteht eine wirklich gute
Möglichkeit, herauszufinden, wofür Dinge verantwortlich sind, darin einen wirklich dummen
Wert
hinzuzufügen, sodass wir sehen können, dass wir, wenn
wir die Geschwindigkeit hier auf 11.000 statt auf 1.000
setzen, genau sehen können, wofür
das verantwortlich war, und dann können wir verfeinern
und auf
einen Wert reduzieren , von dem wir glauben, dass wir
vielleicht damit arbeiten möchten. Wie bei einigen anderen Systemen innerhalb des Projekts, die
wir uns bisher angesehen haben, steht
die künstlerischere Seite
der Dinge wirklich nicht im Mittelpunkt dessen, was
wir mit diesen Themen zu
erreichen versuchen . Also werde ich nicht tiefer in Niagara eintauchen. Ich möchte Ihnen zeigen,
wie man es benutzt und wie wir
es in ein Projekt implementieren können Nützlich, wenn du
Zugriff auf Asset-PACs oder einige
der kostenlosen Beispiele
aus dem von Epic bereitgestellten
Inhaltsbeispielprojekt hast Zugriff auf Asset-PACs oder einige
der kostenlosen Beispiele
aus dem von Epic bereitgestellten
Inhaltsbeispielprojekt Erstens, da wir uns
bereits in diesem Partikel befinden, könnten
wir das für das Triebwerk
unserer beiden Flugzeugklassen nutzen unserer beiden Flugzeugklassen Beide werden das brauchen, sowohl der Feind als auch der Spieler Wenn wir also zu unserer
Blueprint-Klasse gehen, gehen
wir nach CR und wir werden
die BP Underscore-Flugzeugbasis finden die BP Underscore-Flugzeugbasis Also können wir das wieder in
die Basisklasse aufnehmen, und das wird für unsere
beiden verschiedenen Flugzeuge verwendet Wir müssen
wieder sehr vorsichtig sein , wo
wir das platzieren werden. Wir könnten es
direkt auf der Kugel platzieren, aber ich denke,
im Moment werden wir es stattdessen hier platzieren, falls wir eine
bestimmte Versatzdrehung oder solche
Dinge mit
dem statischen Netz machen solche
Dinge mit
dem statischen Netz wollen. Also schnappen wir uns das statische Netz. Wir werden
eine neue Komponente hinzufügen und nach Niagara
suchen Wir können hier sehen, dass wir
nur eine Option haben,
die Niagara-Partikelsystemkomponente Und im Detailbereich werden
wir das Drop-down-Menü sehen, nach dem wir wahrscheinlich Ausschau halten und mit dem wir inzwischen ziemlich vertraut Wir können das herunterklappen und die Pixel-Engine
auswählen. Wenn wir zum Viewpot navigieren, können
wir sehen, dass er quasi in der Mitte von Amopla
angedockt wurde , also müssen wir das nur ein wenig nach hinten
verschieben Und ich denke, ich werde das einfach ungefähr neben
dem Metallkreis
platzieren , den ich gerade hier im
Flugzeug hinzugefügt habe Wenn wir auf Compiling safe klicken, gibt es ein paar Dinge, die wir damit vielleicht testen
müssen Die erste ist also
die unterschiedliche Rotation , die wir
auf
die verschiedenen Kinderklassen anwenden werden die verschiedenen Kinderklassen Wenn wir also im normalen Player beginnen und nur
den Blickwinkel hier
überprüfen, sieht
dieser hier völlig in Ordnung Dies ist im Wesentlichen
derselbe Aufbau wie bei Plane Base. Wenn wir in Plain Enemy
gehen, gehen wir hier in das Viewboard, damit wir sehen können, dass
der Partikeleffekt auch hier gut aussieht Wenn wir jedoch auf Play drücken, also in unseren
Viewpot und in den Spielmodus gehen, können
wir sehen, also in unseren
Viewpot und in den Spielmodus gehen, können
wir sehen, dass es für den Spieler in Ordnung zu sein
scheint, aber die feindlichen Partikel
sehen einfach ein bisschen aber die feindlichen Partikel
sehen einfach ein bisschen
seltsam aus, so wie sie sind. Denken Sie daran,
wenn wir in den Spielmodus kommen,
drehen
wir die Rotation unseres
Feindes basierend auf der Position
des Spawners komplett um wenn wir in den Spielmodus kommen, drehen
wir die Rotation unseres
Feindes basierend auf der Position
des Spawners komplett . Und obwohl dieser
Partikeleffekt verschachtelt ist, können wir, wenn wir uns das Setup in der
P-Unterstrich-Pixel-Engine ansehen, sehen, dass die
Geschwindigkeit auf
eine bestimmte Richtung eingestellt ist ,
negativ 1.200. Also, was wir tun wollen, und
das wird nur
eine sehr einfache Anpassung an
einem bestehenden Partikelsystem sein eine sehr einfache Anpassung an
einem Damit Sie anfangen können,
zumindest ein bisschen in die Hand zu nehmen, müssen
wir ein Duplikat
der Pixel-Engine erstellen Also kommen wir
zurück zu unseren Effekten. Wir werden zu
unseren Niagara-Systemen gehen. Wir haben unsere
Pixel-Engine genau hier. Eine andere Sache, diese
wurden aus
den Inhaltsbeispielen kopiert , sie haben
nicht die beste Benennung, also
nehmen wir das und benennen dieses in Ns um. Die richtige Benennungskonvention
wäre also Nagra-System, Underscore-Pixel-Engine, und wir nennen diesen einen
Underscore-Player Also können wir das genau so lassen, wie es
ist. Wir können dann in der Tat die
Strg-Taste drücken, um das zu duplizieren,
und
das nennen wir dann Underscore Enemy Und wenn wir doppelklicken, um die gegnerische Version zu
öffnen, wollen
wir unsere Geschwindigkeit ermitteln Wir haben bereits gesehen, dass
dies
die Richtung bestimmt, in die sich der
Partikeleffekt bewegt, und wir werden hier einfach
die Option Negieren entfernen Wir könnten auch etwas tun,
während wir hier sind, und diesen vielleicht ein
bisschen grüner
machen, sodass wir den Wert nach oben ziehen
könnten ,
um ihm einen etwas
anderen Farbton zu geben Und wenn wir den roten Wert
überschreiten, können
wir sehen, dass das
hier eher
ein
grünes Triebwerk ist , nur um es für die gegnerische Version, auf der wir
das platzieren werden,
etwas einzigartiger zu
machen für die gegnerische Version, auf der wir
das platzieren werden,
etwas einzigartiger zu
machen Also können wir auf Kompilieren
und Speichern klicken. Wir gehen zurück in
die feindliche Klasse. Wir schnappen uns hier unser
Niagara-Partikelsystem und wollen nur das vom Spieler,
das wir gerade umbenannt haben, ändern
und es auf
die feindliche Version Das wird im Bauplan also
kaputt aussehen. Das ist völlig in Ordnung, denn sobald wir in die Playode gehen, wird
die Weltrichtung der
Bewegung des Partikelsystems berücksichtigt und nicht
die Entität, in der es sich befindet Wir können also sehen, dass das jetzt einwandfrei
funktioniert. Etwas anders, weil
wir verschiedene Farben haben, also sieht es auch ein
bisschen interessanter aus. Eine nette, einfache Änderung, nur um Partikelsystem dort
ein bisschen in
die Hand zu nehmen, und wir lassen sowohl das Spieler
- als auch das gegnerische System funktionieren Das ist also eine Möglichkeit, Partikel ohne
Code direkt auf Komponenten
und bestehende Funktionen anzuwenden Code direkt auf Komponenten
und bestehende Funktionen Wenn Sie sich erinnern, haben
wir ein paar Dinge vorbereitet , die wir auch
in unserem Code implementieren können. Erinnern Sie sich an einige
dieser To-do-Kommentare. Eines davon, an das ich mich erinnere,
war tatsächlich Teil unseres Blueprint-Kurses
für unsere Projektile Also, wenn wir zu BP gehen, die Projektilbasis
unterstreichen
und genau das, was ich vorhin
erwähnt habe, gebe ich hier unten einfach todo ein
. Wir werden den
Kommentar finden, den ich
selbst hinterlassen habe , und er ist einfach Wenn Sie diesen
Kommentar also nicht hinterlassen haben, müssen Sie nur zu Ihrer
Komponente „Beginn der Überlappung“
navigieren, und hier
möchten wir einige Effekte einfügen. Und wir werden mit
unserem einfachen Partikelsystem beginnen um zu zeigen, dass sich zwei
Dinge ausgewirkt haben Zwischen unserem Schadensangriff und noch einmal, was wirklich wichtig ist bevor wir
das Projektil zerstören, ziehen
wir
aus dem
Hinrichtungsstift und suchen vor Ort
nach sogenannten
Spawn-System Also wollen wir diese
Option nur hier haben, gesamte System an Ort Nun, es gibt ein paar verschiedene Dinge, wenn
Sie anfangen, sich selbst genauer mit Partikeln zu befassen, um auf dem
aufzubauen, was
wir hier tun. Möglicherweise stoßen Sie auch auf
den Begriff Spawn-Emitter. Wenn wir also nach
Born-Emitter at Location suchen, hat
das eine sehr ähnliche Terminologie, und das ist im Grunde
die ältere Version
des Partikelsystems des Partikelsystems Es ist also noch nicht vollständig entfernt, aber ich habe es vorhin ganz
kurz erwähnt. Früher gab es ein
sogenanntes Kaskaden-Partikelsystem Es war nicht ganz so flexibel, hat nicht so viele Funktionen Es ist nicht so einfach
einzuprogrammieren, obwohl wir jetzt
das Niagara-System verwenden Wenn Sie also mit Niagara
arbeiten möchten, worauf
Sie sich idealerweise konzentrieren werden, sollten
Sie nach etwas
suchen, das als
das Wort System bezeichnet wird, das
ziemlich häufig vorkommt Wenn Sie mit
Cascade arbeiten, wenn Sie einem Legacy-Projekt oder
einem älteren Projekt arbeiten, Ihnen möglicherweise das
Wort Emitter Kaskadenartikel wurden also als Emitter
bezeichnet,
wohingegen heute, wie ich bereits erwähnt habe,
ein Emitter nur ein einzelnes Element ist, das
ein ganzes
Niagara-System bildet Das ist also der einfachste
Weg, sich daran zu erinnern.
Also suchen wir
nach einem System. Sie wissen, dass Sie
auch
das richtige haben , denn wenn
wir das weglassen, haben
wir nichts
Gültiges, das wir in
den Emitter-Slot stecken könnten. Also werden
wir das loswerden Wenn wir das hier
runterlassen, wollen wir unseren Metalleinschlag
herausfinden. Das
wollen wir also verwenden, wenn zwei Projektile oder ein Projektil auf eine andere Oberfläche
treffen Das ist also der Emitter
, den wir spawnen wollen. Und das ermöglicht es uns, diese zur Laufzeit
einzubinden, sodass die Projekte
etwas dynamischer aussehen Der Standort wird wirklich
einfach sein. Wir ziehen von hier aus
und
suchen einfach nach dem Standort des Schauspielers. Wir wollen also
, dass der Partikeleffekt entsteht, also
der Einschlagspunkt,
an dem zwei Dinge aufeinandertreffen Die Skalierung der Drehung belassen
wir als Standard. Wir müssen
diese nicht ändern. Wir kommen zurück und machen später ein paar
Soundeffekte und so. Also werde ich
diesen Kommentar später für mich selbst hinterlassen , da ich zurückkommen
und noch ein paar Dinge hinzufügen muss. Aber auch hier können wir jetzt
reinkommen und testen, und was wir
sehen sollten, ist, dass jedes Mal ,
wenn
ein Projektil auf etwas trifft , irgendein Partikeleffekt abgespielt wird Es ist also ein
bisschen extrem, aber wir können definitiv
sehen, dass es passiert Und wieder können Sie
reinkommen und
die verschiedenen Skalierungen
und solche Dinge verfeinern . Aber wir haben jetzt
Feedback erhalten , dass zwei
Dinge kollidiert sind, wodurch sich das
Spiel einfach viel
interessanter und
intuitiver anfühlt interessanter und
intuitiver Ich habe auch dafür gesorgt,
ebenso wie den Metallschlag. Möglicherweise könnten Sie auch die Pixelexplosion
verwenden, also liegt es ganz bei Ihnen. Ich denke, sie sehen
etwas anders aus. Überprüfe einfach noch einmal,
wie sie aussehen. Dieser könnte
tatsächlich
etwas besser für die
geringere Wirkung dort geeignet sein. Also werde ich das
bei der Pixelexplosion beibehalten. Aber das ist die Hauptsache, wir haben
jetzt dieses visuelle Feedback. Und dann
wollen wir dasselbe für unsere beiden Flugzeuge tun. Also nochmal, wir haben das in der Basisklasse
aufgegriffen, also gehen wir zur
BP Underscore-Flugzeugbasis Ich glaube, ich habe mir hier auch
ein Spielzeug hinterlassen, und wir werden einfach darauf
doppelklicken Also um
Flugzeugtodeffekte zu implementieren. sind also die
Effekte, die ich
spielen möchte , wenn eines der
Flugzeuge zerstört wird. Also nochmal das Gleiche. Von hier aus ziehen
wir weiter. Wir werden nach der Systemoption
Born suchen. Nehmen Sie das Span-System vor
Ort. Dieselbe Immobilie. Also wo auch immer das Flugzeug gerade zerstört
wurde, das
wird der Ort sein. Also werden wir den Ort finden, an
dem wir uns befinden. Und wir werden das hier etwas
anders machen . Also, wie wir es in
der Vergangenheit getan haben, wollen wir das flexibel
machen,
weil wir es für die Verwendung in
den untergeordneten Klassen
des Elternteils verfügbar für die Verwendung in
den untergeordneten Klassen machen, wo sich
die Kernlogik befindet Also nehmen wir hier
unsere Systemvorlage und wir werden sie einfach zu einer Variablen
heraufstufen Wir benennen diese in
Explosionspartikeleffekt um. Und das müssen wir für
die Kinderklassen ändern ,
weil der Spieler und der Feind nur
leicht unterschiedliche
Partikeleffekte haben leicht unterschiedliche
Partikeleffekte Also klicken wir auf Kompilieren und Speichern. Wir gehen
in die Flugzeugklasse, die Spielerflugzeugklasse. Stellen Sie sicher, dass wir
das oberste Element ausgewählt haben, und wir sollten irgendwo hier unten
sehen können, wir jetzt einen
Explosionspartikeleffekt haben. Von hier aus suche ich den Pixel-Explosions-Spieler und dann klicken wir auf Kompilieren,
Speichern und gehen in das feindliche Flugzeug. Noch einmal das Gleiche. Schnapp dir
das oberste Element. Wir werden unser
Explosionspartikel finden und dieses
auf die feindliche Version umstellen. So nett und einfach,
kompilieren und wieder speichern. Und jetzt wollen wir
testen und sehen, wie das
funktioniert, wenn sich die Dinge
tatsächlich gegenseitig überfordern. Wir sehen also, dass es beim ersten
Mal eine kleine Verzögerung gibt. In einem Light-Spiel, das vollständig geflasht wirst
du etwas
ausführen
wollen die
Shader vorkompiliert werden,
um sicherzustellen, dass alle
Effekte
im Wesentlichen mindestens
auf rund sind, damit wir nicht zu dieser Verzögerung kommen um sicherzustellen, dass alle
Effekte
im Wesentlichen mindestens
auf rund sind , damit wir nicht Aber jetzt, wo wir das hinter uns
haben,
können wir sehen, dass wir die verschiedenen Effekte haben Und wir können auch einfach testen. Wenn der Spieler stirbt, bekommen
wir dasselbe. Es ist also etwas anders, wenn wir überprüfen und uns ansehen. Ich denke, einer ist
etwas blauer, also haben wir hier eine Art
blaue Explosion, und der andere
hat diesen grünen Farbton Vielleicht möchten Sie reinkommen und die Farbeigenschaften
ändern Und Sie können sehen, wie die Dinge
etwas komplexer werden, wir können die Komplexität sehen, die Anzahl
der Emitter nimmt ab Aber sobald Sie sich mit den Dingen vertraut gemacht haben, nach denen
Sie Ausschau halten, sind
diese relativ
einfach zu optimieren
und zu ändern und so einzustellen, dass sie genau so
funktionieren, wie Sie Das ist die
Programmierseite der Dinge. Das ist wirklich alles, was
wir tun müssen,
um einige
Partikeleffekte abzuspielen Es ist also ein relativ einfacher Schritt , unserem Projekt etwas Feinschliff
zu verleihen Und dies ist ein weiteres dieser Dinge
, bei denen Ihnen das
Experimentieren und wird Herumspielen mit
Dingen wirklich mehr
als alles andere zugute kommen Ich habe zum Beispiel
die Partikeleffekte direkt
aus den Beispielen für epische Inhalte übernommen die Partikeleffekte direkt
aus den , und ich denke, nur für
den allgemeinen Aufbau, dass ich die Explosionen
etwas zu dünn sehe,
nicht ganz so klobig, wie
ich Ich könnte also versucht sein,
bei beiden zu versuchen, reinzukommen und die Dinge zu
finden, die speziell
mit der Größe des Netzes zu tun Das sind also drei
dieser statischen Maßnahmen. Ich kann hier sehen, dass wir eine skalierte Maschengröße
haben, und ich könnte diese standardmäßig einfach auf
etwas viel
Größeres
erhöhen . Ich kann hier genau sehen auf
welches
Element das wirkt, sodass wir sehen können, welche
gerade viel größer geworden sind. Ich habe das viermal
größer gemacht als es war. Auch das
ist etwas
zeitaufwändig, weil ich das für jedes der
verschiedenen Elemente
tun muss . Also würde ich zu diesem kommen zum Beispiel
auf vier, vier und vier setzen. Aber wir haben jetzt sofort
eine viel schönere klobigere Explosion für die Art von Stern
, die wir Also wirklich einfache Änderungen wie diese können bei den Emittern wirklich einen Unterschied
machen und alles, was
ich tun musste, war reinzukommen und die Maschengröße zu finden Wenn ich das also an
unserem Feind testen wollte , würde ich
das Gleiche noch einmal machen, also könnten wir uns die Maschenwaage nehmen auf vier, vier und
vier
setzen , damit sie zum Spieler passt Und wir machen
das einfach für jeden
der verschiedenen Emitter, damit
alles einigermaßen
einheitlich bleibt , weil sie quasi
verschiedene Elemente
des Explosionssystems repräsentieren
sollen verschiedene Elemente
des Explosionssystems Also kompiliere und speichere
das, wir können
reinkommen und spielen und sehen,
wie das aussieht A Ich denke, das ist viel besser. Ich denke, es zeigt einfach einen
schönen Unterschied zwischen dem allgemeinen
Projektileinschlag der Explosion
der Schiffe.
Also wirklich
kleine Dinge wie diese Du könntest die
Farben auch finden,
vor allem, wenn du
andersfarbige Gegner hast als
die, die ich ausgewählt habe. Ihr könntet in
die gegnerische Explosion kommen, alle
Farbeigenschaften zwischen
all den verschiedenen Emittern
finden , herausfinden, welche für
welche Farbe
verantwortlich sind , und
sie dann nach Belieben ändern Denken Sie daran: Wenn Sie
sich nicht sicher sind , welches Element
Sie ändern möchten, können
wir hier einfach die verschiedenen
Emitter deaktivieren und sehen was für welchen Teil verantwortlich ist.
Sie können es also durchgehen Das wäre nur
die Art von After Smoke, damit wir den
ausschalten können. Das mittlere ist
für die Hauptfarbe. Also wenn meine, meine Feinde tatsächlich grün
sind. Also vielleicht wäre
es sinnvoller, eine eher grüne Farbe zu haben, damit wir den grünen Wert erhöhen können, das Ganze
hochziehen können. Und dann gehen wir. Wir haben eher eine grüne
Explosion für die feindliche Nacht. Wir haben also eine schöne
gelbe Farbe mit einer
hitzigen Explosion
beginnt. Aber dann zeigen wir
, dass es tatsächlich wieder zu
einer grünen Verlängerung
geht, was die Karosseriefarbe
des feindlichen Schiffes ist Also nochmal, eine
wirklich, sehr schnelle Änderung. Solange Sie ungefähr wissen,
wonach Sie suchen, können
wir diese Änderungen im
Handumdrehen vornehmen. Und zu sehen, wie sich das ganz gut
zusammenfügt. Spielen Sie also mit
solchen Dingen herum. Mit diesen Ansätzen können Sie
die Systeme
viel schneller
verstehen. Sie werden zu Beginn nicht unbedingt genau
wissen, wonach Sie suchen,
aber ich denke, gerade
bei so etwas wie Niagara-System,
den
Namenskonventionen,
den Dingen, nach denen Sie
suchen, und
dem unmittelbaren Feedback, das Sie vom Standpunkt aus
erhalten, ist eine sehr praktische Methode, dies sehr schnell zu
lernen, indem nur einige Fehler ausprobieren und mit verschiedenen Werten
optimieren Das ist also der erste Schritt zur Verbesserung
unseres visuellen Feedbacks Verbesserung
unseres visuellen Feedbacks Dadurch fühlt sich alles lebendig an. Die Feinde tauchen immer noch
irgendwie aus dem Nichts auf. Dann das nächste Thema,
wir wollen
die wirklich schönen
Spawnanimationen hinzufügen die wirklich schönen
Spawnanimationen hinzufügen ,
die im Beispielprojekt bereitgestellt wurden
25. 24 - Audioeffekte: hätte sagen können, dass
wir beim Animationsfestival
mitmachen werden, aber mir ist klar, dass
wir hier
das fehlende Stück unserer
Lackierung übersehen hier
das fehlende Stück unserer
Lackierung Und das ist oft etwas
, das bei der Entwicklung von
Spielen viel zu
spät vergessen wird , und das ist Audio. Wir wollen anfangen, uns mit der Verwendung
von San-Cues zu befassen, um
eine minimale Anzahl von
Audiodateien
nach dem Zufallsprinzip zu sortieren, damit die Dinge etwas abwechslungsreicher und
interessanter klingen Es gehört
auch zu den Dingen, dass es
beim Prototyping eines eigenen
Spiels
sehr leicht ist, die Bedeutung von Audio zu übersehen oder zu unterschätzen. Möglicherweise haben Sie das Gefühl, dass sich Ihr Spiel flach
oder langweilig anfühlt. Sie können Dinge
wie Partikeleffekte,
Kameraverwacklungen und all
diese anderen Dinge hinzufügen , und es könnte sein,
dass dem Projekt einfach etwas Audio
fehlt , das wirklich dazu beitragen
würde, es zum Leben zu
erwecken. Also werden wir uns
auf dieses Festival konzentrieren. Also, wenn wir in
unsere Inhaltsauswahl gehen, gehen
wir in
den Audio-Ordner. Ich habe ein paar
verschiedene Sounddateien bereitgestellt. Wir haben einen für die Explosion, also werden wir ihn
für unsere Flugzeuge verwenden ,
wenn sie explodieren,
und wir haben den Schusseffekt, der immer dann abgespielt wird
,
wenn wir schießen abgespielt wird
,
wenn wir Wir werden das wahrscheinlich nicht für den
Feind
einsetzen, aber auch hier kannst
du die Dinge anpassen und
herumspielen, um zu sehen, wie dir das
Projekt gefällt Ich denke, wenn zu viele
Dinge gleichzeitig abgefeuert werden, kann
das sehr leicht zu
einer Hörüberlastung Wenn Sie
die Audiodateien testen und
sehen möchten, wie sie klingen, können
wir sie hier über
die Play-Schaltfläche springen und Sie erhalten sofort die
Wiedergabe im Editor Wenn wir uns auf unsere Schüsse konzentrieren, zunächst, da
wir zwei davon haben, wollen wir
zunächst, da
wir zwei davon haben,
beide mit der Shift-Taste
auswählen, mit der rechten Maustaste auf einen der beiden klicken, und wir haben hier diese Option,
um eine einzelne Warteschlange zu erstellen Wenn wir uns also dafür entscheiden, mehrere Warteschlangen zu
erstellen, wird
dadurch eine Datei erstellt, eine Que-Datei für jede Wave-Datei, die
wir hier unten haben Stattdessen können wir diese
beiden Wave-Dateien nehmen und sie
in einer einzigen Warteschlange komprimieren. Also klicken wir auf diesen
. Benennen Sie diesen in SC Underscore Gunshot Sie können sehen, dass es sich um einen etwas
anderen Asset-Typ handelt. Und im Grunde sind SN-Cues eine sehr einfache Methode, wenn wir
doppelt klicken, um sie zu öffnen Sie ermöglichen es uns, mit
mehreren Audiodateien zu arbeiten ,
ohne die Quelldatei bearbeiten zu müssen So können wir
Gunshot 1 und
71 genau so lassen , wie sie waren
, als sie importiert wurden, und wir können
hier individuelle
Überschreibungen vornehmen z. B. ob der Ton wiederholt werden
soll, wie hoch die Standardlautstärke ist
und solche Dinge Eine Sache, die man beachten sollte,
ist, dass Sie
sehen können , dass die Nails Es weiß, dass
wir, weil wir
mehr als eine
unterschiedliche signierte Datei eingebracht haben, wahrscheinlich
die Reihenfolge, in der sie abgespielt werden, zufällig
bestimmen wollten die Reihenfolge, in der sie abgespielt werden, ,
was wir Nachdem diese Randomisierungen vorgenommen
wurden, wollen
wir jedoch von
hier aus nach etwas
suchen, das man Modulator
nennt Oder Sie können ihn sogar direkt hier unten
sehen. Wir werden das Ergebnis
unseres Modulators
in den Ausgang einstecken unseres Modulators
in den Ausgang einstecken Dadurch wird also zwischen dem Sound umgeschaltet
, der abgespielt werden soll. Es wird
eines davon randomisieren. Ich werde
einen Modulator einbauen, damit wir den
Ton leicht anpassen können Und was auch immer
das Ausgabeergebnis
ist , es wird dem Endbenutzer
vorgespielt Der Modulator ist
immer noch ausgewählt. Sie können sehen
, dass die Hauptsache, die ich
hier außer Kraft setzen wollte, die minimale
und die maximale Tonhöhe ist Das wird nur
dazu beitragen, dass wir
zwar nur zwei Sounddateien
haben, diese
aber nicht
exakt gleich klingen, wenn wir
sie potenziell hunderte oder wie viele Male hintereinander abfeuern . Ich gebe beiden eine
ziemlich große Tonhöhenverschiebung, also setzen wir 12,5 und
die andere auf 1,5. Und wieder, das können ziemlich extreme Werte
sein, und wenn der Sound zu verzerrt
ist, dann können wir
hier zurückkommen und anfangen langsam zu verfeinern, bis er genau so
klingt, wie wir es Das Gleiche gilt für die
Lautstärke, wir können einen
auf 0,9 und einen auf 1,1 einstellen auf 0,9 und einen auf Wir haben also bei
jeder Wiedergabe
für beide Soundeffekte einen ähnlichen Offset zur Mindest- und Höchstlautstärke Mindest- und Höchstlautstärke. Also das war großartig. Wir
konnten sehen, dass das definitiv genau so
wirksam wurde, wie wir wollten, mit einer kleinen Einschränkung Gemeinsames Problem mit
dem alten Q-System , das wir hier verwenden Die Randomisierung ist nicht
wirklich zufällig. Sie können sehen, dass es
einfach ein Hin- und
Herschalten zwischen
den beiden Optionen Es wird A, dann B, dann A, dann B abgespielt . Ziemlich vorhersehbar Wenn wir uns also unsere zufällige Note schnappen, wollen wir zum
einen das Häkchen hier entfernen, das Randomisieren
ohne Ersatz Etwas, das die Leute
oft übersehen. Aber wenn wir jetzt auf Play drücken, müssen
wir sie uns nicht unbedingt anhören,
also schalte ich
die Lautstärke einfach schnell stumm Aber
überprüfe noch einmal, ob du
sehen kannst , welches Kabel abgefeuert wird. Und was wir sehen sollten, ist, dass ich dort etwa vier oder
fünf Klicks
hatte, während ich
dieselbe Audiowiedergabe bekam, die eher einer
echten Randomisierung als
dem Flipflop zwischen A und B näher kommt.
Natürlich würden Sie das auch
tun wollen, wenn Sie in Ihrer einzigen Warteschlange eher einer
echten Randomisierung als Flipflop zwischen A und B näher kommt. mehrere Schallwellen darüber
hätten mehrere Schallwellen darüber Wenn du also fünf oder sechs hättest, würdest
du nicht wollen, dass es eins, zwei, drei, vier, fünf, eins,
zwei, drei, 45 und so weiter ist. Sie möchten, dass es
zufällig zwischen
diesen fünf oder sechs Soundeffekten wählt . also immer daran
, reinzukommen und Häkchen „Ersatzlos zufällig“ zu entfernen Nachdem das erledigt ist, wollen wir etwas
Ähnliches
mit den Explosionen machen etwas
Ähnliches
mit den Also klicke ich mit der rechten Maustaste auf
die Explosionswelle. Wir werden eine einzige
Sound-Warteschlange für diese erstellen. Wir werden das SC
Underscore Explosion nennen. Offensichtlich werden wir
keine Randomisierung
zwischen diesen benötigen keine Randomisierung
zwischen diesen Wir haben nur die einzige
Datei, aber wir können immer noch Dinge
gebrauchen, wie zwischendurch wieder
einen Modulator einzuwerfen wieder
einen Modulator einzuwerfen Also werde ich hier einfach auf die gleiche Weise
einen anderen Modulator anschließen und hier vielleicht für etwas weniger
intensive Unterschiede sorgen intensive Unterschiede Also vielleicht 0,7 bis 1,3. Und wieder können wir
zurückkommen und etwas verfeinern ,
falls das ein zu großer
Tonhöhenunterschied ist. Ich werde das Minimum und
das
Maximum der Lautstärke so lassen , wie sie sind. Und es ist nur eine wirklich
einfache Änderung, die wir in
unserer Sound-Warteschlange vornehmen Wenn Sie eher
von einem Audio-Hintergrund kommen, gibt es vielleicht andere
Terminologien und Funktionen ,
mit denen Sie auf der rechten Seite herumspielen können Sie können diese einfach in das Diagramm
ziehen, der Eigenschaft
herumspielen und sie nach Belieben
anpassen Für diese einfache Demonstration werde ich es so belassen,
wie wir es hier haben Also werde ich das ganz schnell
machen und
anfangen, einige der
Fenster zu schließen, die ich nicht benötige, vor allem die Partikeleffekte, also werden wir sie loswerden. Und wenn wir
in der Playbase anfangen, bin
ich schon da, also
werde ich mich zuerst um den
Death-Effekt kümmern. Ich werde den
Kommentar hier hinterlassen, da wir wahrscheinlich etwas später noch ein paar
Dinge benötigen werden. Also, zwischen unserem
Spawn-Partikelsystem und dem Aufruf der
Destroy-Actor-Funktion, ziehe
ich aus
dem Execution-Pin und suche nach
Play-Sounds am Standort Das ist also wieder ein wirklich nettes
Feature in Unreal. Wir haben bereits
standardmäßiges räumliches Audio eingebaut. So können wir
den Ausgangspunkt angeben von dem aus dieses
Audio abgespielt werden soll. So können wir die Dinge
etwas glaubwürdiger machen,
wenn ein Flugzeug an der
linken oberen Seite der Kamera zerstört
wird an der
linken oberen Seite der Kamera zerstört
wird , dann haben wir einen Soundeffekt, der
etwas mehr auf der linken
Seite Ihres Headsets abgespielt werden
sollte etwas mehr auf der linken
Seite Ihres Headsets Also werden wir hier die
Standardfunktion verwenden. Wir werden
Get Act Location verwenden, um
herauszufinden, wo das explodierende
Flugzeug zerstört wurde Und dann verwenden wir das Sound-Drop-down-Menü
hier und wählen unseren SC aus, unseren Sound-Cue , den wir angepasst haben, um die Explosion zu
unterstreichen Nun, wir müssen das nicht wirklich
bewerben, denn auch hier werden beide dieselben
Explosions-Soundeffekte verwenden dieselben
Explosions-Soundeffekte und beide haben ihre eigene Randomisierung
und solche Dinge Nun, ich werde
es hier nicht verwenden, aber ich wollte Ihnen auch die Funktionen
zeigen, auf die
wir Zugriff haben Wenn wir also das
Drop-down-Menü auf diesem Node verwenden, wenn Sie nicht mit Sound-Hinweisen
herumspielen wollen oder einfach nur die Regelwellendatei
verwenden wollen, können
wir trotzdem reinkommen und Dinge wie
Lautstärkemultiplikation
und
Tonhöhenmultiplikation machen Lautstärkemultiplikation
und
Tonhöhenmultiplikation Wir könnten wieder so etwas
wie einen zufälligen Float einbauen, also haben wir das
schon oft gesehen, oder
idealerweise einen zufälligen Float in der Reichweite, wie wir es schon einmal gesehen haben Und das ist dem, was wir
im Sound-Cue für
den Pitch-Multiplikator eingerichtet haben, sehr ähnlich im Sound-Cue für
den Pitch-Multiplikator Aber weil wir eine nette,
anpassbare
Sound-Warteschlange haben, mit der wir arbeiten können, verwenden
wir einfach diese anstelle
der Standard-Soundwave-Dateien im ländlichen Raum Es gibt noch viel detailliertere Dinge, auf die wir uns auch mit Dingen wie
den
Dämpfungseinstellungen befassen könnten auch mit Dingen wie
den
Dämpfungseinstellungen befassen Das ist also die Bereitstellung des
Drei-D-Soundsystems, eine Art Absenkung,
ein Bereich, in dem der Ton lauter und leiser werden
sollte,
je nachdem, wo Sport betrieben wird Dafür kopiere ich
einfach
die Funktionalität, die wir hier
haben, weil wir sie zu
unserer Feuerfunktion hinzufügen
wollen Also werden wir
den Kommentar einfach verschieben. Wir werden
wieder hierher kommen und noch ein
paar Dinge tun , wenn wir
unsere letzten Durchgänge mit den Effekten machen , also ist das immer noch relevant. Aber wir werden die
Presssteuerung in C übernehmen. Ich werde in
die Feuerfunktion wechseln. Und nachdem das Projektil
gespawnt ist, können
wir es einfach hier drauflegen Noch einmal, wir
wollen den Ort, an
dem der Feuer-Soundeffekt abgespielt werden soll Und wir
nehmen hier unseren Schuss ab,
und es wird jetzt automatisch
ein Schuss abgespielt und es wird jetzt automatisch
ein Schuss abgespielt , wann immer
etwas Das liegt daran, dass ich denke, wenn vier oder fünf Gegner
auf dem Bildschirm sind und sie alle schnell
hintereinander schießen, sollten
wir vielleicht ihre Lautstärke
verringern Also ich denke, was ich
tun werde, ist, anstatt separate Feuerfunktionen
in jeder Klasse zu
haben, werden wir, wo wir können, Vererbung
nutzen . Ich werde
den Volumenmodifikator hochstufen und ihn zu einer Variablen
heraufstufen, und das nennen wir
Fire Volume Offset Wir können dies also standardmäßig
auf den Wert Eins setzen, was es bereits war Also werden wir
standardmäßig
die volle Lautstärke des
Schussgeräuschs abspielen . Wenn wir das also so eingestellt haben, dass es
hier mit
dem Modulator ein wenig randomisiert wird, könnte
die Standardlautstärke natürlich hier mit
dem Modulator ein wenig randomisiert wird, könnte
die 0,9 in Richtung 1,1
sein Wir werden das dann überschreiben und
entweder das mit einer Summe
von eins multiplizieren oder zum Beispiel für die
Feinde Der Grund, warum ich das verwenden möchte, ist, dass wir auf Kompilieren und Speichern klicken. Ich werde in
die Feindesklasse gehen. Wir werden den Wert
hier anhand der Eigenschaften ermitteln. Ich gebe dem standardmäßig einen
Volumenversatz von 0,5. Wir werden also die
Standardlautstärke für feindliche Schüsse
haben . Selbst wenn sie anfangen, sich ein wenig zu
stapeln, sollten
sie nicht völlig
unerträglich werden und, wie ich schon sagte, völlig
überreizend Okay, also ein wirklich schneller Spieltest. Ich fand heraus, dass die Schüsse
wahrscheinlich ungefähr so laut
oder vielleicht lauter waren wahrscheinlich ungefähr so laut
oder vielleicht lauter als
die Ich denke, was ich tun werde, ist, eine Mindestlautstärke festzulegen, eine Mindestlautstärke festzulegen,
und das hängt
möglicherweise von den
Anzeichen ab
, die ich gefunden habe von den
Anzeichen ab
, die ich gefunden Sie wurden wahrscheinlich
nur exportiert, nicht mit einem guten
normalisierten Volumen Also vielleicht werden
wir das standardmäßig auf 0,5 bis
vielleicht
0,7 oder vielleicht 0,4 bis 0,7 erhöhen. Und
wir werden sehen, wie sich das anhört. Okay, nach einer ganzen Reihe
von Optimierungen
habe ich festgestellt, dass ein
guter Wert 0,1 und
0,2 für ein Minimum und ein
Maximum für die Standardeinstellung waren ,
und dann werden wir das beim Feind noch niedriger
nehmen, indem wir hier diesen
Lautstärkeversatz hinzufügen Das ist also nicht das Ende
der Welt. Wie ich schon sagte. Vermögenswerte sind absolut praktikabel, aber das sind nur
nützliche Dinge, auf die
Sie
achten sollten und die Ihnen vielleicht ausgehändigt werden, oder Sie könnten Vermögenswerte von
Marktplätzen und ähnlichem finden, und einige wurden vielleicht
einfach
mit einem völlig
anderen Volumen exportiert mit einem völlig
anderen Es ist also nützlich zu wissen, dass wir mehrere Stellen haben, wir verschiedene
Volumenoffsets und
ähnliches anwenden können Volumenoffsets und
ähnliches Ein Projekt oder ein vollständiges
Produktionsspiel. diesem Grund ist es auch
sehr wichtig, so etwas wie
ein Einstellungsmenü mit
einigen wirklich flexiblen
Audio-Schiebereglern zu haben einigen wirklich flexiblen
Audio-Schiebereglern , damit die Leute wählen
können, ob
sie ihre Soundeffekte entweder
leiser oder lauter machen wollen als ihre Musik und ihr
Voice-Over und so. Und zum Wohle aller
Ohren, auch meiner, stellen
Sie bitte Ihre
Standard-Master-Lautstärke auf etwa 50% ein Niemand mag es, das Spiel einzuschalten und sein
Trommelfell durch eine
100-prozentige Master-Lautstärke zerstört
zu bekommen ,
wenn Ihr Spiel eine völlig andere
Lautstärke eine völlig andere
Lautstärke hat als alles andere, was das System
möglicherweise gespielt hat Audio kann also wirklich sehr
wichtig sein und einen wirklich guten oder schlechten
ersten Eindruck auf dein Spiel hinterlassen,
je nachdem, wie du es verwendest Aber auch das ist einfach
etwas anderes, das
du anpassen
und mit dem du herumspielen solltest Hören Sie sich an, was Sie über
die Schüsse auf Ihrem System
im Vergleich zur Explosion denken die Schüsse auf Ihrem System
im Vergleich zur Explosion Finden Sie heraus, wo Sie die Lautstärkeregler
ändern möchten, die
verschiedenen Que-Optionen aus
, die ich
Ihnen gezeigt habe, um zu versuchen, dass
Ihr Spiel gut gemischt
und so interessant wie möglich klingt,
auch wenn wir nur
ein paar verschiedene
Audiodateien zum
Spielen , die ich
Ihnen gezeigt habe, um zu versuchen, dass Ihr Spiel gut gemischt
und so interessant wie möglich klingt , haben ein paar verschiedene
Audiodateien zum Sie können auch
verschiedene Websites besuchen, HIO, Freesound und
ähnliches, um
einige neue Soundeffekte herunterzuladen und zu sehen, was Sie dem Projekt hinzufügen
können , um es wirklich
zu Ihrem eigenen zu machen. Die Hauptsache, nach der
du suchst, ist das Spiel
einfach ein paar Minuten
lang zu spielen Fängt
nach der 32. Minute etwas an, nervig zu werden? nach der 32. Minute etwas an, nervig zu Und wenn ja, können Sie das
einfach beheben, indem die allgemeine
Lautstärke in der Sound-Warteschlange
reduzieren Oder falls nötig, wie ich schon sagte, sollten
wir vielleicht sogar
reinkommen und
dem Feind den Schuss wegnehmen dem Feind den Schuss wegnehmen weil das so oft passieren
wird Keine davon sind klare spezifische Regeln, die
wir befolgen müssen Wie bei vielen anderen
Dingen wird es nur eine Menge
Versuch und
Irrtum geben, um
herauszufinden, was funktioniert und was sich am besten
auf Ihr Endergebnis auswirkt. das
Audio-Feedback abgeschlossen ist, ist
das Spiel nun
präsent und bietet visuelles und akustisches Feedback Als Nächstes werden wir tatsächlich zu
den Spawn-Animationen übergehen, die nur eine
optionale Ergänzung zu
dem visuellen Flair sind, das wir bereits zu unserem Projekt
hinzugefügt haben
26. 25 - SpawnAnimations: Die letzte Schicht Feinschliff, lasst uns unseren Schiffen ein großes Intro
geben. Wir lassen sowohl den Spieler
als auch die gegnerischen Schiffe hineingleiten und sich
in Position drehen anstatt einfach nur zu existieren. Noch einmal, eine Animation in der Basisklasse
, die für
alle Flugzeuge funktionieren wird , mit denen
wir arbeiten wollen Aus diesem Grund gehen
wir direkt in unsere
Inhaltsschublade, den Ordner mit den
Bauplänen, den
Kern und
finden dort die Basis der
BP-Unterstrichebene Wir möchten zurück
zu unserem Hauptereignisdiagramm navigieren und neben unserem Startvorgang klicken
wir mit der rechten Maustaste
und suchen hier nach einer praktischen Funktion
namens Zeitleiste hinzufügen Es ist also diese Option
unten. Wir können dem einen Namen geben.
Es ist eine Art Funktion , die über ein eigenes integriertes Diagramm verfügt. Wir werden uns das
gleich ansehen, aber wir können diese Namen geben. Also nennen wir diesen einen
Anime, wie in Animate in. Wie bei allem anderen werden
diese nur
aktiviert, wenn eine
Ausführung sie erreicht. Wir ziehen aus
unserer Ausführungs-Pinhe und wollen das von Anfang an
ins Spiel integrieren Das wird also eine grafische Kurve
sein , die wir quer animieren können, und wir wollen nur sichergehen
, dass die Wiedergabe immer
vom Nullframe in der
Kurve bis zum Ende beginnt die Wiedergabe immer
vom Nullframe in der
Kurve bis zum Ende Wir haben andere Optionen, wie zum Beispiel ab einem bestimmten Punkt
abzuspielen, die Animation
zu beenden, rückwärts abzuspielen
oder was auch immer Wir wollen nur im Wesentlichen
von Frame Null bis zum Ende spielen . Das funktioniert quasi
wie ein temporäres Update, also sehr praktisch, wenn Sie
keine Konstante animieren möchten Dadurch wird jedes einzelne
Bild ausgelöst, solange die Timeline abgespielt wird,
bevor sie ihr Ende erreicht Und
solange das ausgelöst wird,
wird der
Update-Pin genau hier aufgerufen. Und wenn die Animation
fertig ist, wird der fertige Pin aufgerufen. So wissen wir, ob und wann
er noch abgespielt wird, und wir wissen auch, wann er am Ende
der Animation
erreicht ist . All das wird
sehr praktisch sein. Wenn wir also hier auf
diesen gelben Knoten doppelklicken
und das ist eine Sache, die
uns auffallen wird, dass viele der Knoten, mit denen wir
gearbeitet haben ,
unterschiedliche Farben haben Diese blauen sind die
Funktionen, die wir erstellen. Sie sehen
also immer, dass eine Funktion blau gekennzeichnet
ist Jedes benutzerdefinierte Ereignis oder ein Ereignis in der Grafik wie dieses ist
im Grunde immer noch eine Funktion, aber diese sind rot gekennzeichnet Wir haben Dinge wie
die grünen Variablen und jetzt haben wir hier
eine leicht benutzerdefinierte
zeitbasierte Funktion, unsere Animations-Timeline,
die gelb Wenn wir sie ziemlich oft sehen, können
wir darauf doppelklicken und wir werden hier eine
neue Funktion haben. Doppelklicken Sie also auf diesen
Knoten und wir befinden uns in der Timeline. Es gibt ein paar Dinge, die
wir tun wollen. Zuallererst benötigen wir
eine Spur, um mit
einer Animationskurve zu arbeiten
, um mit der Erstellung zu beginnen. Wenn wir hier also die
Plus-Spur drücken, haben
wir ein paar verschiedene Optionen Wir können im Wesentlichen eine Float-Kurve,
eine Vektorkurve, eine
Event-Track oder
Farbkurven erstellen eine Vektorkurve, eine
Event-Track . Wir wollen nur einen wirklich
schönen, einfachen Wert von Null zu Eins, also im Grunde einen normalisierten
Wert, den wir verfolgen können Also werden wir hier
einen Float-Track erstellen. Und was wirklich wichtig
ist, wir können mit der rechten Maustaste klicken und ziehen um mit der mittleren
Maustaste zum Zoomen zu gelangen, wie bei vielen anderen
Navigationen in Unreal Aber eine wirklich wichtige
Sache, bevor wir hier irgendwelche Keyframes
oder Pins
hinzufügen, wir wollen die
Länge unserer Animation festlegen Wenn wir jetzt damit beginnen, Pins hinzuzufügen, können
Sie sehen, dass wir
von einem Zeitrahmen von null auf 5 Sekunden Wir werden
diese Länge also bis auf eins reduzieren
,
und das bedeutet nur, dass
wir sofort mit einer Kurven-Timeline
arbeiten, das ist die Länge, die
wir haben wollen. Nun, der Grund, warum ich
das mache, ist, dass wir das
etwas genauer sehen werden , wenn
wir die Dinge konkretisieren, aber wir betrachten das nicht als eine Zeit. Wir machen das nicht
innerhalb einer Sekunde. Wir können uns das
im Grunde als Prozentsatz vorstellen. Das wären 0%
unserer Animation, und das wären 100%
unserer Animation. zeige dir einen praktischen
kleinen Trick, den ich etwas später
nicht mehr oft sehe. Und auf diese Weise können
wir das
dann tatsächlich so anpassen, dass es eine
Fünf-Sekunden-Animation, eine Zehn-Sekunden-Animation, eine Zehn-Sekunden-Animation, eine
halbe Sekunde Animation wird,
was auch immer wir wollten. Solange wir
das auf einen Bereich von Null bis Eins normalisiert haben , können wir das
eher als Prozentsatz behandeln Wenn wir hier nur
ein bisschen hineinzoomen, haben
wir die Kurve jetzt
etwas kleiner gemacht.
Wir können die linke Umschalttaste gedrückt halten und mit der linken Maustaste klicken und wir werden
diese Keyframes hier erstellen Wenn Sie also mit einer
anderen Animationssoftware gearbeitet haben, werden Ihnen
diese
ziemlich vertraut sein Es wird unsere
Zeit sein, dass das passiert, und die Stärke oder der Wert
zu diesem Zeitpunkt. Wenn du wie ich zufällig
herumgeklickt hast, brauchen
wir hier eigentlich nur
zwei Punkte. Also ziehe ich mit der
Maus einige dieser Punkte, diese Keyframes, und
ich werde sie entfernen Beim ersten Keyframe setze ich das
auf eine Zeit von Null und einen Wert von Zu diesem Zeitpunkt ist also genau keine der Animationen passiert Und dann ziehe
ich für den
zweiten Keyframe diesen mit der
Maus
und setze ihn auf eine Zeit
von eins und einen Wert von eins Das ist also, dass unsere Animation
jetzt zu 100% abgeschlossen ist Sie können also anfangen zu sehen, dass
wir das
als Prozentsatz und nicht
als bestimmten Wert betrachten . Eine andere Sache, die wir tun
möchten, ist, es sofort schön und
glatt aussieht. Wenn wir im Moment entlang
dieser Spur animieren würden, wäre
es nur eine
sehr flache, konsistente und etwas Wenn wir also
beide mit der Maus auswählen, rechten Maustaste auf einen
der Keyframes klicken und das auf Automatisch
setzen, erhalten wir ein angenehmes, flüssiges Ein- und
Auslassen Jetzt kannst du
damit herumspielen, wenn du willst. Sie können es übertreiben lassen,
wenn es zum ersten Mal reinkommt, oder Sie können es sehr
langsam machen, wenn es zum ersten Mal reinkommt Und das ist einer der
wirklich coolen Vorteile der Arbeit mit
solchen Keyframes Wir können mit der
Animation
herumspielen , um
sie stilisierter,
karikaturhafter zu gestalten, was auch immer
Sie suchen BDEFelt Ich werde es
trotzdem so lassen. Die letzte Sache ist, dass
dieser Track Zero oder neue Track Zero etwas ist
, das wir auch optimieren können Also werde ich darauf klicken. Ich drücke F zwei, um das umzubenennen, und gebe ihm einfach
den Namen Alpha. Denn wenn wir anfangen,
unsere Flugzeuge
so zu animieren , dass sie einfliegen, wird
das im Wesentlichen die
Alpha-Überstunden sein, die wir verfolgen, und nicht der
spezifische Rotationswert Und das
ist eine Sache, dass
Sie in vielen Beispielen, bei
der Arbeit
mit Zeitlinien, Beispielen, bei
der Arbeit
mit Zeitlinien, Leute sehen könnten, die direkt die Position
oder Rotation von
tatsächlichen Vektorwerten
über einen bestimmten Zeitraum
animieren oder Rotation von
tatsächlichen Vektorwerten , und am Ende werden Sie hoffentlich
sehen dass das ziemlich
unflexibel sein kann, denn
wiederum, wenn Sie etwas animieren das genau 7 Sekunden dauert, ,
das genau 7 Sekunden dauert,
und
Ich habe das für alle XY- und Z-Werte der Positions
- oder Rotationswerte gemacht, und dann entscheiden Sie
, dass das tatsächlich zu stark rotiert, und dass es die
Hälfte der Zeit dauern muss. Sie müssten reinkommen, die Spurlänge
ändern, alle
Keyframes
verschieben,
und das kann ein bisschen
knifflig und zeitaufwändig werden Wo ist das? Wir können das
nur einmal einstellen und haben jetzt stattdessen die volle Kontrolle über die Animation in unserem
eigentlichen Code. Das ist es. Das ist so
ziemlich erledigt. Wir haben also unsere Kurve bereit, um im Laufe der Zeit einen
Alpha-Wert zu liefern. Wenn wir also auf Kompilieren klicken
und dann zu unserem
Event-Graph hier oben
zurückkehren,
haben wir zu unserem
Event-Graph hier oben
zurückkehren, Sie
lediglich in
einen Tab innerhalb der
Animations-Timeline gebracht , die wir erstellt haben. Also gehen wir zurück
zum Event-Graph. Um also
zuerst unsere Animation von
unserem Update-Pin aus einzustellen und uns an die zu
erinnern, die ständig läuft, bis
diese
Animation beendet
ist , wollen
wir von hier aus die Funktion „
Standort des Schauspielers festlegen“ aufrufen . Das wird wieder das
Ergebnis einer LP sein, also verwenden wir einfach die Larp-Funktion
, die wir schon einmal gesehen haben Also unsere lineare Interpolation
zwischen zwei Vektoren, nicht die Interp-Zwei
oder irgendwas ausgefallenes, sondern einfach A mit einem Alpha auf Punkt
B zeigen Sie können also sehen, dass der
Grund, warum wir
das Alpha genannt haben , darin besteht, dass wir sie direkt
miteinander verbinden können und wir haben
hier bereits einen
Teil der Antwort, der nur auf
Namenskonventionen basiert Dann müssen wir nur noch
berechnen oder herausfinden was Punkt A sein wird und
was Punkt B sein wird. Um das als Konzept aufzuschlüsseln, wird
Punkt A einfach der Laichplatz
sein Wo auch immer wir beim Spawnen
beginnen , es wird Punkt A sein. Dann wollen wir eine bestimmte Anzahl
von Einheiten vor diesem Spawnpunkt erreichen ,
was unser Punkt B sein wird, etwas, das die Leute
ziemlich stolpert , wenn sie mit lauernden
Animationen
arbeiten , und das ist
verwirrend, weil
es so aussieht, als ob
es Aber wenn du darüber nachdenkst, würde
das, was ich dir zeigen werde,
die Animation ein bisschen verwirren. Was manche Leute also
tun würden , wenn sie
zum ersten Mal mit
linearen Interpolationen arbeiten , ist, dass wir wissen , dass Punkt A unser
Ausgangspunkt ist Wir können also mit der rechten Maustaste klicken und nach Standort Schauspielers
suchen Für viele Leute
könnte das Sinn machen, dass wir von unserem
Startpunkt zu einem Endpunkt gehen. Und wir könnten sagen, dass der
Endpunkt zum Beispiel ganz einfach dort
wäre, wo wir uns gerade befinden, plus einer Vektoreinheit in einer
bestimmten Richtung. Wenn wir also nehmen, wo wir uns
am Startpunkt befinden ,
und dann, sagen
wir, 300 Einheiten
vorausprojizieren sagen
wir, 300 Einheiten , dann wollen
wir dort landen. Das
wäre im Grunde unser Endpunkt. Nun, das würde sowieso nicht funktionieren, aber nur um sehr schnell
etwas Code einzufügen ,
um das zu zeigen, könnten
wir so etwas sagen wie,
wir wissen, dass X
vorwärts ist, also könnten wir den X-Standort plus 300
Einheiten weiterleiten auf dem X.
Das sieht so aus, als ob das unser Anfang und unser Ende sein
könnte. Und ich wollte
darüber sprechen und warum wir es nicht verwenden
werden,
gerade weil ich das in so vielen
Studentenprojekten
und neuen Entwicklungsprojekten
sehe , weil es
, wie ich bereits erwähnt habe, irgendwie Sinn macht. Wir haben unseren Startpunkt und wir haben unseren Endpunkt, der darauf
basiert. Aber was die Leute nicht
berücksichtigen, wenn sie
das tun , ist, dass es nicht
nur einmal losgeht. Ich denke, das ist der Punkt, an dem die
Leute ein bisschen stolpern. Ich stelle mir vor, dass das nur einmal
abgefeuert wird und dieser
Wert gleich bleibt Wenn wir also bei 000 beginnen
und 300 hinzufügen, würden
wir erwarten, 30000 als Endpunkt zu haben Aber was tatsächlich passiert, ist jeder Frame, der aufgerufen wird, erneut überprüft wird Wenn wir also bei
Null, Null, Null beginnen und dann einige Einheiten verschieben,
sagen wir, wir haben fünf Einheiten bewegt Beim nächsten Bild, wenn das
abgekühlt ist , sind wir jetzt bei 500. Das bedeutet also, dass der Endpunkt stattdessen 30500 sein
wird. Diese beiden Werte bewegen sich
dann kontinuierlich. Wir animieren
sowieso nur für diese eine
Sekunde oder wie lange
es auch dauern wird Das heißt, wir
werden zu einem Ende kommen, also sieht es so aus, als ob die
Animationen passieren, aber es wird immer und
nur ein bisschen falsch aussehen, und vielleicht sogar ein
bisschen unvorhersehbar weil diese beiden Werte ständig
überprüft und
aktualisiert
werden und
am Ende der Berechnung
ein anderes LP-Ergebnis angewendet ein anderes LP-Ergebnis wird,
falls das Sinn macht Ich wollte nur vorstellen, warum
wir
uns hier etwas Platz einräumen müssen ,
etwas Platz schaffen müssen Und wir wollen sicherstellen, dass diese Werte
gespeichert und unveränderlich sind Es ist also keine schwierige
Sache, aber ich wollte nur hervorheben, dass das relativ oft
passiert, und ich verstehe, glaube ich,
warum die Leute das tun würden Und es ist einfach
etwas, worauf Sie achten wenn Sie später versuchen Ihre eigene Animation
oder eine Anpassung
davon zu
erstellen , Ihre eigene Animation
oder eine Anpassung
davon zu
erstellen. Denken Sie nur daran, dass ein Loop einen konstanten Start
und ein konstantes Ziel
benötigt , damit eine reibungslose
Animation zwischen beiden möglich Stattdessen nehmen wir das, also schneide ich Strg X und füge die Position des
Schauspielers abrufen Wir werden das
zu einer Variablen heraufstufen und diese
eine Startposition nennen. Also nett und klar, schließ das an
und dann machen wir hier
etwas ganz Ähnliches. Und wie ich schon erwähnt habe, würde
das
sowieso nicht funktionieren , weil wir
nur eine Einheit hinzufügen. Wir
berücksichtigen nicht wirklich die Richtung, in
die das Flugzeug schaut, also müssen wir sowieso ein
bisschen mehr tun. Aber selbst wenn wir den gesamten Prozess
durchführen würden,
würde das
so, wie es ist, immer noch nicht funktionieren. Also
bewegen wir das einfach rüber, holen uns das, also schneiden wir es aus und fügen es hier ein. Wir können immer noch einen Haufen davon gebrauchen
. Nun, das Erste
ist, sich daran zu erinnern, dass die Feinde das auch
benutzen wollen, und sie werden ausgeflippt, wenn sie erscheinen. Wir wollen also nicht, dass
sie wie der Spieler
auf dem Bildschirm animiert werden wie der Spieler
auf dem Bildschirm Wir möchten, dass sie
auf der Grundlage der Richtung animiert
werden , in die sie blicken. Also werden wir nach
G Actor Forward Vector suchen . Damit wird
die Richtung ermittelt, in die der Schauspieler gedreht wird
oder in die er gerade schaut. Denken Sie an den Pfeil, den wir
auf das Projektil aufgebracht haben Ich werde im Wesentlichen überprüfen , in welche Richtung dieser
Pfeil zeigt Wir wollen das dann mit einem Wert multiplizieren
. Also nehmen wir
den Vorwärtsvektor
, der eine Richtung ist,
kein Wert, also ist das
entweder so etwas wie 11 und eins oder 100, wenn er vorwärts zeigt, oder minus 100 wenn er
rückwärts zeigt, zum Beispiel Wir werden
die Richtung multiplizieren, nicht die tatsächliche Vektorposition, weshalb wir das multiplizieren
können Wir werden
das mit einer Gleitkommazahl multiplizieren, also
klicken wir hier mit der rechten Maustaste auf den Stift, machen daraus eine
Gleitkommazahl, und wir können hier
immer noch den Wert von 300
Einheiten annehmen. Wir wollen also 300 Einheiten
in Vorwärtsrichtung bewegen . Das
können wir dann nutzen. Also wollen wir
diesen Wert nehmen und ihn zu
einem anderen Vektor hinzufügen. Und tatsächlich werden wir diesen
loswerden. Diese Notizen
werden also nicht mehr benötigt, nur um die Dinge
schön und ordentlich zu halten, und wir werden sie ein bisschen
aufräumen Und was wir mitnehmen wollen,
ist, wo auch immer wir angefangen haben, wir wollen unser XY und Z
unserer Startposition Plus 300 Einheiten in
Vorwärtsrichtung. Also multiplizieren wir unseren Vorwärts, um entweder ein negatives oder ein
positives Ergebnis zu
erhalten , je nachdem, ob wir
vorwärts oder rückwärts schauen,
und das X, und wir nehmen das
und teilen hier einige Werte auf Das Erste, was das
Lesen etwas einfacher macht
, ist, dass ich
diesen Pin zu einer Variablen heraufstufen
und diesen
einen Zielort benennen werde Wir können Alt-Taste und
Linksklick drücken, um das aufzulisten. Wir teilen den
Struktur-Pin hier auf. Und jetzt haben wir alle Knoten, die wir brauchen. Wir können das ein bisschen
aufräumen,
wir wollen eigentlich, dass unser erster
Pin unser Startort Also nochmal, nur meine
persönliche Präferenz, ich werde
die Startposition kontrollieren und hineinziehen und diese ersetzen Wir können also die Stelle, an der
wir angefangen haben, plus einen Versatz in die Richtung, in die wir schauen, um die Anzahl der Einheiten nehmen. Das wird
uns 300 Einheiten bewegen das X ist das, was wir hier
betrachten, weil X gleich vier ist. Wenn wir also den Get Actor Up-Vektor
bekommen könnten und ihn stattdessen einbauen
würden, würde
das einen Offset auf
der Z-Achse anwenden , nur weil
Z innerhalb von Unreal oben ist X ist vorwärts, Y ist seitwärts. Wir können hier also
mit einigen eingebauten
Funktionen verschiedene
Vektorpositionen hier also
mit einigen eingebauten
Funktionen Wir wollen nur darüber nachdenken,
weiterzumachen. Und dann können wir
hier nicht den vollen Wert
verwenden , weil
wir Y und Z konsistent halten wollen wir Y und Z konsistent unabhängig davon, wo
wir uns drehen oder bewegen. Also werde ich mir wieder die
Startposition nehmen, das hier unten
duplizieren und den Strukturstift
aufteilen. Und wir können hier das Y und
das Z an diese Werte anschließen, weshalb ich
das gerade aufgeteilt habe. Und was auch immer dieser Wert sein mag, also bei der Berechnung,
wie weit wir uns in unserer
lokalen Richtung
bewegen wollen , wir werden auch diese
Struktur aufteilen, und das wird unser
X-Wert sein, den wir wollen. Denken Sie also daran, dass hier sowieso nur das X
berechnet wird, also können wir diesen X-Wert nehmen. Das ist die Anzahl der
Einheiten, zu denen wir im
X- oder Vorwärtswert
fliegen wollen . Und das wird unser
Zielort sein. Also schließen wir sie an. Wir müssen vielleicht die
Dinge aufräumen und ein bisschen
verschieben ,
aber das ist völlig in Ordnung Wir können das einfach nach unten verschieben
und etwas später
zurückkommen und es
aufräumen Die Hauptsache ist, dass wir jetzt wieder zu unserer Schleife
springen können. Und auch das macht
die Dinge jetzt schön und klar. Wir geben hier
unsere Startposition und unsere Zielposition als
A- und B-Argumente an. Wenn wir also reingehen, könnten wir das
wahrscheinlich testen nur um sicherzugehen, dass hier definitiv etwas passiert. Und wir können sehen, dass das
Spielerflugzeug definitiv ein
wenig
nach vorne rutscht dort
definitiv ein
wenig
nach vorne rutscht, genau wie
das gegnerische Flugzeug. Es rutscht also hinein und bewegt sich dann
von einer Seite zur anderen. Wir können also sehen, dass die
anfängliche Animation funktioniert, und das
Gleiche gilt für den Spieler, was bedeutet, dass wir wahrscheinlich
unseren Player-Start nehmen
und ihn
etwas weiter
hinten starten wollen Player-Start nehmen
und ihn
etwas weiter . Tatsächlich
können wir einfach herkommen. Etwas anderes, das Ihnen
vielleicht nicht bewusst ist. Und das ist sehr
praktisch, weil wir
unseren Standort ermitteln können , weil wir wissen, dass wir an dieser
Stelle auf dem Bildschirm landen wollen , und wir können hier -300 eingeben Wenn wir also -300 eingeben, funktioniert
das eigentlich
als mathematische Gleichung, das ergibt uns -190 -300, und wir erhalten genau minus 490, was unser Startpunkt sein wird, und dann fliegen wir rein und landen genau
dort, wo wir vorher waren. Das sieht also wirklich ein
bisschen interessanter aus. Ich finde das sieht ziemlich cool aus. Das ist also definitiv
ein guter Anfang. Und Sie können
hoffentlich sehen, wie diese Mathematik zusammenkommt und funktioniert. Und wieder haben wir dafür gesorgt, dass
das funktioniert, indem den
Vorwärtsvektor des Schauspielers berücksichtigt haben. Die Art und Weise, wie er
gedreht wurde und nur um noch einmal zusammenzufassen ,
warum das relevant ist,
liegt darin, dass wir, wenn wir
in den Gegnern spawnen, sie um
180 Grad drehen, damit sie sie um
180 Grad drehen, damit sie der Zeigerichtung
unserer Spawner-Klasse
entsprechen Sie bewegen sich also vorwärts, je nachdem
, ob sie zeigen,
was bedeutet, dass alles auf die richtige Weise
animiert wird Das ist also der erste
Teil des Puzzles. Der zweite Teil wird das Ganze noch
interessanter
machen , indem er auch einen
Rotationsversatz bietet. Nachdem wir die Position des Schauspielers festgelegt
haben, wollen wir nur
das visuelle Element
der Rotation beeinflussen , weil
wir nicht mit dem
Sphärenbeschleuniger
herumspielen und möglicherweise die Art und Weise
ändern wollen mit dem
Sphärenbeschleuniger
herumspielen und möglicherweise die Art und , wie die Schauspieler zuschauen. Also machen wir das einfach
zu einer visuellen Änderung und nicht zu einer
tatsächlichen Position oder Änderung Um das zu tun, bekommen wir
oft Dinge wie, wir verwenden stattdessen das statische
Netz. Wir ziehen das in den Boden, wir ziehen
daraus und
suchen nach einer festen Weltrotation. Also ähnliches Ding, aber jetzt beeinflussen wir stattdessen
nur das Mesh. Und das ist viel besser
, weil wir sowieso keine Kollisionen oder irgendetwas
Wichtiges mit dem Netz machen Kollisionen oder irgendetwas sowieso keine Kollisionen oder irgendetwas
Wichtiges mit dem Netz Das ist nur dazu da
, visuelle Dinge zu tun, und das ist eine visuelle Veränderung Also schließen wir das an,
damit es sofort aufgerufen wird, und wir werden etwas sehr Ähnliches machen Wir nehmen
unseren Alpha und machen einen Loop Also ziehen wir von hier aus
und suchen erneut nach Loop, P Rotator, und wieder bekommen wir dasselbe, A
und B mit einem Alpha Das ist völlig optional.
Sie könnten das Alpha zu einer Variablen heraufstufen, nur um es in dieser Funktion zu
verwenden. Ich
möchte
aber noch etwas anderes vorstellen, ist, dass wir das einfach tun
könnten. Ich habe zweimal auf das Kabel geklickt. Und nochmal, nur um die
Dinge ein bisschen aufgeräumter zu halten, werde
ich
die Alphas einfach auf diese Weise anschließen Weil dies
die einzigen zwei Male , dass wir es hier verwenden werden, denke
ich, vielleicht machen wir
eine Trakt-Variable nur für dieses
einmalige Feuerereignis, vielleicht ein bisschen Deshalb werde ich nur
die Verwendung von Reroot-Knoten vorstellen. Dadurch bleibt das Ganze immer noch etwas aufgeräumt und es ist einfach, es zu
visualisieren und damit zu arbeiten Und für das A&B werden
wir hier wieder etwas sehr
Ähnliches machen, aber wir werden
die Rotationswerte Also solltest du vielleicht anfangen, einige der
Dinge hier aufzuräumen Hier können
Sequenzen, wie
ich bereits erwähnt habe , wirklich gut sein Also sehr schneller Cutaway hier. Wir möchten möglicherweise damit beginnen, zu verfolgen, was wir tun,
um Werte zu initialisieren, im Wesentlichen, wenn wir Werte setzen und fracken, wenn das Spiel Das wird normalerweise als Initialisierung bezeichnet
. Und ich denke, ich könnte das
von unserer eigentlichen
Timeline-Animation
trennen von unserer eigentlichen
Timeline-Animation So nett und einfach, auch diese Referenzfaktoren dauern
wirklich nicht lange. Wenn wir
hier
vom Ausführungs-Pin ziehen und nach einer Sequenz suchen
, wird
diese automatisch verknüpft. Wir
ändern also nicht wirklich etwas. Auch hier geht es nur darum, die Reihenfolge zu
organisieren
, in der die Dinge behandelt werden. Ich lösche diese
Knoten einfach hier und verschiebe dann
die Animation nach Dine Und wir werden sicherstellen, dass
wir zuerst alle Variablen
bereit
haben,
und wenn wir dann alle Variablen verfolgt
haben, die wir für die dann verwenden
werden, werden wir
unsere Animation aufrufen, um sie abzuspielen Also nochmal, alles
, was das macht,
ist , die Dinge
ein bisschen aufgeräumter zu halten, einfacher zu lesen und
einfacher zu handhaben Das heißt, wir können jetzt damit beginnen , einige davon zu entfernen, weil wir all diese
standortbezogenen Prüfungen zuerst haben wollen Das ist also immer noch unsere
Startposition. Und danach werden
wir auch unsere Start-Rotation haben wollen . Von hier aus können wir also auf dem statischen Mesh nach
der
G-Welt-Rotation suchen auf dem statischen Mesh nach
der
G-Welt-Rotation ,
genauso wie wir es zuvor getan haben. Ich ziehe unser statisches Mesh, wir
verwenden die G-Welt-Rotation. Und wie wir es
mit den Standorten gemacht
haben, nehmen wir einfach diesen Wert und
machen daraus eine Variable. Und das aus
genau demselben Grund. Wenn wir das
in einer Animation verwenden, möchten
wir nicht, dass sich dieser Wert im Laufe der Zeit
ändert. jedoch, Wir beginnen unsere Rotation jedoch, wenn
wir in der Welt erscheinen Das ist unser Startpunkt,
und wir werden auch
einen permanenten Ausgleich zu diesem Punkt
als permanenten
Zielpunkt haben einen permanenten Ausgleich zu diesem als permanenten
Zielpunkt Das können wir jetzt ein
bisschen einfacher machen. Wir benötigen kein eigentliches
Ziel für das B. Sie können eine Variable als Ziel
heraufstufen, wenn Sie möchten, aber das ist ein
bisschen einfacher. Für unsere Start-Rotation werden
wir die
Start-Rotation einfach auf A fallen lassen, sodass wir von dort
aus rotieren. Und dann unser Ziel. Also B, wir können
den Strukturstift
hier einfach teilen , weil wir
nur berücksichtigen
wollen, dass wir eine
720-Grad-Rollrotation machen. Zumindest
haben sie das in dem Beispielprojekt gemacht. Und auch hier stellen wir
das nur etwas
aufgeräumter wieder das nur etwas
aufgeräumter Wir könnten
also
unsere Startrotation hierher ziehen und den Strukturstift
teilen Wir wissen, dass Y
und Z gleich bleiben sollen. Wir wollen keine Drehung
nach oben oder von oben nach unten hinzufügen. Wir drehen uns nicht
um uns selbst herum. Wir wissen, dass wir sagen, dass
das statische Netz immer bei einer Drehung um
Null
beginnt , weil wir das
nicht geändert haben Und selbst bei den
Feinden rotieren wir ihren gesamten
Akteur zunächst
ihren gesamten
Akteur und nicht ihr statisches
Netz. Das bedeutet, dass wir dem X, das sich um sich selbst rollt,
mit großer Sicherheit
eine Drehung um 720 Grad hinzufügen
können X, das sich um sich selbst rollt,
mit großer Sicherheit
eine Drehung um 720 Grad . Denken Sie daran, was wir
tun, damit es sich auf diese Weise
um sich selbst dreht. Wir machen hier eine sehr
ähnliche Sache. Wenn wir also auf Kompilieren und Speichern klicken, können
wir das testen,
und das sollte auch hier funktionieren. So nett, einfach. Sie können sehen, dass das einwandfrei
funktioniert. Das wollten wir also,
eine Drehung
um 720 Grad oder zweimal um sich selbst. Wenn Sie wollten, dass es
nur eine einzige 360°-Bewegung ist, sodass sie sich
etwas langsamer drehen, können
wir das auf jeden Fall
wieder herunterdrehen, sodass es nur ein einziger Wurf ist,
oder Sie könnten ein
bisschen wild werden , vielleicht fünf
verschiedene 360°-Rotationen machen lassen, und es wird sich hier
ziemlich oft drehen Damit du Spaß haben kannst. Sie können
damit genau so herumspielen, wie Sie möchten. Wie gesagt, ich glaube, von
dem Referenzprojekt, das wir nachzubauen
versuchen, glaube
ich, dass es
nur eine 720-Grad-Drehung war , die sie da gemacht haben So können wir das also anwenden. Nett und einfach. Wir brauchen
nicht wirklich ein bestimmtes Ziel, denn es ist nur die Startdrehung mit einem Offset von 720 Grad, damit
sich das zweimal dreht. Dies überbrückt auch eine große Sache , die uns lange gefehlt
hat, obwohl wir den
Code in unserem Projekt fertig hatten. Und das ist so, dass der Spieler und die Feinde sich nicht
wirklich Seite an Seite
bewegen sollten , bis sie ihre
spornen Animationen gemacht haben Auch dies dient nur der Parität
mit dem Beispielprojekt. Wenn du es anhand
der Inhaltsbeispiele
abspielst, wirst du feststellen, dass
du die Schiffe erst steuern und bewegen
darfst steuern und bewegen , wenn sie diese
Intro-Animation beendet haben Das können wir also tatsächlich
nutzen. Wir haben unsere
Bewegung bereits aktiviert. Das wurde
immer überprüft, also haben wir einfach nichts damit
gemacht. Also können wir das jetzt
aus unserer Basisklasse holen. Wir können dies
standardmäßig auf false setzen, sodass wir zunächst keine
Bewegung zulassen. Wenn wir also reinkommen und die Play-Taste drücken, stecken
wir jetzt völlig fest, genau wie
der Feind, was wir eigentlich wollten. Und hier war es wichtig, Ihnen
das Animationssystem näher
zu bringen . Denn denken Sie daran, ich habe gesagt
, dass es uns alle Informationen mitteilt,
während die Animationen noch laufen
, hier aufgerufen werden. Und
sobald die Animationen fertig sind, wird das aufgerufen. Also können wir jetzt
von hier aus ziehen oder wir könnten einfach die aktivierte
B-Bewegung einziehen. Das würde uns genau hier
einen Setter geben, und wir könnten diesen Wert
erst auf „true“ setzen , wenn die
Intraanimation fertig ist Also können wir jetzt reingehen und testen,
wir können spielen. Wir werden uns nicht bewegen
können, bis die Animation fertig
ist. Also nochmal, völlig optional, aber ich versuche nur, dies so
nah wie möglich an das
Beispielprojekt heranzuführen nah wie möglich an das
Beispielprojekt Es ist eine Funktion, die sie implementiert haben, also dachte ich, ich würde das hier
behandeln Das ist aber so ziemlich alles.
Es funktioniert technisch gesehen. Wie bei allem
wollte ich mit dir ein bisschen
tiefer tauchen. Das ist definitiv eine 100-prozentige Option, aber ich finde, es ist wirklich,
wirklich wichtig, etwas über
die Zeitlinien zu wissen und eine Möglichkeit
, die
Wiedergabegeschwindigkeit unserer Animation zu manipulieren Wiedergabegeschwindigkeit unserer Animation ohne in
den Event-Graph springen zu müssen Eine Sache, die
ich meiner Meinung nach tun möchte,
nur eine letzte Sache, die ich noch nur eine letzte Sache optimieren
muss, ist,
dass ich mir den Knoten hier schnappen werde
, und ich werde ihm eine etwas übertriebenere Bewegung
geben übertriebenere Es wird quasi
hineinrasen und dann im Laufe Animation immer weniger Das ist also rein visuell, aber das gibt Ihnen ein gewisses Maß an
Freiheit bei der Wahl, wie glatt oder scharf einige
der Animationen sind Ich möchte also nicht, dass es zu weit geht. Wenn wir eine solche Kurve hätten, sie tatsächlich über den Zielpunkt
hinausgehen
, der
ungefähr hier wäre Die Zielpunkte hier würden
also über
diesen Zielpunkt hinausgehen, und dann würde sie
wieder zu ihrem Zielpunkt animiert Das würde also ein bisschen komisch aussehen. Lass uns einen kurzen
Blick darauf werfen. Es wird sogar besser, wenn ich auf Simulieren klicke. Man kann sehen, dass der Feind seinen Zielpunkt
weit hinter sich gelassen hat
und zurückanimieren musste Also pass auf, dass du so etwas nicht
tust, aber ich könnte es ein
bisschen schärfer machen, damit wir nur ein
bisschen schneller reinkommen Ein bisschen schwer zu
erkennen, weil es
diese Ladezeit gibt, aber das ist wahrscheinlich
völlig in Ordnung Was ich
aber vorstellen
wollte, ist, wie ich bereits erwähnt habe,
eine Sache, die ich bei
vielen Entwicklern
sehe , ist, dass sie das vielleicht
versuchen und denken
: Oh, eigentlich ist 1
Sekunde zu schnell. Ich möchte, dass
diese Animation 3 Sekunden dauert. Also musst du wieder
hochkommen, deine Länge anpassen, deine Keyframes nehmen,
deine Keyframes quer bewegen und wieder mit den Kurven
herumspielen Sie können sich vorstellen, dass das ziemlich knifflig
wird, wenn Sie ständig
hin und her gehen müssen Also werden wir das nicht tun. Wenn Sie dann einfach
mitgemacht haben, drücken Sie die Taste ein paar Mal und wir werden die Kurvenlänge wieder auf eins zurückstellen, also die volle
Länge. Was wir
stattdessen tun können, und
das ist der Trick, von dem ich denke, dass er in Bezug auf
Zeitlinien wirklich mächtig
ist , ist, dass wir
hierher zurückkehren können und vielleicht gleich, nachdem wir
die Position und die Rotation festgelegt Wir können uns davon überzeugen, dass unsere
Zeitplaninformationen tatsächlich zu einer Komponente
verarbeitet wurden Wenn wir
diese Komponente also im
Variablenbereich ablegen , können
wir unseren Anim in den
Timeline-Details abrufen und
ihn hier einfügen. Also holen wir uns die
Informationen für Anim rein. Von hier aus können wir etwas
abrufen und
etwas finden, das als festgelegte Wiedergabegeschwindigkeit bezeichnet wird So können wir anhand der Wiedergabegeschwindigkeit sehen wie schnell diese
Timeline abgespielt wird Und wenn wir das dann hier
einbauen, haben wir jetzt volle Kontrolle, weil wir wissen
, dass wir das normalisiert haben, also haben wir es auf 0-1 Sekunden geschafft Wenn wir die
Spielgeschwindigkeit festlegen, sagen wir einfach wir arbeiten mit einfachen runden
Zahlen. Wir sagen zwei. Das wird jetzt
doppelt so schnell abgespielt, es
dauert
also eine halbe Sekunde, denn wenn es standardmäßig
1 Sekunde
abgespielt wird, ist das die Länge. Wenn es doppelt
so schnell abgespielt wird, wird
es natürlich halb so
lange abgespielt Also diese ganze
Animation wird jetzt innerhalb einer halben
Sekunde fertig sein innerhalb einer halben
Sekunde fertig Wir sehen also im Grunde genommen
wegen des Ladens nicht
einmal, dass das passiert. Ich müsste simulieren. Und ja, es ist fast
unmöglich zu sehen. Aber wenn wir das
auf etwa 0,5 setzen würden, würde
das jetzt doppelt so lange
dauern, also würde es 2 Sekunden dauern. Wir haben jetzt also eine schöne, lange, flüssige Animation, 2
Sekunden, bis sie reinkommen. Wir haben jetzt also, mit einigen
wirklich grundlegenden mathematischen Grundlagen, volle
Kontrolle darüber, wie lange das dauert Wir können das auf
etwas wirklich, wirklich Langsames reduzieren, 0,1 macht immer noch
dieselbe Kurve Es macht immer noch
die gleiche Animation, aber es nimmt jetzt die
zusätzliche Zeit je nachdem, was Sie mit der Wiedergabegeschwindigkeit hier machen
. Hoffentlich können Sie
den Wert darin erkennen ,
wie ich bereits erwähnt habe. Es bedeutet nur, dass
wir nie wieder in unsere Zeitlinie
zurückkehren müssen . Wir müssen die Kurve nie
wieder anpassen, weil wir das normalisiert haben, um es zu arrangieren Und wenn wir die Wiedergabezeit erhöhen oder
verringern wollen , können wir uns
diesen Wert einfach hier drüben holen Und ich denke, was ich tun
könnte, ich denke 1 Sekunde war wahrscheinlich
ein bisschen zu schnell, also könnte ich das auf
etwa 0,75 setzen Wir können auf Kompilieren und
Speichern klicken, loslegen und nochmal nachschauen. Ich finde, das sieht
ganz nett und glatt aus, also bin ich damit zufrieden. Aber auch hier können Sie auf jeden Fall herumspielen und die Werte anpassen Und das ist das
ganze Ziel dieser Themen, da ich Ihnen kein vordefiniertes
spezifisches Ergebnis gebe , das
Sie anstreben könnten Ich versuche, Ihnen
all die verschiedenen Möglichkeiten aufzuzeigen
, wie Sie
einige der Werte
und
Variablen, mit denen wir
arbeiten, offenlegen und extrapolieren können ,
um das Projekt wirklich zu Ihrem eigenen zu machen Wenn Sie also möchten, dass sie wirklich flott sind und dreimal rotieren, haben
Sie
mit den Variablen hier unten die volle
Kontrolle darüber mit den Variablen Du hast den
Dramatiker. Und auch hier ist
es wahrscheinlich ein
guter Zeitpunkt, um auch
über die Sauberkeit
Ihres Projekts nachzudenken auch
über die Sauberkeit
Ihres Projekts nachzudenken Wir haben jetzt viele Variablen. Also sollten wir vielleicht damit beginnen,
diese in Kategorien einzuteilen. Wir haben einige magische Zahlen, also könnten wir auch anfangen solche Dinge in eine Variable umzuwandeln. Wir könnten diese Zahl zu
einer anderen Variablen heraufstufen, sie so etwas wie
Intro-Rollenabschlüsse oder so
etwas Ähnliches
nennen . Ich
versuche es etwas klarer zu machen Es ist die Intro-Animation und nicht speziell die
Rotation, die wir am Ende haben wollen, sondern die Anzahl der
Grad, um die sie rollt Und dann könnten
wir hier die Wiedergabegeschwindigkeit der
Animation festlegen, also werden wir sie auch
auf variabel hochstufen Das ist also nett, weil
die Hauptsache, wie ich immer wieder
bei Variablen erwähne, auch wenn wir nichts
speziell mit ihnen machen, das ist großartig, weil wir nicht
in unseren Code eintauchen müssen. Wir wollen immer vermeiden,
dass wir reinkommen und uns mit fest codierten
Teilen unserer Logik
befassen fest codierten
Teilen unserer Logik
befassen Wenn wir jemals schnell etwas ausprobieren
wollten, könnten
wir uns stattdessen einfach
die Flugzeugbasis schnappen. Wir können auf Kompilieren klicken und
sicherstellen, dass das aktualisiert wurde. Wir können uns alle Variablen schnappen und hier einfach herausfinden
, dass wir
die Wiedergabegeschwindigkeit so oder so anpassen können ,
und alle Werte, mit denen wir schnell einige Änderungen
sehen wollten Wie ich bereits erwähnt habe, gilt das Gleiche für C plus Plus, und es
passiert in Blau Am Ende haben Sie
viele Variablen, also möchten Sie vielleicht
anfangen, die Dinge in nette logische Kategorien
oder so etwas
einzuordnen, aber das wäre
etwas, das Sie zwischen den Themen tun könnten. Eine weitere Sache für dich
zwischen den Themen, ein kleines Experiment
hier, weil wir uns gerade
erst
kurz mit Animationen befasst haben gerade
erst
kurz mit Animationen befasst Ich empfehle auf jeden Fall, mit Dingen
herumzuspielen. sehen, ob du es rückwärts
abspielen kannst nachdem es schon einmal gespielt wurde. Machen Sie so etwas wie
die Verwendung von benutzerdefinierten Ereignissen. Denken Sie daran, wie wir
unsere eigenen benutzerdefinierten Ereignisse erstellen können, wie wir
diese von überall aus aufrufen können. Wir könnten definitiv
etwas anschließen, um Reverse aufzurufen. Also nochmal, wenn wir versuchen,
Dinge zu vermeiden , wie wenn
das erledigt ist, wirst
du viele
Codebeispiele im Hintergrund sehen und diese schreckliche Art
von Schleifenlogik haben. Es wäre viel schöner,
wenn so etwas wie das benutzerdefinierte Ereignis, das Sie erstellt
haben, im Code aufgerufen wird
27. 26 - CameraShakeKnockback: Noch nicht fertig. Es gibt noch mehr Feinschliff, den wir diesem Projekt
hinzufügen können. Wir werden bei Kollisionen
und Kamerawackeln nach
Rückschlägen
suchen, um
sicherzustellen, dass sich jeder Treffer so
anfühlt, als ob Kollisionen
und Kamerawackeln nach
Rückschlägen
suchen, um
sicherzustellen, dass sich jeder Treffer so
anfühlt, sicherzustellen, dass sich jeder Treffer so
anfühlt Wir werden uns den
Rückschlag etwas später ansehen. Das ist ein bisschen mehr
Handarbeit als das Verwackeln der Kamera. Das fangen wir hier an. Zu Beginn gehen
wir einfach zu unserer Inhaltsschublade und stellen sicher, dass wir unsere
Ordnerstruktur eingerichtet haben. Und innerhalb des
Blueprints-Hauptordners werden
wir hier
einen neuen Ordner erstellen, und
das nennen wir einfach Camera Shake Wir können unserem Projekt einige verschiedene Arten
von Kamera-Shake hinzufügen unserem Projekt einige verschiedene Arten
von Kamera-Shake hinzufügen So können wir einige Absichten
für die Explosionen haben, und wir können vielleicht ein
paar weichere Ziele
für die Projektile haben , die
abgefeuert werden oder Auch hier liegt
es ganz bei Ihnen, je nachdem, wie viel Wirkung Sie dem Spieler vermitteln
wollten Um einen Kamera-Shake zu erzeugen, benötigen
wir eigentlich eine benutzerdefinierte Klasse, was wirklich nett und
einfach ist. Wir klicken mit der rechten Maustaste. Wir können hier oben zu unserem
Blueprint-Kurs gehen. Ich bin mir nicht sicher, wo
es in den Kategorien ist, aber wir können ganz einfach nach Camera Shake
suchen Ihr könnt sehen, weil Epic New
eine sehr beliebte
Sache ist, um sie
zu vielen Spielen hinzuzufügen, haben
sie sogar
einige benutzerdefinierte Klassen
erstellt mit denen wir arbeiten können. Wir wollen diesen hier haben,
die Kamera-Shake-Basis. Wir haben einige ältere Optionen und eine benutzerdefinierte Version davon, aber wir
werden einfach mit
der rudimentären Basisversion arbeiten , auf Auswählen
klicken und
diese Version BP Underscore Camshak Small nennen BP Underscore Wir doppelklicken, um das zu öffnen,
und wir brauchen das
Ereignisdiagramm im Hintergrund hier eigentlich nicht Ereignisdiagramm Also werde ich
das einfach
sehr schnell schließen , weil ein wirklich
einfacher Weg, in die reine
Datenansicht in
einigen Blueprints zurückzukehren reine
Datenansicht in , darin besteht,
sie zu schließen und sie mit einem Doppelklick erneut
zu öffnen Und alles, was wir wirklich sehen
müssen, sind unsere
Kamerawake-Eigenschaften genau Wir werden nichts
programmieren, also können wir einfach mit
den bereitgestellten vordefinierten
Eigenschaften arbeiten . Das Wichtigste, was wir ändern
wollen, ist, dass wir
das
Root-Shake-Muster auf „Keine“ gesetzt haben . Wir lassen das
fallen und suchen nach Perlin. Dies bietet eine
nette Randomisierung unter Verwendung einiger vorgenerierter
Perlin-Geräuschmuster Wenn Sie sich an diese Abkürzungen erinnern ich vor vielen Themen erwähnt habe, Dinge
wie das Halten der Umschalttaste und können Dinge
wie das Halten der Umschalttaste und
das Ablegen der Pfeile
hier wirklich hilfreich sein Wenn wir also bei gedrückter Umschalttaste
erneut darauf klicken, wird jede
einzelne Kategorie ausgeklappt. Und wenn wir
all diese wieder einklappen wollen, können
wir die Umschalttaste gedrückt halten und sie wieder nach oben
klicken. Und wieder, das
versteckt sie einfach gut. Da es also
so viele verschiedene Eigenschaften gibt , auf die
wir zugreifen wollen, werde
ich alles
herunterklappen,
sodass wir sie der Reihe nach durchgehen und
herausfinden können , womit wir beginnen, wir haben die Ortsamplitude
und den Frequenzmultiplikator Ich werde sie
bei eins belassen. Dies nimmt die gesamte Animation, die generiert wurde, und fügt
der Amplitude und
Frequenz auf X,
Y und Z
einen Multiplikator der Amplitude und
Frequenz auf X, für die Rotation, Position und das Sichtfeld Dies ist praktisch, wenn wir einige wirklich große Änderungen vornehmen möchten , aber im Allgemeinen möchten wir pro Punkt
arbeiten. Für den kleinen Effekt, den
wir im Moment erzielen,
vielleicht jedes Mal, wenn ein
Projektil auf etwas trifft, möchten
wir, dass die Kamera ein
wenig nach vorne springt, nur um zu zeigen, dass ein gewisser
Aufprall empfangen wurde Wir wissen also, dass das X
vorwärts ist, also können wir das nehmen
und damit beginnen,
der X-Position eine
gewisse Amplitude hinzuzufügen der X-Position eine
gewisse Amplitude hinzuzufügen Wenn wir hier einen Wert von 200 hinzufügen, ist
das eine Amplitude, eine
Art Stärke,
die angewendet wird. Und dann
gibt die Frequenz an, wie viele Rucke vorwärts und rückwärts
das abspielt Wenn wir das also bei
einem belassen, wird es jedes
Mal, wenn ein Projektil einschlägt, wie
ein netter Ruck sein jedes
Mal, wenn ein Projektil einschlägt, wie
ein netter Ruck Sie sollten vermeiden, in vielen
Fällen zu
viel Frequenz hinzuzufügen , weil sich die Leute
dadurch ein bisschen
bewegungskrank fühlen Dadurch wird es
etwas schwieriger zu lesen und zu beurteilen, was auf dem Bildschirm
passiert Aber auch hier kann all dies von Ihren
persönlichen Vorlieben, der
Art des Projekts und dem
allgemeinen Stil abhängen, den Sie hatten. Ich belasse das
bei einer für die Frequenz, und ich bedenke, dass
wir bei den anderen Achsen hier etwas
schneller vorgehen können . Ich möchte also, dass das ein
bisschen mehr von einer Seite zur anderen
wackelt , aber
mit geringerer Intensität Also werde ich das auf
40 und zehn für die Frequenz setzen. hier sind zehn vielleicht zu
viel Wackeln von Seite zu Seite, aber wenn wir das
an etwas Größeres verkaufen, können
wir
das später verfeinern , falls das ein Problem darstellt Für die Rotation werde
ich
all diese Optionen als Standard belassen . Sehr oft wollen wir
die Kamera
nicht drehen, das ist fast
mehr als alles andere
, was fast
garantiert
irgendeine Art von visuellem
Feedback verursacht , von dem
Sie definitiv
Reisekrankheit bekommen werden Es sei denn, Sie haben einen
wirklich guten Grund , sie zu benutzen, und Sie wissen,
was Sie tun Also werde ich die
Rotation völlig unberührt lassen. Ähnlich wie beim Sichtfeld können
Sie
damit herumspielen, wenn Sie möchten, aber ich möchte sie nicht zu sehr
optimieren Die letzten Dinge hier, die
Überblendung in der Nacht, wie lange es dauert,
bis sie ihren Höhepunkt erreichen
und wie lange es dauert,
bis sie vom Höhepunkt zurück zum
Nichtanimieren sind und wie lange es dauert , und
dann die , und Also werde ich dafür sorgen, dass
das 3 Sekunden dauert. Es wird eine
relativ geringe Wirkung haben, aber sie wird
eine angemessene Zeit anhalten. Also mussten wir kompilieren und speichern. Das ist so ziemlich unser Setup für die
Kamera-Shake-Klasse. Nun, da die Einrichtung der
Kerneigenschaft hier
ist, können
wir währenddessen auch ein
paar verschiedene Optionen für uns einrichten, um Dinge einzufügen und zu
testen. Also nehme ich
unsere Kamera klein,
drücke die Strg-Taste, um das
zu duplizieren, und ich erstelle
eine Variante namens Medium. Ich werde das duplizieren
und dieses als groß bezeichnen. Also könnten wir vielleicht
verschiedene Arten von Einschlägen haben, besonders bei Dingen
wie den Explosionen Ich würde wahrscheinlich eine etwas
andere, aber viel größere Wirkung haben wollen andere, aber viel größere Wirkung haben weil es sowieso nicht
allzu oft passiert, und dann können wir aus
verschiedenen Gründen
zwischen den kleinen und
mittleren Auswirkungen wechseln oder iterieren zwischen den kleinen und verschiedenen Gründen
zwischen den kleinen und
mittleren Auswirkungen Für Medium werde ich hier
reinkommen. Wir erhöhen die Amplitude auf
etwa 500, erhöhen
vielleicht die
Amplitude auf der Y-Amplitude auf 90, die Frequenz auf
15. Auch hier können wir jederzeit
zurückkommen und diese
Werte ändern, falls etwas
davon zu viel ist. Mir wurde
gerade klar, dass ich darüber
nachdachte , wie ich das einrichten
wollte. Bei Camera Shake Small sollte
die Dauer
meiner Meinung nach
0,3 und nicht 3 Sekunden betragen. Hält 3 Sekunden an. Wenn du dir vorstellst, dass ich jetzt rede,
sind es ungefähr 3 Sekunden. Der Bildschirm
hätte bei der Länge dieses Satzes gewackelt , was ein bisschen zu viel ist Also
kompilieren wir das und reduzieren es auf 0,3, weil wir
die Leute nicht visuell
überreizen wollen nicht visuell
überreizen wollen. Also können wir hier dasselbe
tun Wir setzen das auf
0,3. Wir können das vielleicht auf 0,4
setzen,
weil mehr Shake im Gange ist. Es könnte einen Grund geben, es
noch ein bisschen länger
bestehen Also setzen wir das auf 0,4.
Das Gleiche gilt für Groß. Wir wollen, dass dieser Film wirklich einen großen Kick hat,
weil es das Gefühl
haben wird
, dass er
ziemlich nah an der Kamera ist ,
wenn etwas tatsächlich explodiert, diese großen
Partikeleffekte abgespielt werden Dieser macht also Sinn er könnte ein
bisschen stärker sein Also werde ich hier tatsächlich
den
Gesamtmultiplikator ändern , um
dem Ganzen einen Kick zu verleihen Also stellen wir das auf fünf und dann die Amplitude, ich stelle das auf 900 ein Erhöhen
Sie die Y-Amplitude auf 160. Ich werde
die Frequenz bei zehn belassen. Wir wollen nicht, dass das zu sehr von einer
Seite zur anderen geht. Ich denke, der Zeitrahmen ist
vielleicht ungefähr auf
0,5 Sekunden
eingestellt oder
sie geben ihnen nur kleine Schritte, sodass sie sich
beim
Abspielen und Testen alle
merklich unterscheiden beim
Abspielen und Also nochmal, es gibt
kein Richtig oder Falsch. Ich habe vielleicht
wirklich hohe Werte erreicht,
vielleicht sogar zu hohe,
aber wir können
es jederzeit verfeinern und wieder heraufsetzen vielleicht sogar zu hohe, und
sagen, dass das
definitiv zu hoch ist. Ich sagte 900, aber bis zu 9.000. wäre fast unmöglich zu erkennen,
was passiert ist, also werden wir sicherstellen, dass
wir das wieder abschwächen Sag das nicht zu hoch. Wir müssen also nicht drei
Intensitäten testen, und wir müssen
das nur in unseren Code implementieren So nett und einfach, ist ein
vorgefertigtes System für uns bereit. Ich werde zurück zur BP
Underscore Flugzeugbasis gehen. Ich lasse sie offen,
nur für den Fall, dass ich zurückkommen und
die Werte
zu irgendeinem Zeitpunkt anpassen möchte zurückkommen und
die Werte
zu irgendeinem Zeitpunkt anpassen Innerhalb der BP-Flugzeugbasis wäre
eine der offensichtlichsten Aufgaben, mit
denen man sich
zuerst befassen sollte, die
Todesfunktion Wir haben also unser Handle
Death-Funktion. Wir haben
hier immer noch unsere Arbeit zu erledigen , falls du es
auf diese Weise finden musst. Ich habe also meinen
Todo-Kommentar, und das ist der endgültige Effekt, von dem ich wusste, dass ich
zurückkommen und ihn umsetzen wollte Also können wir hier vom
Hinrichtungs-Pin abziehen. Wir suchen nach
einer Funktion namens Play World Camera Shake.
Das kannst du gerade hier sehen. Das ist unseren drei D-Zeichen sehr
ähnlich, also unseren Richtungszeichen und
sogar unserem Partikelsystem. Also alles nochmal,
wenn man einmal angefangen zu
lernen, wie man eine
der verschiedenen Funktionen
in Unreal macht, versteht
man einigermaßen, wie man auch
die anderen Dinge macht,
falls das Sinn macht Also haben wir hier zum
Beispiel das Epizentrum, das ist der Ort, von
dem aus der
Shake abgespielt wird Also, nett und einfach, wir
werden das duplizieren, den Standort des Schauspielers ermitteln
und das einstecken Also
sollte die Kamera wackeln das Schiff
von Aber
gerade explodiert ist, und dann wird es
irgendwie Licht in Richtung Kamera
werfen, das ist die allgemeine
Idee hier. Wir machen das auf der Grundlage eines Radius, also
ist der innere Radius dort, wo dieser am stärksten
sein wird Wenn sich die Kamera also direkt
neben dem Flugzeug befindet , das explodiert, erhält
sie die volle
Kraft der Kamera-Shake-Ebene Also setzen wir das auf
etwa 2000 Radiuseinheiten. Und dann
ist der äußere Radius
der Punkt, an dem alles, was außerhalb dieser Zone liegt, wahrscheinlich nicht durch die Verwacklung der Kamera beeinflusst
wird, oder wenn es wirklich
nah ist, kann es einfach zu einem endgültigen Wackeln am Ende kommen Und ich denke, wir setzen
das auf
etwa 5.000, und auch hier können
Sie
damit herumspielen, wenn es zu viel
oder zu intensiv
passiert, Sie können den Radius ändern
und damit spielen Wie ich schon sagte, bei
den Explosionen, wenn die Schiffe tatsächlich explodieren, lassen wir das runter und
suchen nach dem
BP-Unterstrich Cam Shake Lidge, also das wird unser
Explosionskamera-Shake sein. Wir können auf Kompilieren
und Speichern klicken, und wir können diesen einfach testen,
weil wir
die Funktionalität definitiv bereit haben . Okay, das meinte ich
also, das meinte ich
also wo einige davon vielleicht
ein bisschen zu intensiv sind. Das wird also leicht
zu beheben sein. Wir können, ich denke, das
Radio sollte in Ordnung sein , weil die Kamera
nur doppelt nachschaut. Wenn die Spieler bei 130 auf
der Z beginnen und die Kamera auf
2.400 Einheiten auf der Z ist, bedeutet
das, dass wir uns
sowieso nur geringfügig außerhalb des inneren Radius einer
der Explosionen sollte also
zu einem etwas
spitz zulaufenden Verwacklungsspiel außerhalb der Kamera
kommen spitz zulaufenden Verwacklungsspiel außerhalb der Kamera Was wir tun können. Ich glaube,
ich bin einfach direkt in den Multiplikator gegangen, ein
bisschen zu hoch Aber wie ich bereits erwähnt habe, ist
das eigentlich ein sehr üblicher Ansatz für
diese Art von Dingen, den
Sie für einen vernünftigen
Wert halten, zu
verdoppeln , zu verdreifachen oder Sie für einen vernünftigen
Wert halten und ihn dann wieder einzuschränken, sobald
Sie ihn getestet haben Es erspart Ihnen, viele wirklich kleine inkrementelle Änderungen vorzunehmen , die oft noch länger
dauern können Das fühlt sich also ein
bisschen besser an, vielleicht 1.5, sodass wir eine größere Überschreibung
vornehmen können, aber die allgemeinen
Einstellungen hier unverändert lassen Und ich denke, das ist
in Ordnung. Also werde ich nicht zu lange damit verbringen, das zu verfeinern Das ist jetzt beobachtbar. kann ich mir ansehen und
mit Too Disturbed
weiterspielen, also
lasse ich es so, wie es ist Das ist also unser großer
Kamera-Shake und noch einmal, Sie können das verfeinern
und komplett an Ihr
Projekt anpassen, wie Sie möchten. Dann kommen wir zur
Frage unserer Projektile. Sollen wir jedes Mal, wenn ein Projektil abfeuert, oder jedes Mal, wenn
ein Projektil auf etwas
trifft
oder
einschlägt, dieses
Zittern abfeuert, oder jedes Mal, wenn
ein Projektil auf etwas
trifft
oder
einschlägt, dieses
Zittern etwas
trifft
oder
einschlägt Das wäre im Wesentlichen
ständiges Zittern, was etwas ekelerregend sein
könnte Also ich denke, bei dieser
Art von Projekt
könnte es besser sein, einfach etwas zu machen, das den Spieler
darüber informiert, dass getroffen wurde, weil
wir auf diese Weise
diesen visuellen Feinschliff nehmen ,
ihn aber tatsächlich in das Gameplay implementieren Eines der nervigsten
Dinge für Spieler
von Spielen, in denen Kampf
involviert ist, ist also ,
getroffen zu werden , ohne zu merken, dass
man Schaden erlitten hat, oder dass man ihn
vom Bräunungsschaden des Feindes unterscheiden
kann Das löst also zwei verschiedene Probleme,
denn im Moment bekommen
wir ein winziges
Feedback, wenn wir
getroffen werden, weil wir die
Stacheln auf unserem Aber es ist nicht ganz klar
, ob wir Schaden oder Gesundheit verlieren, bis
wir zerstört Also das könnte eine
nette Lösung dafür sein. Dies signalisiert, dass der
Spieler Schaden erleidet. Es zeigt nicht, dass der
Feind Schaden erleidet,
aber er ist trotzdem kurz davor
zu explodieren Es ist also nicht ganz so
wichtig, weil sie nicht so viele
Lebenspunkte haben, die sie durchmachen müssen Und wir geben immer noch das visuelle Feedback
, dass die Partikel das feindliche Flugzeug
treffen Das wird also ziemlich klar
sein. Eine nette, einfache Art, wie
wir das machen können,
in diesem Sinne ist, dass
wir
zu unserer Projektilklasse übergehen zu unserer Projektilklasse Projektilen In der Projektilklasse wollen wir
alles machen, was
mit Falls du noch nicht
hier bist, befinde ich mich
zufällig direkt neben
meinen To-do-Kommentaren, also gehen wir nochmal zu dem Bereich
, um Kommentare zu machen Und tatsächlich
werde ich ein
bisschen faul sein , wie ich es in der Vergangenheit
getan habe. Ich werde zum Flugzeugkurs gehen. Ich hole mir den
ganzen Code, also den Standort des Schauspielers
und die Playworld-Kamera Drücken Sie die Strg-Taste in S, um das zu kopieren. Solange ich hier bin, kann ich diesen Kommentar auch
loswerden. Wir haben jetzt tatsächlich unsere
gesamte Aufgabenliste erledigt. Wir haben all die
verschiedenen Effekte , die wir implementieren werden,
also werde ich das loswerden. Und dann gehen wir zurück zur
Projektilbasis, die in der
Spielwelt
platziert ist, die Kamera wackeln die Dinge ein
bisschen
bewegen Und die Logik ist sehr ähnlich. Also wollen wir das
Gleiche noch einmal machen. Wir wollen den Ort ermitteln , an dem der Aufprall gerade passiert ist, und wir werden von dort aus
spielen, im
gleichen Radius, weil wir immer noch wollen, dass die gleiche Art
von Kamera herunterfällt. Aber alles, was wir
tun werden, ist vielleicht zu überprüfen, ob der kleine Einschlag zunächst
groß genug ist, und vielleicht möchten wir den Wert auf mittel
ändern. Und das ist eine andere Sache.
Wenn Sie der Meinung sind, dass dies nicht wirksam genug ist,
können Sie versuchen, es zu ändern. Jeder einzelne Treffer
sorgt also für eine
Erschütterung, aber vielleicht ist
es auf den feindlichen Schiffen nur die kleine
Erschütterung und auf dem Spielerschiff eine mittlere Erschütterung. Auch hier liegt es ganz bei dir. Wir haben jetzt verschiedene Kurse. Du kannst
damit herumspielen und sehen, was funktioniert. Ich denke, für mein Projekt
werde ich es belassen, nur um darauf hinzuweisen, dass die Spieler Schaden
nehmen. Nun, es gibt eine Sache, für die wir nur ein
bisschen Platz schaffen müssen, und ich möchte Ihnen noch einmal
zeigen, ich gesehen habe,
wie Leute
versehentlich ihren Code geknackt haben. Also wir wissen, dass wir hier eine Bedingung
haben. Wir wollen nur, dass das passiert , wenn wir
das Spielerschiff angreifen. Was Sie also tun könnten, ist, dass Sie hier einen Ast
werfen, also werden wir einen Filialcheck
durchführen. Und wir wollen das überprüfen. Wir wissen bereits,
dass wir das Ding
verfolgen, auf das wir treffen, also können wir unseren
überlappenden Akteur nehmen Ich glaube nicht, dass
das alles irgendwie neue Konzepte für dich Also, wir duplizieren das,
also werde ich
meinen Überlappungsdarsteller holen und sicherstellen, dass ich den halte. Drücken Sie
in der Tat die Strg-Taste, um zu duplizieren. Und wir wollen überprüfen, ob das
Ding, das wir überschneiden,
wir wissen, dass es nicht der Besitzer ist, wir haben das Problem bereits hinter Aber wenn es gleich ist und wir das schon einmal
gesehen haben, können
wir Get PlayerPawn verwenden Wenn es also dem Ding
entspricht, das derzeit
als PlayerPawn registriert
ist, wollen
wir dann den World Camera Shake abspielen,
nur wenn das
stimmt World Camera Shake abspielen,
nur wenn das Also haben wir das Ganze einfach ein bisschen aufgestockt. Und Sie haben wahrscheinlich
gesehen, dass dies nicht gerade das größte
Problem oder Problem ist, das es zu lösen gilt. Einige von Ihnen
haben es vielleicht schon gesehen, aber wenn das nicht stimmt, wenn das falsch ist, wenn
es etwas anderes ist, dann blockieren wir
diesen Funktionsaufruf hier. Denken Sie also daran, dass
Sie sich nur mit
der Reihenfolge der Operation und
der Flusskontrolle Ihres Codes vertraut machen müssen. In geschriebenem C plus Plus ist das
viel einfacher, weil
wir
FL-Anweisungen verwenden werden , die wir einfach innerhalb
des Funktionskörpers
löschen können . Es ist also viel einfacher,
den Überblick zu behalten. In Blueprints ist es sehr einfach,
versehentlich zu verhindern, dass der Rest
der Funktionalität ausgeführt wird, wenn eine einzige
Zweigprüfung durchgeführt wurde Ich wollte damit nur
erwähnen, dass,
wenn Sie diesem Ablauf folgen bei dem Sie nur additiv Ihren
Code
aktualisieren und verbessern oder Funktionen hinzufügen,
es sehr leicht ist, dass wir uns nicht versehentlich selbst
zerstören,
wenn der Feind jetzt getroffen
wird wir stattdessen
tun könnten, ist also, dass wir all das
mithilfe einer Sequenz lösen könnten Wenn ich also einfach weitermache,
und das ist wirklich nur, um zu verdeutlichen, wie wichtig es ist,
über
die Sauberkeit des Codes nachzudenken,
nicht nur, um Zeit zu verschwenden und den Code in Blueprints
hübsch aussehen zu
lassen,
sondern auch, weil es buchstäblich
das Lesen und
Verwalten erleichtert und sicherstellt
, dass Sie
diese wirklich leicht
zu machenden wie wichtig es ist,
über
die Sauberkeit des Codes nachzudenken, nicht nur, um Zeit zu verschwenden und den Code in Blueprints
hübsch aussehen zu
lassen, sondern auch, weil es buchstäblich sondern auch, weil es buchstäblich
das Lesen und
Verwalten erleichtert Fehler nicht machen Fehler nicht machen Wenn wir also unsere Sequenz
hier und wieder einfügen, wollen
wir uns das irgendwie als
eine bestimmte Funktion
vorstellen , die in unserem Fall
darin besteht, Schaden zuzufügen,
und ich könnte versucht sein, alles zu tun
,
was und ich könnte versucht sein, alles zu tun dann nicht mit Schaden zu tun hat,
alles, was mit dem Abspielen eines Effekts zusammenhängt
. Wir werden
in die zweite werfen. Also drücke ich einfach Strg X. Und wir
werden sie anschließen. Also werden wir zuerst
Schaden anrichten. Und wenn dann Schaden angerichtet wird, spielen
wir
unseren Partikeleffekt und unseren
Kamerawake ab, aber nur für den Spieler. Und dann werden
wir die letzte Sache machen. Also nochmal, es gibt uns eine
nette Reihenfolge der Abläufe. Wir können die genaue Reihenfolge sehen ,
in der unsere Funktionen
aufgerufen werden. Und wie ich
bereits erwähnt habe, als wir uns Sequenzen angesehen haben, würde
das
Ganze etwas klarer werden, wenn Sie
diese Kommentare abgeben würden. Das könnte also die Schadensreihe sein. Das könnte die Effektzeile sein, und das könnte die Clear-Up-Reihe oder
so ähnlich sein. Und daran könnten Sie
sich in Kommentaren erinnern. Also nochmal, nur eine wirklich
schnelle, einfache Änderung, und wir wissen jetzt, dass
wir unabhängig
davon , ob das
abgefeuert wird oder nicht, definitiv
immer unseren Schauspieler
zerstören werden, denn
wenn das überprüft wurde , wenn
es aufgerufen wird, geht zurück zum nächsten Teil
der Sequenz und kommt zurück. Wenn das nicht aufgerufen wird, geht
es trotzdem
zurück zum nächsten Teil der Sequenz und dann wieder
runter. Das Wichtigste ist also , dass es trotzdem
aufgerufen wird. Jetzt können wir reingehen und
testen und es einfach noch einmal überprüfen. Bei den
Feinden passiert das nicht. Das war also die Explosion.
Die andere Sache ist also, dass, wenn sich die Projektile gegenseitig getroffen
hätten, dies möglicherweise zu Kamerawackeln geführt
haben könnte Kamerawackeln als sich
die Projektile auch
gegenseitig trafen Also werde ich mich jetzt einfach treffen
lassen, ohne
dass etwas
anderes Da haben wir's. Damit du irgendwie sehen kannst, ob ich nicht
gleichzeitig sterbe. Man kann sehen, vielleicht ein bisschen zu
schwer, um getroffen zu werden, aber man kann ein Wackeln der Kamera sehen, was das Wichtigste ist. Wie ich bereits erwähnt habe,
ist das vielleicht zu subtil. Wenn das so ist, ist das
völlig in Ordnung, denn wir haben unseren Medium-Shake
, den wir testen können. Wenn wir wirklich klarstellen
wollten, dass die Spieler
getroffen werden. Da haben wir's. Das ist also ein viel
größeres Anzeichen dafür, dass man getroffen wurde. Auch hier persönlich denke ich, dass der kleine völlig in Ordnung
ist. Wir möchten vielleicht
ein bisschen mehr
Stärke hinzufügen , aber
die Frequenz gleich lassen oder so,
aber nur als Vorwarnung, dass sie ihre Gesundheit
verloren haben , ich denke,
das ist klar genug. Im nächsten Schritt werden wir uns mit
Dingen wie Materialien befassen und
ein blinkendes Material herstellen , das
gesundheitsschädigend ist oder so, falls ihr das wirklich visualisieren
wollt Aber ich denke, das ist
schon ein großer Schritt gegenüber dem, was wir zuvor hatten, weil es die Dinge nur ein
bisschen visueller und ein
bisschen klarer macht bisschen visueller und ein
bisschen klarer Die Sache ist, dass wir
schnell
einen einfachen Rückschlag hinzufügen werden, wenn die Flugzeuge miteinander kollidieren In diesem Fall wollen wir das ausschließlich in
der Spielerklasse
regeln, weil das die einzige ist, die eine Art
Pseudophysik macht Also werde ich
alle anderen Tabs schließen. Ich denke, wir sind fertig mit
den Kamerawackeln und wir gehen zum BP
Underscore Plane Und hier drinnen
wollen wir uns diese Kugel
schnappen Wir
gehen zum
Kollisionsbereich im Detailbereich
und
binden hier die Funktion beim
Komponententreffer ein, wie
wir es in der Vergangenheit getan haben. Und ich werde es
wirklich nett und einfach halten. Und nochmal, ich denke,
das ist sowieso dasselbe wie das Beispielprojekt, wo wir von
den Feinden und den Wänden abprallen können Wenn wir also auf etwas stoßen, müssen
wir nicht
überprüfen, was es ist Wir nehmen einfach
unsere aktuelle Bewegungsgeschwindigkeit und
multiplizieren sie mit
einem negativen Wert und etwas mehr. Dadurch fühlt sich das Spiel
irgendwie lustig und federnd an. Und was noch wichtiger ist, dem Spieler
einfach das
Feedback zu geben, dass Sie tatsächlich ein anderes Objekt auf
der Welt
berühren , das eine
gewisse Beständigkeit hat Also werden wir, wie ich bereits erwähnt habe, die
aktuelle Geschwindigkeit ermitteln. Wir werden das mit
einem negativen Plus und einem kleinen Wert multiplizieren einem negativen Plus und einem kleinen Wert , weil wir es nicht einfach invertieren
wollen Wir wollen einen kleinen kräftigen
Rückschlag hinzufügen. Sagen wir also -1,5. Und was auch immer das
ist, wir werden
dann die aktuelle
Geschwindigkeit wieder auf diese Geschwindigkeit setzen Das
wird offensichtlich sowieso
beim Larpen berücksichtigt sowieso
beim Larpen Die Larp-Interpolation,
die mit
unserer allgemeinen Bewegungsfunktion passiert,
wird also die mit
unserer allgemeinen Bewegungsfunktion passiert versuchen,
unsere neue Bewegungsgeschwindigkeit zu nehmen und sie dann wieder
in die normale Geschwindigkeit zu glätten, in die sie laufen
sollte, und zwar in die
Richtung, in die Ich denke, das wird sich nicht
allzu unangenehm anfühlen. Eine andere Sache, die
wir hier tun könnten
, obwohl wir
sowieso viele Kamerawackeln gemacht haben, und darüber nachgedacht Und wieder, völlig optional, aber
ich werde es einfach versuchen Ich gehe in
die Projektilbasis. Ich werde den Code
hier kopieren, den World Camera Shake, das hier
einfügen, und
vielleicht benutzen
wir den mittleren Kamera-Shake,
also lassen wir das runter Derselbe Radius, derselbe Apicenter und wir können einfach
reinkommen und Play drücken Nein, das ist definitiv
zu schwer,
ich dachte nur, wir
könnten es
ein bisschen wackeln lassen , wenn
der Sprung passiert Wir werden versuchen, das mit
den Feinden zu machen . Da ist zu
viel los. Also nochmal, Versuch und Irrtum, das hat vielleicht funktioniert.
Ich habe vielleicht
ziemlich cool ausgesehen , aber das war es nicht. Vielleicht können wir einfach einen kleinen Shake draus machen
. Hauptsache wir wollen
sichergehen, dass wir auch von den Feinden abprallen .
Also werden wir es
einfach noch einmal überprüfen So schön, dass es von der Wand abprallt. abprallen.
Ich denke, die Feinde erleiden zu viel
Schaden durch unseren Shake Sie sollten wissen, dass es ein Treffer war, nicht
wahr, also ist das in Ordnung. Es ist der Spieler, der nach zwei Treffern
stirbt. Also ja, mit der Hölle ist das völlig in
Ordnung. Und falls du dich dann fragst, warum sich das nicht auf
die Projektile auswirkt können wir
derzeit immer noch von Projektilen
getroffen werden , aber
wir prallen nicht ab Wir prallen nur von den Wänden
und den Feinden
ab , was meiner
Meinung nach Der Grund dafür liegt in unserem Kollisions-Setup. Hoffentlich hilft dies auch dabei die gesamte Kollisionsstruktur
sinnvoller wird. Denkt also daran, dass unsere Kugel
auf den Spieler so eingestellt ist, dass sie treffen wird. Es sucht also nur
nach physischen Kollisionen mit anderen physischen Objekten Das ist also ein
Treffercheck hier in unserem
Spieler und unseren Feinden Das Projektil
sieht zwar relativ ähnlich aus, ist aber
irgendwie das Gleiche, es macht eine andere Art
von Kontrolle, nicht vergessen Das ist als
Überlappungsbeschleuniger eingestellt. Aus diesem Grund ist es
nützlich, darüber nachzudenken, wie Sie
Ihre verschiedenen Collider einrichten werden Das bedeutet, dass Sie
verschiedene Arten von
Kollisions-Setups
komplett verschleiern können verschiedene Arten von , um auf ihre unterschiedlichen
Gegenstücke auf einzigartige Weise zu
reagieren und ihre unterschiedlichen
Gegenstücke auf einzigartige Weise zu
reagieren Das bedeutet, dass
wir uns keine
Gedanken über Projektile machen müssen , die irgendeinen
Rückstoß oder physischen Druck auf andere Objekte auslösen Sie fliegen buchstäblich
einfach durch den
Weltraum . Sie
machen keine Physik. Sie
kollidieren nicht physisch mit Dingen. Sie überprüfen nur, ob sich noch
etwas anderes
im selben Raum befindet Und wenn etwas anderes im selben Raum
landet,
versucht es
nur, Schaden anzurichten, einige Effekte abzuspielen
und sich dann selbst zu zerstören. Deshalb können wir damit
durchkommen. Und auch hier gilt natürlich, dass
die Levelgrenzen mit
derselben Kollision eingerichtet
werden, also sind sie so eingestellt, dass sie
die Gegner und den Spieler blockieren Das ist es also. Das
Projekt ist ausgefeilt. Ich denke, es fühlt sich jetzt viel interessanter an
, damit zu interagieren. Es bietet eine etwas lebendigere und interessantere
Erfahrung, mit der man interagieren kann. Auch hier wird vieles von der
Verfeinerung abhängen. Ich erwarte nicht, dass
Sie das Projekt verlassen, da ich Ihnen
diese Schritte bisher gegeben habe Wenn du den
Kamerawakel überhaupt nicht magst
oder du denkst, du
könntest ihn ein
bisschen besser machen , ist das völlig in Ordnung Fügen Sie all
diese Eigenschaften hinzu, entfernen Sie sie, ändern Sie sie,
wie Sie es für richtig halten Und das ist einfach wieder
etwas für Sie, um zwischen den Themen zu testen und
zu experimentieren und das Projekt wirklich
in die Hand
zu nehmen. Und erstellen Sie neue
Kamera-Shake-Klassen, wenn Sie
einen Anwendungsfall für
etwas sehen , das
mit mehr
oder weniger Frequenz wackelt , aber zum Beispiel mit mehr
Amplitude Die Hauptsache ist, dass sich
jeder Effekt dem Feedback, das
das Spiel zu vermitteln versucht,
angemessen anfühlen sollte dem Feedback, das
das Spiel zu vermitteln versucht,
angemessen . Und das ist es, was dazu führen wird, dass deine Projekte nicht mehr wie
ein Amateurspiel für Anfänger
anfühlen , sondern zu etwas, bei dem etwas mehr Nachdenken, Sorgfalt und Aufmerksamkeit auf all
die verschiedenen Elemente
angewendet werden, mit denen der Spieler
interagieren wird. Andere Dinge, die Sie ausprobieren
sollten, sind, dass Sie die Welle anstelle
der Perle im
Rauschen
ausprobieren könnten die Welle anstelle
der Perle im
Rauschen
ausprobieren , wenn die Kamera wackelt, und jedes der anderen Themen, die
ich erwähnt habe, aber wir werden nicht die Zeit
haben jeden einzelnen Vorbehalt der
verschiedenen Prozesse einzugehen. Aber wenn das erledigt ist,
haben wir unseren Shake, Knock Back. Das Gewicht und die Wirkung
des Feldes werden jetzt
ziemlich real
, sodass der Abschluss der
Erstellung einer Benutzeroberfläche für
den gesamten Spielablauf übrig bleibt . Im Moment stecken die Spieler
einfach in einer endlosen Leere fest, wenn
sie zerstört werden, und wir
wollen natürlich nicht, dass das der Fall ist.
28. 27 - Benutzeroberfläche: Okay, wir sind also
beim letzten Thema. Das wird
das Spiel über den Bildschirm sein, die Benutzeroberfläche, die
ein Neustartsystem
und einen ordnungsgemäßen Ausgang bietet . Im Idealfall müssten wir
einige Tasten drücken. Aber wir werden
diese Benutzeroberfläche nett und einfach halten. Du bist fertig. Sie können die I-Taste drücken, um
neu zu starten, und dann können Sie
direkt wieder ins Spiel kommen. In einem größeren Projekt möchten
Sie vielleicht einen Menübildschirm oder
etwas Ähnliches
hinzufügen. Aber damit hast du ein
vollständiges und spielbares Spiel. Das erste, was
wir uns ansehen möchten, ist das Konzept der Widgets Die UnrelEngine handhabt also
Menüsysteme und
UI-Overlays , Tastendrücke
und ähnliches über eine
sogenannte Widget-Klasse Also werde
ich innerhalb unserer
Ordnerstruktur einen neuen Ordner erstellen und diesen Widgets oder UI
nennen Sie sich die Projekte
anderer Leute ansehen, werden Sie oft sehen, dass es eines dieser beiden
genannt Wenn Sie sich die Projekte
anderer Leute ansehen, werden Sie oft sehen, dass es eines dieser beiden
genannt wird. In meinem Widgets-Ordner möchten
wir hier mit der rechten Maustaste klicken. Wir gehen
zur Benutzeroberfläche. Wir können hier sehen,
dass wir die Option
für einen Widget-Blueprint haben für einen Widget-Blueprint Es gibt also immer noch
Blueprint-Klassen, aber das ermöglicht
uns nur, eine Art
visuelle Oberfläche mit
etwas Code zu erstellen, der damit verknüpft Wir wählen diese
Option hier aus und erstellen ein Standard-Benutzer-Widget Wir drücken einfach und dann auf Auswählen und geben diesem
Bild den Namen WBP for Widget Blueprint
underscore Wir doppelklicken, um es zu öffnen, und Sie können sehen, dass das
Layout etwas anders ist Als Erstes ist zu beachten, dass wir
auf der rechten Seite, oben rechts, zwei verschiedene Tabs
haben. Wir haben den Designer-Tab, auf
dem wir uns jetzt befinden. Dies bietet ein
visuelles Layout und ein wirklich schönes
Leinwandsystem, mit dem Sie verschiedene Elemente per
Drag-and-Drop verschieben können,
um die Art und Weise festzulegen , wie sie auf dem Bildschirm angezeigt
werden. Dann haben wir das Diagramm,
unser Standard-Blueprint-Editor, das dem, was Sie
zuvor gesehen haben,
sehr ähnlich ist unser Standard-Blueprint-Editor, das dem, was Sie
zuvor gesehen haben, sehr ähnlich , mit nur
ein paar leichten Nuancen Während wir uns hier noch im
Designer-Element befinden, gehen
wir auf
die linke Seite
und suchen nach einem
sogenannten Overlay aus diesen verschiedenen Kategorien. Sie können sehen, dass es viele
verschiedene Kategorien gibt, also
suche ich einfach nach Und das ist im Grunde nur
ein Panel, in dem wir all die anderen
wichtigen Dinge
platzieren Also werden wir das
einfügen und Sie können
hier sehen, dass dies unser
Overlay auf dem Bildschirm ist Wir wollen nur sichergehen, dass es
sich um ein 19 x 20-Panel handelt. Also können wir das ziehen
und wir werden es platzieren. Ich muss mir nur
ein bisschen mehr Freiraum geben. Wir können das fallen lassen und
wir können sehen, wie es irgendwie einrastet, wenn Sie hier
auf die Grenzen klicken, und das wird sich hier
zusammenfügen Wir haben also ein
Standard-Hochhaus-Panel mit einer Größe von 19 mal 20. Diese werden nun so
eingestellt, dass sie je nach Bildschirm
, auf dem sie platziert werden, skaliert und geändert werden. Aber wir werden einfach die Standardeinstellung verwenden, vorausgesetzt, wir haben ein 19 x 20-Display,
und wir können von dieser Prämisse ausgehen. Als Nächstes können wir dem auch
ein nettes Bild
hinzufügen . Wir können also nach
etwas suchen, das als Unschärfefeld
oder Hintergrundunschärfe bezeichnet wird, und
wir werden das einfach hinzufügen Wir können sehen, dass die
Hierarchie hier,
das Overlay, der Ort ist, an dem alles irgendwie abgelegt
wird,
und dann ist die Hintergrundunschärfe
ein untergeordnetes Wir können sehen, ob wir die
Hintergrundunschärfe vergrößern, die Unschärfe ist
ein bisschen klein Wir werden es
etwas schwierig finden, das zu
erkennen, wenn wir auf
Play drücken und es angezeigt bekommen würden Was wir also tun wollen, ist
auf der rechten Seite, wir können das
an unserem Overlay ausrichten Wenn wir also sagen, dass es den gesamten Raum horizontal
einnehmen
und
den gesamten Raum
vertikal ausfüllen soll Raum horizontal
einnehmen
und
den gesamten Raum
vertikal ausfüllen , können Sie
sehen, dass das jetzt der Größe der
übergeordneten Komponente, der
Überlagerung,
entspricht übergeordneten Komponente, der
Überlagerung, Für die Stärke der Unschärfe nehme
ich einfach diesen Wert hier
im Detailbereich und wir geben ihm eine
Unschärfestärke von 15, und wir können sehen, dass das unserem Panel
eine leichte Unschärfe hinzugefügt hat, was meiner Meinung
nach ziemlich nett und modern aussehen wird und ihm nur
ein bisschen visuelles Flair verleiht . Als Nächstes wollen wir uns
ansehen, wie wir den Text
formatieren können , wir auf dem Bildschirm anzeigen
möchten. Also werden wir so
etwas zeigen, nur einen einfachen Text mit der
Aufschrift, dass das Spiel vorbei ist, und dann einen Tooltip
, wie man neu startet. Eine nette und einfache Möglichkeit,
mehrere Elemente in
einem einzigen Bereich eines Menüs zu verwalten ,
wäre, entweder einen horizontalen
Kauf zu verwenden , wenn Sie
möchten, dass sich die Dinge horizontal über Ihr
Widget
erstrecken, oder ein vertikales Feld. In diesem Fall
gehen wir vertikal vor. Wenn wir also nach
einem vertikalen Feld suchen, können
wir dieses dort ablegen und
nur sicherstellen, dass es sich um
ein untergeordnetes Objekt der Überlagerung handelt und
nicht um die Hintergrundunschärfe Bei
der Ausrichtung dieses Felds
können Sie sehen, dass es das gesamte Feld
einnimmt Stattdessen
stellen wir hier die Mittellinie für die horizontalen und
vertikalen Einstellungen ein. Das ist völlig
in Ordnung. Wir können diese Skala etwas später an die Elemente im Inneren anpassen. Die Elemente
werden, wie ich bereits erwähnt habe , dafür sehr,
sehr einfach sein. Wir geben
dem einfach ein Textelement, also
suchen wir nach einem Text und legen unser erstes
Textelement in das vertikale Feld. Und Sie können sehen, dass das vertikale Feld
wirklich so herausgeholt wurde, dass
das Element hier
hineinpasst Für den ersten
Text werde ich hier
GameOver einstellen der Text ausgewählt ist, möchten
wir hier unsere
Textoption finden Sie können sehen,
dass dort derzeit Textblock steht, und ich werde das einfach auf Game Over
ändern. Ändere unsere Schriftgröße. Im Moment, wenn wir unsere
Schrifteigenschaften nur hier
auflisten, ist
die Größe 24,
und ich denke, eine Größe von etwa 50
wäre ideal für diese Schrift. Wir können das Schriftbild ändern. Roboto Bold sieht oft
ein bisschen unangenehm aus. Wir können es einfach auf normal umstellen oder sogar Licht kann ziemlich gut
aussehen Sieht nur ein bisschen sauberer aus. Das sieht jetzt
nicht ganz so wirkungsvoll aus. Vielleicht möchten wir
die Schriftgröße auf
etwa 60 ändern , damit sie ein
bisschen besser aussieht und klingt Jetzt, wo dieser Text
ausgewählt ist, können wir drücken. Also holen wir uns
das hier auf
der linken Seite oder
duplizieren unseren Text. Also kontrollieren Sie tatsächlich,
um zu duplizieren. Und Sie können
das sehen, weil es sich in diesem vertikalen Feld befindet Es stellt jetzt sicher, dass
es vertikal ausgerichtet ist. Und wenn wir weiterhin
Textelemente hinzufügen
würden, hätten wir diese schöne Ausrichtung
in vertikaler Reihenfolge. Das macht
es also ein bisschen einfacher,
mehrere Elemente zu verwalten und mit ihnen zu arbeiten , wenn
Sie möchten, dass an derselben Stelle
ungefähr
zueinander passen. In diesem Fall nehme ich einfach das neue Textelement
oder ändere den Text so, dass ich
sage, dass R gedrückt werden soll, um neu zu starten. Wahrscheinlich nicht das
interessanteste Spiel auf dem Bildschirm, aber es
bringt den Punkt rüber. Wir werden die
Größe ein wenig ändern. Es muss nicht sehr
wirkungsvoll sein, wenn das Spiel vorbei ist. Also geben wir dem
eine Schriftgröße von 30. Wir könnten diesen auch
ein wenig Polsterung geben. Wenn ich mir also
zuerst das GameOver schnappe , können
wir ihm im
Detailbereich auf der rechten Seite eine
Standardüberschrift von sagen wir zehn geben, damit es ein bisschen
kniffliger wird Und wir können dasselbe
tun, indem wir R drücken, um neu zu starten. Wir werden das
auch etwas genauer betrachten. Und die Hauptsache ist, dass wir wollen, dass
es mittig ausgerichtet ist. So können wir die
horizontale Ausrichtung übernehmen und sicherstellen, dass beide mittig ausgerichtet
sind. Sie sind also quasi in
der Mitte ihrer
vertikalen Box platziert , schön und aufgeräumt, und wir
mussten nicht viel Arbeit machen Eine andere Sache, die Sie vielleicht tun
möchten, ist,
die visuellen Farben ein wenig zu ändern die visuellen Farben ein wenig Damit wir das Spiel beenden könnten. Spielübergänge werden
normalerweise mit
Rot oder Orange oder
etwas ähnlichem dargestellt ,
also könnten wir
die Farbe hier
so ändern, dass also könnten wir
die Farbe hier
so ändern etwas negativer ist,
damit sie sich einfach
von der Eingabe hier
abhebt Es sieht ein
bisschen interessanter weil wir noch
mehr Dinge im Gange haben Ein paar ausgefeiltere die Sie vielleicht machen
möchten, Sie können Ihre
eigenen Schriften sehr einfach einfügen, um sie zu entreißen,
und dann können Sie einfach die Schriftart ändern
, die Sie verwenden
möchten , damit sie ein
bisschen individueller aussieht Spielen Sie mit Dingen wie
der Kühnheit und der Schriftgröße herum. Sie können sogar
Dinge wie Konturen hinzufügen , wenn Sie bestimmte Teile
hervorheben möchten Also wenn ich nur ein bisschen
hineinzoome. Ich könnte einen
Umriss von zwei Pixeln hinzufügen und
schon bekommen wir hier eine Gliederung unserer Menüelemente. Also, was auch immer Sie tun wollten
, um es ein bisschen
interessanter
aussehen zu lassen , wie gesagt, wir werden es nett und
einfach
halten, nur um zu zeigen
, dass das Spiel
vorbei ist , und um dem Spieler
eine Aufforderung zu geben ,
was er als Nächstes tun kann. Wir werden uns also ganz kurz
mit dem Eingabesystem
befassen dem Eingabesystem weil wir jetzt dafür sorgen
müssen, dass etwas funktioniert wenn diese Benutzeroberfläche auf dem Bildschirm angezeigt
wird. Wenn wir also zu
unserem Eingabesystem zurückkehren, fassen wir
einfach zusammen, was wir haben Wir haben bereits unseren Neustartschlüssel. Nun, wie ich bereits erwähnt habe, in einem
kompletten Spiel, in dem du ein
komplexeres
Menüsystem und solche Dinge hast . Möglicherweise haben Sie unterschiedliche Kontextklassen für die
Eingabezuweisung. In diesem Fall haben wir einfach
alles an ein einziges Gameplay gebunden , und ich denke, das ist in
Ordnung, weil wir
keine überlappenden Verwendungszwecke haben .
Wenn du also zum Beispiel
die Zurück-Taste auf einem Gamepad
verwenden
möchtest,
also B auf dem Gamepad, als Eingabe wie Jump,
aber du willst die Zurück-Taste auf einem Gamepad
verwenden
möchtest, also B auf dem Gamepad, also B auf dem Gamepad, als Eingabe wie Jump, ,
dass es auch die Neustart-Taste ist, dann
möchtest du das vielleicht teilen. Wenn Sie also in einem Menü wären, würde
B dem Neustart zugeordnet werden Sie hätten also Ihren
Menüzuordnungskontext. Und wenn du dann im
Gameplay bist und es „Jump“ heißt, dann hättest du deinen
Gameplay-Mapping-Kontext. In diesem Fall denke ich, dass es völlig in Ordnung
wäre, einfach diesen zu
verwenden. Also gehen wir
zurück zu unserem GameOver und wollen nur die
Bindung herstellen, die wir zuvor
gemacht haben Hier kommt also die
Codeseite unseres Menüs ins Spiel, und hier
macht ein Teil der
wirklich coolen Flexibilität
des erweiterten Eingabesystems solche Dinge viel
einfacher als früher Mit dem alten System war es definitiv möglich, aber das ist
definitiv ein Fortschritt. Wir werden hier
zur Grafik navigieren, und diese ist dem, was wir zuvor gesehen haben, ziemlich ähnlich
. Wir haben also ein
Event-Häkchen, und in diesem Fall werden
wir in
unserem Menü
nichts mit dem Häkchen machen , also können wir das
loswerden. Das Event-Konstrukt
ist also im Grunde dasselbe
wie das Begin-Play. Dies wird geschehen,
sobald das Spiel beginnt und das Menü
erscheint. Wenn wir also das
Menü auf dem Bildschirm anzeigen, es einmal fünf sein Vor der Konstruktion musst du
ein bisschen vorsichtig sein. Dies ist nützlich für Änderungen am
Editor. Wir könnten also
Dinge so programmieren, dass wir Live-Editor-Updates erhalten können, aber Sie müssen
hier vorsichtig sein, denn wenn Sie auf andere Klassen verweisen oder Dinge außerhalb
des Menüs
tun, kann
dies zu Problemen führen, wenn
Sie sich noch nicht im Spielmodus Um Verwirrung zu vermeiden, wir das hier
loswerden, und wir werden es einfach
als unser Spiel betrachten, was wir tun wollen, was wir tun wollen oder was wir
beim Event Construct ist, dass wir wieder zum
Spielercontroller gehen
und genau das tun wollen, was wir zuvor getan haben. Wir wollen das erweiterte
Eingabe-Subsystem für lokale Spieler finden Eingabe-Subsystem für lokale Spieler Dieser hier mit dem
rosa-lila Funktionssymbol genau Und wieder, wie
wir es zuvor getan haben, werden
wir
den Mapping-Kontext hinzufügen Also können mehrere Klassen
denselben Mapping-Kontext haben, also werden wir
den Mapping-Kontext
jetzt in unserer Spielerklasse haben , die die Eingabe
für das Bewegen und Schießen verarbeitet. Wir können denselben
Zuordnungskontext zu unserem Menü hinzufügen. Wenn es also erscheint, wird
es auch die
entsprechenden Tastendrücke verfolgen In diesem Fall ist das in Ordnung, da der entsprechende
Tastendruck nur
ein Neustart durch einen
Unterstrich ist Also können wir hier mit der rechten Maustaste
reinklicken. Wir suchen nach IA Underscore Restart Wir wollen das Ereignis erneut. Wenn
also etwas passiert, erhalten
wir die Ausführungs-PIN-Datei, wann
dieser Knopf gedrückt wird Wir wollen ganz einfach
das Level neu laden , in dem wir uns gerade befinden und wir
starten das Spiel gerade neu Wir haben nur ein Level, also ist
das nett und einfach. Es gibt eine Funktion, die
wir dafür verwenden können, eine integrierte Funktion in Unreal Wir können den Namen Get
Current Level verwenden. Also diese Funktion einfach hier,
schließe sie an, um sie zu starten. Also nochmal, wenn diese Taste einmal gedrückt
wird, gibt das den Namen
des Levels zurück , in
dem
wir uns gerade befinden. Remember heißt
einfach Main. Wir könnten das also fest
codieren und einfach
das Level main für das Level eingeben , das wir neu laden möchten Aber nur für den Fall, dass du
jemals anfängst,
weitere Level hinzuzufügen oder
den Namen zu ändern, ist das nur, wiederum, eine nette, dynamische und wiederverwendbare Methode, dies
zu implementieren Sobald wir das haben, ziehen
wir von hier aus nach
der Ladestufe der Funktion
und
suchen dann nach
der Ladestufe der Funktion nach der geöffneten Funktion. Ich kann die Option hier sehen, Ebene nach Namen
öffnen. Jetzt erhalten wir zwei leicht
unterschiedliche Variablen, also haben wir den aktuellen
Ebenennamen als Zeichenfolge zurückgegeben
und wir haben Level
to Load zurückgegeben, und wir haben Level
to Load zurückgegeben erwartet wird, dass er
als Namensvariable eingegeben wird. Vollkommen in Ordnung. Auch hier
können wir sie einfach anschließen. Sie sind beide im Grunde eine Art
von Text, und Unreal wird
diese Konvertierung für uns vornehmen Das nimmt also den aktuellen Namen der
Ebene, in der wir uns befinden, und öffnet die
Ebene mit dem gleichen Namen Also starten wir gerade von rechts
neu, das andere Problem, das mir
gerade klar geworden
ist, ist, dass wir keine
Möglichkeit haben, das Spiel zu verlassen Ich versuche hier
wirklich zu helfen
, dass sich das Spiel am Ende nicht wie ein komplettes
Anfängerspiel
anfühlt wie ein komplettes
Anfängerspiel
anfühlt. Eine Sache, die ich
beim Testen und
Vorführen von Spielen
neuer Entwickler feststelle
, ist , dass man oft
in ihrem Spiel feststeckt und Alt-Taste F drücken
muss, um das Panel zu
schließen Während wir
uns also die Eingabe ansehen, können
wir dieses Problem
genauso gut
beheben . Ich
werde also den IA duplizieren und den Neustart
unterstreichen Ich werde
diesen umbenennen, um zu beenden. Innerhalb des
IMC-Unterstrichs Main wollen
wir nur ein neues
Mapping hinzufügen Wir wissen also, dass restart
ein boolescher Wert ist, eine binäre Eingabe. Also haben wir auch schon aufgehört, es
als digitalen Booleschen Wert festzulegen , was perfekt Also werden
wir in IMC Underscore main ein neues Mapping hinzufügen Wir lassen es fallen und
wählen die Schaltfläche „Beenden“. Zum Testen im Editor ist
das also etwas
kompliziert, weil standardmäßig Escape sowieso dem
Ende der Wiedergabe zugeordnet ist Wenn wir also spielen und testen würden, könnten
wir nicht testen Ohne unser
Menüsystem oder unsere Schnelltaste zu deaktivieren. Also werde ich das geben. Aber wenn wir das verpacken und jemand anderem
geben würden. Ich möchte nur, dass die Escape-Taste
das Projekt schließt. Es wird keine Menüs geben, es wird keine Popups geben,
nur eine schnelle Möglichkeit, das Projekt zu
schließen, damit ich zumindest nicht feststecke, wenn ich
das Projekt fertig gebaut habe. Für Editor-Tests gebe ich
mir
oft eine weitere Bindung und setze sie auf
etwas wirklich Zufälliges, das ich sonst nicht in meinem Gameplay
drücken würde. Also könnte ich
das als Löschtaste festlegen. Und das
bedeutet, dass ich wieder in meine Spielerklasse
zurückkehren kann . Also werde ich in
den Kern des Flugzeugspielers gehen. Und wieder entfernen wir
uns ein
wenig von den idealen Möglichkeiten
, das jetzt einzurichten. In einem echten Projekt
würden Sie das wahrscheinlich
innerhalb eines Player-Controllers
oder in verschiedenen Menüsystemen tun , aber wir gehen nicht so
tief, um komplette Menüsysteme zu entwickeln. Also werden wir das hier einfach
in unser Eingabesystem einfügen. Wir haben also unser
Eingabediagramm. Zumindest
halten wir die Dinge immer noch schön
und aufgeräumt Das ist immer noch in
unserem IMC Underscore Main enthalten. Das bedeutet also, dass alle unsere neuen Bindungen
weiterhin verfolgt werden Und was wir tun können, ist, dass der IA-Unterstrich beendet ist. Und wenn diese Taste gedrückt wird, wollen
wir das Event erneut. Und wenn diese Taste gedrückt,
also gestartet wird , wollen wir nur die eingebaute
Funktion
aufrufen, die beendet wird. So schnelles Spiel. Und
dadurch wird die
Instanz des Spiels
automatisch für dich geschlossen. Wenn wir also auf Kompilieren und Speichern klicken, können
wir das sofort testen. Denken Sie daran, dass es im Play-Modus sowieso geschlossen worden wäre, wenn ich Escape
gedrückt
hätte Also werde ich
die Löschtaste drücken und die Wiedergabe ist gerade beendet. Das funktioniert also sowohl für
unsere Paketversion als auch für unsere
Editor-Version hier. Wir müssen hier also
nichts weiter tun. Und ich wollte
Ihnen nur die Schnellfunktionalität vorstellen , denn wie ich bereits erwähnt habe, ist
sie wirklich leicht zu übersehen, aber sie ist super, super
einfach zu implementieren Und es ist einfach eines
dieser Dinge, die deine anfänglichen Gefühle beeinflussen
und die Benotung eines Spiels , das du spielst, macht es
einfach einen Schritt weiter und gibt
dir das Gefühl, ein Spiel
zu spielen, das von jemandem
mit etwas
mehr Erfahrung gemacht wurde mit etwas
mehr Erfahrung letzte Sache ist, dass wir wollen, dass
diese Benutzeroberfläche anzeigt
, wenn der Spieler stirbt Wir wissen genau, wann das
passiert, weil wir unsere Handle-Death-Funktion
innerhalb der Spielerklasse haben. Damit
werden wir also
unsere Handle-Death-Funktion finden . Wir wollen zu Override übergehen
und wir wollen
herausfinden, ob Dyna erledigt Wir wollen sichergehen
, dass wir immer noch
all diese wichtigen
übergeordneten Dinge anrufen , damit unser Effekt und all
das erledigt wird Aber kurz bevor das
passiert, oder vielleicht ja, kurz bevor das
passiert, weil wir Destroy in
der übergeordneten Version
aufrufen, wollen
wir es in
unserer Benutzeroberfläche starten Und wir können das
ganz einfach machen, also werden wir
von hier aus
eine Funktion namens Create Widget finden eine Funktion namens Create Widget Das ist also eine Funktion, um
eines unserer Blueprint-Widgets zu erstellen eines unserer Blueprint-Widgets Wir können das
hier einstecken und wir wollen unser WBP-Underscore-Spiel
finden Jetzt werde
ich noch einmal ein bisschen darauf hinweisen,
nur weil Sie überrascht
wären , wie
viele Menschen
den nächsten wichtigen Schritt vergessen den nächsten wichtigen Schritt Das fühlt sich an, als
ob das funktionieren sollte. Aber wenn ich schnell reingehe und zulasse, dass mein Flugzeug zerstört wird, rufen
wir diese Funktion auf, wir haben ihr ein
bestimmtes Widget gegeben, aber wir sehen
dieses Widget nicht auf dem Bildschirm. Also nochmal, sehr verbreitetes Ding. Auch wenn es sich
anfühlt , als ob das alles ist, was
wir tun müssen. Es gibt tatsächlich einen zusätzlichen Schritt. Wir wollen aus
diesem Return-Pin ziehen. Das wird also
im Hintergrund erstellt. Es gibt ein Game-Over-Widget, das einfach irgendwie im
Gedächtnis Wir wollen diese
Referenz und Erinnerung nehmen
und wir wollen sagen, zum Standpunkt
hinzufügen Hier gibt es eine spezielle Funktion namens
Need to Make, und dann werden
wir einfach all das zusammenfügen Und jetzt wird das
tatsächlich funktionieren. Also, wenn wir reinkommen und erneut auf Play
drücken, lassen wir
einfach meine Flugzeuge
zerstören und los geht's. Dadurch wurde das Menü erstellt, aber
es wurde auch zum Viewpoint hinzugefügt Wenn ich R drücke, haben wir
diese Bindung im Menü, also haben wir jetzt auch einen
Neustart Also können wir reinkommen und das Spiel jetzt wirklich,
wirklich einfach
neu starten . Wir werden am Ende
dasselbe haben. Und wenn ich auf Löschen drücke, habe ich dort
etwas übersehen. Ich wollte sagen, wenn ich Löschen
drücke, kann ich aufhören. Ich kann nicht, weil die
Spieler zerstört wurden. Und vergiss nicht, dass unsere
Verpflichtung zum Austritt beim Spieler liegt. Also etwas, das wir vielleicht ein bisschen duplizieren sollten ein bisschen duplizieren Wir werden hier
unseren IA-Unterstrich Beenden“ und die Funktion „
Spiel beenden Wir werden es hier nicht
entfernen. Wir wollen es an beiden Orten haben.
Wir gehen zurück ins Spiel und fügen
das einfach hier ein. Wenn der Spieler also zerstört
wurde, existieren
sie nicht mehr. Wir können das Spiel offensichtlich nicht
beenden. Also werden wir
diese Funktionalität
stattdessen auf das GameOver-Widget übertragen Also völlig in Ordnung. Achte nur darauf, dass
der Spieler trotzdem stirbt. Und wenn ich jetzt auf
Löschen drücke, können wir das Spiel schließen. Also die gleiche Funktionalität,
wir
müssen nur immer berücksichtigen, ob etwas komplett aus dem Spiel
entfernt wurde, komplett aus dem Speicher entfernt wurde, wir müssen sicherstellen, dass alle
Funktionen, die
relevant waren, auch woanders
verfügbar sind. Und nochmal, wenn du herausfindest, wie damals, als ich mir das angeschaut
habe, habe ich das Gefühl, dass wir dort ziemlich
viel Platz auf
dem Bildschirm hatten . Also ich denke, was ich tun könnte, sind nur ein paar sehr kleine Änderungen, um das wirklich große Spiel
vielleicht
doppelt so groß wie unser Spiel zu machen Und dann die doppelte Größe
unseres Tooltips hier. Es ist also nichts Wichtiges, aber
es geht einfach wieder
darum,
einfach eine generelle
Füllung zu bekommen und alles
so gut wie möglich aussehen zu lassen und zu
versuchen, das
Spiel auf die beste Art und Weise zu präsentieren. Also ja, wahrscheinlich eine viel bessere Art von
allgemeinem Stil. Drücken Sie, um neu zu starten, alles funktioniert. Also ziemlich perfekt. Ich denke, für ein Anfängerprojekt, eine sehr einfache Art von Remake
von etwas Bestehendem, aber der Versuch, zu
erweitern und zu verbessern, insbesondere die
Codebasis, wo immer möglich, aber auch das allgemeine Feedback und die Füllung und die Grafiken
werden hoffentlich
ein netter
Lernpunkt sein und ein Schritt in die richtige Richtung für
Ihre zukünftigen Aber damit ist das Ganze
so gut wie abgeschlossen. Also noch ein paar Dinge
, die Sie aus
diesen Lernpunkten mitnehmen können. Du kannst spielen,
Feinde erschießen, getroffen werden, sterben, Game Over-Bildschirm
erscheint und du kannst
das Ganze noch einmal machen .
Alles sieht ganz nett aus. Es entsteht eine
Art halbverschwommene, modern aussehende, einfache
Benutzeroberfläche. Du kannst Escape oder
Löschen drücken und das
Spiel von überall aus schließen Also nochmal, wir wollen nicht,
dass es sich wie
ein komplettes Newbie-Projekt anfühlt , bei dem du feststeckst und
F 4 aus einem
Wochenendprojekt von jemandem ändern musst F 4 aus einem
Wochenendprojekt von jemandem Hoffentlich ist das
eine nette Verbesserung gegenüber dem, was Sie vielleicht auch gesehen
haben Wir haben also eine
komplette Spielschleife. Wir können spielen, sterben,
neu starten und beenden. Im Laufe dieser
ganzen Zeit sind
wir also von einem leeren
Projekt zu einem kompletten Spiel übergegangen, mit
Bewegungen, die
unabhängig von der Bildfrequenz sind, Projektile,
dynamische Materialien, Feinde mit Vererbung und einem kurzen Blick auf Wir haben Spawner
mit Randomisierung,
um sicherzustellen, dass sie auf generische Weise
erstellt wurden,
aber generisch auf eine gute Art und
Weise, dass wir
die Klasse einmal erstellen und sie für mehrere Eigenschaften verwenden können die Klasse einmal erstellen und sie für mehrere Eigenschaften verwenden Wir haben uns Partikel, Audio,
Kameraverwackeln, Rückschlag und jetzt die Benutzeroberfläche angesehen Kameraverwackeln, Rückschlag und jetzt Das ist also hoffentlich
eine gute Grundlage. Darauf können Sie aufbauen. Wie ich bereits erwähnt habe, wäre
es toll wenn du einige einzigartige Gegner hinzufügst, ihnen verschiedene
Bewegungsmuster und Waffenmuster geben würdest, sie
vielleicht beschleunigen und sie einfach
dazu bringen würdest, Gegner
mit bekannten Projektilen zu kamikazen Was auch immer du
für deine zusätzlichen Schritte empfindest, um dieses Projekt einzigartig zu machen Bringen Sie einige neue Ressourcen ein und teilen Sie Ihre Fortschritte und
Updates mit anderen Personen. Könnte auch Dinge
wie das Scoring hinzufügen, was mit der
Shared-Handle-Death-Funktion wirklich einfach zu bewerkstelligen wäre . Wir wissen genau, wann
die Feinde sterben, also könntest du
darauf aufbauen und eine Art Punktesystem einrichten. Machen Sie sich dieses
Projekt also wirklich zu eigen. Nehmen Sie Referenzen
aus anderen Spielen, schauen Sie sich die Inhaltsbeispiele an, und ich empfehle auf jeden Fall
,
sich an dieser Stelle die Inhaltsbeispiele anzusehen. Schauen Sie sich die
Blueprint-Eingabekarte an und sehen Sie genau, woher dieses Projekt inspiriert
wurde, und vergleichen den Code, den Sie haben, mit
dem Code in diesem Projekt Und auch hier geht es nicht darum, ein Urteil
zu fällen, sondern nur, um zu sehen
, dass es immer
verschiedene Möglichkeiten gibt , ein einzelnes Problem
anzugehen Und sehen Sie, was
Sie von dem, was wir haben, im Vergleich zum
ursprünglichen Projekt halten. Aber das Wichtigste
ist, dass Sie jetzt ein Spiel
entwickelt haben , und
das ist nicht nichts. Das ist eine Leistung, und das gilt umso mehr, wenn Sie diese zusätzlichen Schritte
unternommen haben und wirklich das Gefühl haben, zumindest ein bisschen
zu verstehen was Sie in
Unreal tun können Einiges davon wird ein
wenig Wiederholung erfordern. Möglicherweise müssen Sie zurückgehen
und die Dinge erneut ausprobieren, aber die Fähigkeit, diese
Funktionen selbst zu optimieren und zu
implementieren ist wirklich die große
erste Lernhürde , an der meiner Meinung nach viele
Leute nicht weiterkommen Also danke, dass du mir ernsthaft gefolgt bist
. Wenn Sie so weit gekommen sind, schätze
ich es sehr, dass Sie Ihre Zeit
etwas gewidmet haben, an dessen Entstehung ich mitgewirkt habe Aber ich
mache weiter Dinge. Das ist
der springende Punkt hier.