Transkripte
1. Intro: Willkommen zu meinem Kurs
über die Grundlagen der Spieleentwicklung und Gado Dieser Kurs ist eine Fortsetzung der
Einführung in die
Entwicklung von Three D-Spielen und Gado. Er
kann jedoch verfolgt und auf jedes Projekt angewendet
werden, das
einen Charakter enthält, den der Spieler
steuern kann , um sich durch
mehrere Level zu bewegen Du kannst gerne
unserem Discord-Server beitreten um
gemeinsam mit deinen Kollegen an diesem Kurs zu arbeiten In diesem Kurs werden wir grundlegende Elemente
behandeln , die fast
jedem Spiel aller Genres gemeinsam sind Erstellen einer Titelszene, Menüs, reibungsloser Übergang
zwischen Szenen, Verschieben eines Charakters zwischen verschiedenen Leveln Ihres
Spiels, Hintergrundmusik, Einstellungen und
Datenpersistenz zwischen Szenen, Levels und Spielsitzungen Wenn du fertig bist,
hast du eine gute Grundstruktur
eines Spiels, die du zu
etwas nach deinem eigenen
Design eines beliebigen Genres weiterentwickeln
kannst etwas nach deinem eigenen
Design eines beliebigen Sie werden auch nützliche Fähigkeiten erlernen um mit der
Gada-Game-Engine zu arbeiten und
Ihre Projekte so zu
organisieren und zu gestalten, organisieren und zu gestalten dass sie
skalierbarer sind Sie werden lernen,
wie man mit dem GD-Skript programmiert, wobei alles ausführlich
erklärt wird Wir werden
objektorientierte Designprinzipien
in unseren Skripten, Vererbung,
Kapselung und Abstraktion anwenden in unseren Skripten, Vererbung, ,
um sie
für ein Projekt jeder Größe organisiert,
anpassbar und wiederverwendbar zu halten für ein Projekt jeder Größe organisiert,
anpassbar und wiederverwendbar Alle Projektdateien werden auch auf GitHub verfügbar sein, falls Sie
das Projekt so überprüfen möchten, wie es nach Abschluss
jeder Lektion war Diese Videos wurden
mit Gadot Version 4.2 0.2 aufgenommen. Das Projekt beginnt
mit Inhalten aus Ka Kits Character und Dungeon Remastering-Paketen
Ka Kits Character und Dungeon von Kay
Lauberg In diesem Kurs werde ich
auch Inhalte
aus dem Basic Guy Bundle von Penzilla
und Musik
aus dem
Barns Music-Paket
von Eric the Funny Baron hinzufügen aus dem Basic Guy Bundle von Penzilla
und Musik
aus dem
Barns Music-Paket
von Eric the Funny Baron . Alle können kostenlos auf H dot
IO heruntergeladen werden.
2. Pause: Hallo, Freunde. Bevor
wir anfangen, solltest
du eine
Spielszene in deinem Projekt haben, die einen Charakter enthält
, den der Spieler
kontrollieren kann , und ein Level, in dem er herumlaufen
kann. Du solltest mindestens zwei oder
drei verschiedene Levelszenen
bereit haben drei verschiedene Levelszenen , die miteinander verbunden werden können, wenn der Spieler
einen Schwellenwert überschreitet. In diesem Kurs werden wir Elemente
hinzufügen, die für
jede Art von Spiel, die du dir
vorstellen kannst, unverzichtbar
sind . Dazu gehören Menüs,
Szenen- und Levelübergänge, das
Ausblenden von Szenen- und Levelübergänge, Bild und Ton,
Einstellungen, Credits
und Datenpersistenz Du kannst dein eigenes Projekt verwenden, um diesem
Kurs zu
folgen, oder
ein Starterprojekt mit dem Titel Godot Essentials
course Main Branch von meinem
Github herunterladen ein Starterprojekt mit dem Titel Godot Essentials
course Main Branch von meinem
Github . Ihr Projekt kann
zwei D oder drei D sein und fast jedes
Spielgenre, bei dem ein Charakter
zwischen verschiedenen Szenen
bewegt wird dem ein Charakter
zwischen verschiedenen Szenen
bewegt Lassen Sie uns zunächst dem
Spieler erlauben, das Spiel zu unterbrechen. die Projekteinstellungen öffnen und zur Eingabekarte
wechseln, können
wir eine neue Aktion für die
Pause hinzufügen und auf
die Schaltfläche Hinzufügen klicken. nach unten scrollen und
unsere neue Pause-Aktion finden, können
wir Ereignisse hinzufügen,
die
diese Pause-Aktion auslösen , indem wir auf die Plus-Schaltfläche
klicken Ich verwende die Escape-Taste und die Starttaste
auf meinem Controller Wir haben den
Spielerknoten verwendet, um die Eingaben
unseres Spiels über
das beigefügte Spielerskript zu verarbeiten Eingaben
unseres Spiels über
das beigefügte Spielerskript und die
entsprechenden Informationen weiterzuleiten, um den Charakter oder den
Federarm und die Kamera zu bewegen Wie bei den Tasten „
Ausführen“ und „Springen“ können
wir überprüfen, ob die
Pause-Taste gedrückt wurde Aber wir wollen weder
den Charakter noch die Kamera anhalten. Wir wollen
die gesamte Szene pausieren. Wir können einen Verweis
auf den
Stammknoten der Szene abrufen , indem wir
eine weitere Variable exportieren. Nennen wir es Underscore GM, kurz für Game Manager Aber der Wert dieser Variablen sollte niemals wirklich geändert werden
müssen Es sollte immer der
Stammknoten der Spielszene sein. Anstelle von at export könnten
wir at on
ready verwenden, könnten
wir at on
ready verwenden um den Wert unserer
GM-Variablen auf get parent zu setzen, da der Player-Node
ein untergeordnetes Element des Spielknotens ist. Aber vielleicht wollen wir uns nicht auf
diese exakte Struktur verlassen diese exakte Struktur damit unser Skript
richtig funktioniert. Wir
möchten zum Beispiel aus anderen Gründen, dass der Spielerknoten ein untergeordnetes Element des
Charakterknotens ist. Damit dieser Verweis also immer direkt auf den Stammknoten der
Szene
verweist, können
wir die
Dollarzeichen-Annotation verwenden. Wenn wir den Knotenpfad
mit einem Schrägstrich beginnen, beginnen
wir mit dem Stamm der
Szenenbäume Es ist jedoch wichtig zu beachten, dass dies noch nicht der Szenenknoten des
Spiels ist Wir müssen
diesem Knotenpfad auch den
Namen des Root-Nodes hinzufügen (root slash gain Wenn wir unsere aktuelle Szene ausführen und
dann im Szenenfenster zur
Remote-Ansicht wechseln, können
wir sehen, dass der Stammknoten der
Szenenbäume als Root bezeichnet wird
und derzeit der
untergeordnete Knoten, der nur Roots enthält, der Spielknoten ist Da unser Player-Node nun
einen direkten Verweis auf
den Root-Node der Szene hat , rufen
wir eine Funktion für ihn
auf, die wir noch nicht geschrieben haben: Pause ein-/ausschalten Ein neues Skript an unseren
Spielknoten anhängen. Dieses Skript wird
für die Verwaltung der gesamten
Szene verantwortlich sein für die Verwaltung der gesamten
Szene Wir nennen es Game Manager. Ähnlich wie bei einem Manager
an einem Arbeitsplatz besteht
dieser Drehbuchjob darin, die Szene
zu öffnen,
wenn sie zum ersten Mal gestartet wird . Stellen Sie sicher, dass alle
Mitarbeiter oder untergeordneten Knoten über alles verfügen, was sie
für ihre jeweiligen Aufgaben benötigen , schließen Sie
dann die Szene,
wenn sie fertig ist. Da unser einfaches Spiel nur einen Spielmodus
hat, benötigen
wir nur einen Spielmanager. Aber ein komplexeres Spiel mit mehreren Spielszenen könnte
einen Erkundungsmanager, Kampfmanager, Rätselmanager usw. für verschiedene
Spielszenen haben. In unserem neuen Game Manager-Skript können
wir die Funktion „
Pause ein-/ausschalten“ hinzufügen, können
wir die Funktion „
Pause ein-/ausschalten“ hinzufügen wir über das
Spielerskript aufgerufen haben Das Spiel zu pausieren ist
eigentlich ganz einfach. Wir beginnen damit, einen Verweis auf
den gesamten Szenenbaum mit der
eingebauten Funktion get tree zu
erhalten den gesamten Szenenbaum mit der
eingebauten Funktion get Der Rückgabetyp dieser
Methode ist ein Szenenbaum
, der eine Variable namens
paused enthält, auf die wir
mit p zugreifen können . Der Typ der
pausierten Variablen ist ein boolescher Wert
, der den Standardwert false hat Wenn Sie den Wert auf „true“ setzen, wird der Wert pausiert, um zu gewinnen. Wir können den Wert jedes Mal, wenn
diese Umschalt-Pause-Funktion aufgerufen wird, zwischen wahr
und falsch
hin - und herschalten , indem wir den Logik-Operator „Null“ verwenden, der
durch ein
Ausrufezeichen dargestellt wird Wir setzen den Wert
pausiert beim ersten Mal auf Null (falsch) und beim zweiten Mal
auf „ Nicht wahr“ und wiederholen . Wenn wir es testen,
können wir das Spiel pausieren,
aber wir können die Pause noch nicht rückgängig Das liegt daran, dass der Spielerknoten
, der versucht, die
Eingabe zu empfangen, um das Spiel aufzuheben, ebenfalls pausiert ist und keine Eingaben
empfangen oder verarbeiten kann Bei einigen bestimmten Knoten
möchten wir möglicherweise nicht pausieren, während
das Spiel pausiert Wählen Sie den
Spielerknoten im Szenenbaum
aus, schauen Sie im Inspektor unter
Knoten nach und erweitern Sie den
Prozessbereich Die Eigenschaft mode ist
derzeit auf erben gesetzt, was bedeutet, dass sie denselben Prozessmodus erbt wie
ihr übergeordnetes Objekt, der Spielknoten Da der Spielknoten angehalten ist, wird auch
der Spielerknoten angehalten der Spielerknoten Wir können diesen
Wert auf „Immer“ ändern, sodass der Player-Node auch dann
weiterläuft , wenn
das Spiel pausiert wird Beachten Sie, dass wir bei Pai auch festlegen können, dass einige
Knoten nur dann wenn das Spiel
pausiert ist , oder die Verarbeitung
von bestimmten Knoten aus ganz deaktivieren können weiterarbeiten, wenn das Spiel
pausiert ist, oder die Verarbeitung
von bestimmten Knoten aus ganz deaktivieren können. Wenn wir die Szene jetzt ausführen, können
wir das Spiel pausieren und wieder
unterbrechen, da
der Player-Node trotzdem immer läuft Aber das schafft ein neues Problem. Wenn wir das Spiel unterbrechen und die Sprungtaste
drücken und dann die Pause beenden, springt der
Charakter Wenn wir dieses Verhalten nicht wollen, müssen
wir zum Drehbuch
des Spielers zurückkehren Lassen Sie uns zunächst das Häkchen für
die Pause-Taste an den
Anfang der Eingabefunktion verschieben . Wenn der Baum dann angehalten ist,
ignorieren Sie alle weiteren Eingaben, indem zurückkehren. Gehen Sie dann in der Prozessfunktion
genauso vor, um auch die Bewegungs- und
Kamerasteuerung zu ignorieren Wenn das Spiel nun unterbrochen ist, kann
der Spieler nur noch etwas dazu sagen, das zu
unterbrechen Alles andere wird ignoriert. Schließlich möchte
ich auf dem
Bildschirm ein Menü mit einigen Tasten anzeigen,
während das Spiel angehalten ist Aber bevor wir etwas
mit der Benutzeroberfläche machen, sollten
wir die Fenstergröße des
Spiels konfigurieren Öffnen Sie die Projekteinstellungen und
wechseln Sie zur Registerkarte Allgemein. Fenster auswählen, können wir die Größeneigenschaft festlegen, um die
Fenstergröße unseres Spiels festzulegen. Die optimale Fenstergröße
hängt von Ihrer Zielplattform ab. Ich verwende 12 x 80 x 720 Pixel. Bisher wurde alles in
unserem Szenenbaum von der Kamera
beobachtet , um ein Zwei-D-Bild zu
erzeugen, das wir in unserem
Fenster sehen, wenn wir das Spiel spielen. Dieses von
unserer Kamera
gerenderte Zwei-D-Bild ist die Ebene Null
des Zwei-D-Displays. können wir weitere
Ebenen zur Anzeige unseres Spiels hinzufügen Nachdem die Kamera das Rendern abgeschlossen
hat , können wir weitere
Ebenen zur Anzeige unseres Spiels hinzufügen, indem wir
einen neuen Knotentyp verwenden, einen Canvas-Ebenenknoten. Die Standardebene eines
Canvas-Ebenenknotens ist eins, sie wird
also
über Ebene Null gezeichnet. Wenn wir möchten, können wir eine beliebige Anzahl von
Ebenen
hinzufügen , um sie vor
oder hinter unserem Spiel zu zeichnen. Benennen wir den
Canvas-Layer-Node in UY um, kurz für User Interface. rechten Maustaste auf den UI-Knoten und wählen Sie Untergeordneten Knoten hinzufügen aus. Fügen wir dem Canvass einen
Label-Knoten hinzu. Dadurch wird unsere Ansicht auf zwei
D umgestellt. Bisher haben wir nur mit Standardknoten wie
dem Player-Knoten und drei
D-Knoten für alles andere
gearbeitet dem Player-Knoten und drei
D-Knoten für alles Unser Canvas wird
eine andere Familie
von Knoten verwenden ,
die als Kontrollknoten bezeichnet werden und grüne Symbole haben. Ich benenne diesen Knoten in Titel um und setze seine Eigenschaft
auf Pause. Als Nächstes wiederholen wir den
Vorgang, um eine Schaltfläche hinzuzufügen. Und nenne die Schaltfläche Continue. Bearbeiten Sie dann den
Text der Schaltflächen so, dass er dasselbe sagt. Zoomen und schwenken Sie, sodass Sie das blaue Rechteck
rechts
von der grünen Y-Achse und
unterhalb der roten X-Achse
sehen können das blaue Rechteck
rechts
von der grünen Y-Achse und
unterhalb der roten X-Achse
sehen . Dies ist der Viewport
des Spielfensters. Unsere Knoten wurden
am Ursprung der Szene hinzugefügt, sodass sie in
der oberen linken Ecke des
Bildschirms gerendert werden , wenn wir das Spiel spielen, aber sie überlappen sich Organisieren wir diese Knoten
mithilfe eines weiteren Kontrollknotens, eines vertikalen Box-Containers Ein vertikaler Box-Container zeichnet eigentlich
nichts, aber wir ordnen seine
untergeordneten Objekte so an,
dass sie vertikal ausgerichtet sind. Das macht die Organisation schneller, als wenn wir jeden Knoten manuell
positionieren würden. sowohl den Titel
- als auch den fortlaufenden Knoten auswählen, können
wir sie per Mausklick und Ziehen
dem Knoten mit der vertikalen Box zuordnen und sehen, dass sie
automatisch neu angeordnet werden Lassen Sie uns auch die Schaltfläche „
Weiter“ duplizieren, um
eine weitere Schaltfläche zu erstellen , und dieser einen
Namen geben wir Exit Bearbeiten Sie dann die
Texteigenschaft entsprechend. Das vertikale Feld hat sich automatisch an
die zusätzliche Schaltfläche
angepasst. Lassen Sie uns das vertikale
Feld in Pausenmenü umbenennen. bei ausgewähltem
Pausenmenüknoten Erweitern Sie bei ausgewähltem
Pausenmenüknoten den Layoutbereich. Der voreingestellte Wert für den Anker ist
derzeit auf links oben eingestellt. Wir können
das Pausenmenü problemlos an
einer beliebigen Ecke oder in der
Mitte des Bildschirms verankern einer beliebigen Ecke oder in der
Mitte des Bildschirms Die Anker werden in
der Vorschau durch diese
vier grünen Pins dargestellt , die wir einzeln
klicken und sie über den Bildschirm
ziehen können klicken und sie über den Bildschirm
ziehen Die Anker bestimmen die Position oder Größe der
Notizen
im Verhältnis zur Fenstergröße, die wir in den Projekteinstellungen festgelegt haben, ausgedrückt Wir können auch benutzerdefinierte Anker verwenden ,
wenn wir beispielsweise nur die oberen 10% des Bildschirms für eine Menüleiste
verwenden möchten oder vielleicht
das mittlere Drittel
des Bildschirms für die
Anzeige einer Anzeigetafel verwenden möchten Ich verankere mein Pausenmenü in
der Mitte des Bildschirms
und stelle außerdem die
horizontale Ausrichtung der Titel so ein, und stelle außerdem die
horizontale Ausrichtung der Titel Tasten
entsprechend zentriert sind Nachdem das Pausenmenü erstellt wurde, setzen
wir dessen
Eigenschaft visible standardmäßig auf false indem wir in der Szenenstruktur auf das Symbol
neben dem Menü klicken. Dann können
wir im Game Manager-Skript ein Ready verwenden, um einen
Verweis auf das Pause-Menü zu erhalten. Verwenden Sie das $1-Zeichen, um einen Knotenpfad
anzugeben, verwenden Sie Anführungszeichen, weil
der Name ein Leerzeichen enthält.
Gehen Sie durch den UI-Knoten, um
auf den Pausenmenüknoten zuzugreifen. Wenn das Spiel
pausiert oder nicht angehalten wird, können
wir die Eigenschaft „
Sichtbar“ des Pausenmenüs so einstellen, können
wir die Eigenschaft „
Sichtbar“ des Pausenmenüs so einstellen dass sie
dem Wert „Pause“ in der Baumstruktur
entspricht Jetzt haben wir ein
Pausenmenü mit Tasten,
aber woher wissen wir, wann
die Tasten gedrückt werden,
und was tun wir, wenn sie gedrückt werden und was tun Wenn wir die
Exit-Taste im Szenenbaum auswählen, können
wir vom
Inspektor-Tab zum Node-Reiter wechseln, auf dem standardmäßig
Signale angezeigt werden. Wenn Gruppen angezeigt werden, können
Sie zu Signalen wechseln,
indem Sie hier klicken. Hier sehen wir eine
Vielzahl von Signalen, die dieser Knoten unter
verschiedenen Bedingungen aussendet. Der Tastenknoten gibt ein
Signal aus, wenn er gedrückt wird. Alles, was wir tun müssen, ist,
dieses Signal mit einer Funktion zu verbinden, entweder indem wir darauf doppelklicken oder mit der rechten Maustaste klicken und Verbinden
auswählen. In dem Fenster können wir
einen beliebigen Knoten in unserem Szenenbaum auswählen, bei dem wir auf das Signal
warten, das gesendet werden soll. Wenn wir den
Game Manager-Knoten auswählen, wird im Feld für
die Empfängermethode
die Meldung „Beim Beenden gedrückt “ angezeigt. Das ist der Name der
Funktion, die für uns
erstellt wird , wenn
wir auf Verbinden klicken. Unsere Ansicht wechselt
automatisch zum Skript und zeigt das
Game Manager-Skript an, das jetzt die Funktion „Beim
Beenden gedrückt“ enthält. Diese Funktion wird nun
automatisch aufgerufen , wenn der Spieler die
Exit-Taste drückt. Ein grünes Verbindungssymbol
wird neben
der
Funktionsdefinition angezeigt , um uns mitzuteilen , dass diese Funktion durch ein Signal aufgerufen
wird, und die Exit-Taste im Szenenbaum hat
ein Signalsymbol,
das uns
mitteilt, dass dieser Knoten
ein Signal aussenden kann , das mit einem Empfänger
verbunden ist. Lassen Sie uns zunächst einfach an die Ausgabe
eine Meldung mit der
Aufschrift „
Zurück zur Titelszene“ senden. Sowohl damit wir wissen, dass es funktioniert, als auch um uns
daran zu erinnern,
diese Funktion später zu implementieren. Wenn wir auf die Schaltfläche Weiter klicken, können
wir das gedrückte Signal auch mit
dem Game Manager-Node verbinden . Aber dieses Mal klicken Sie
auf die Auswahltaste
und wählen Sie die
Funktion zum Umschalten zwischen Pause, die wir zuvor geschrieben haben Schließlich benötigen wir diesen Knoten, um zu verarbeiten, während
das Spiel pausiert ist Lassen Sie uns also seinen
Prozessmodus auf pausiert ändern. Lass es uns ausprobieren Wir können das Spiel pausieren, wenn wir auf
die Exit-Taste klicken, wird
unsere Nachricht angezeigt und wenn die Schaltfläche Weiter klicken, wird das Spiel
angehalten Sobald die
Menütasten den Fokus haben, können
wir auch die
Pfeiltasten verwenden, um
zwischen den Tasten zu wechseln , und die
Leertaste verwenden, um sie zu drücken Lassen Sie uns das
mit nur ein
paar weiteren einfachen Schritten
auch mit unserem Gamecontroller zum Laufen bringen. Öffnen Sie die Projekteinstellungen, die Eingabekarte klicken Sie auf den
Schalter „Integrierte Aktionen anzeigen “, um die verwendeten
Aktionen zu sehen Das Controller-DP ist bereits unter der Benutzeroberfläche links,
rechts oben und unten
aufgeführt , um
durch Menüs zu navigieren Aber wir müssen
der Benutzeroberfläche eine
Controller-Eingabe hinzufügen, um die Tasten drücken zu
können Ich verwende die untere
Aktionstaste, die A auf meinem Controller ist. Jetzt brauchen wir nur noch das Menü, um den
Fokus zu bekommen, wenn es geöffnet wird. dem Pausenmenüknoten ein Skript hinzufügen, nennen
wir es einfach Menü. Wir exportieren eine Variable
für das Menüelement, das standardmäßig den
Fokus erhalten sollte, wenn das Menü geöffnet wird,
vom Typ control. Ich weise die Schaltfläche „
Weiter“ als
Standard-Fokuselement
im Inspektor zu Standard-Fokuselement
im , indem ich sie anklicke und
in das Feld ziehe Wenn wir eine öffentliche Funktion erstellen, nennen
wir sie offen. Wir können die
Eigenschaft visible auf true setzen und auch dem
Standard-Fokuselement mitteilen, dass es den Fokus übernehmen soll. Und eine weitere Funktion, die geschlossen
wird, setzt die
Eigenschaft visible wieder auf „fällt“ zurück. Zurück im Game Manager-Skript. Anstatt die Eigenschaft visible
der Pause-Many direkt festzulegen , können
wir basierend auf dem Wert
von paused entweder open oder
closed aufrufen basierend auf dem Wert
von paused entweder open oder
closed , indem wir
eine if-Anweisung verwenden die Szene
nur mit einem Controller ausführen, können
wir das Spiel pausieren, im Menü
navigieren und die Tasten
drücken Wir haben jetzt ein Pausenmenü, das dem Spieler
angezeigt wird , wenn er die Pause drückt. In der nächsten Lektion werden wir eine Titelszene
für unser Spiel
erstellen. Wir sehen uns in der nächsten Lektion.
3. Stellenbezeichnung: Hallo, Freunde. In
der vorherigen Lektion haben wir ein Pausenmenü
für unsere Spielszene erstellt. In dieser Lektion erstellen wir eine Titelszene, die eine Verbindung
zur Spielszene herstellt. Dafür benötigen wir
ein Hintergrundbild und einige grundlegende Benutzeroberflächenelemente. Ich werde das Basic Guy Bundle von
Penzila auf It Shot IO verwenden von
Penzila auf It Shot Beginnen wir mit der
Erstellung einer neuen Szene. Sie können in der
Menüleiste eine Szene und dann eine neue Szene auswählen. Verwenden Sie die Tastenkombination
Strg N oder Befehl N oder
klicken Sie mit der rechten Maustaste auf die Registerkarte Dateisystem
und wählen Sie Neue Szene erstellen. rechten Maustaste auf einen
bestimmten Ordner klicken, wird
die Szene in diesem Ordner erstellt und wir
können ihr sofort
einen Namen geben. Es spielt keine Rolle, ob es sich bei dieser
Szene um zwei D oder drei D handelt, da wir für diese Lektion nur an UY
interessiert sind. Machen wir aus dem Stammknoten dieser Szene einen Kontrollknoten, indem
wir Benutzerschnittstelle wählen. Und der Stammknoten
wird automatisch umbenannt, sodass er dem
Namen des Szenentitels entspricht. Wenn wir die Szene
über das Menü erstellen, werden
wir aufgefordert, zuerst
den Root-Knotentyp auszuwählen. Benennen Sie es dann und sortieren Sie es beim
ersten Speichern in einen Ordner. den Wurzelknoten auswählen, können
wir sehen, dass es sich um
einen Kontrollknoten handelt , dessen
Anker-Voreinstellungen auf Full Wreck gesetzt sind, der das gesamte Spielfenster
abdeckt, aber eigentlich nichts
zeichnet Wie in der vorherigen Lektion fügen
wir einen Labelknoten
und einige Geben wir dem Label den Namen Titel der Notiz und setzen wir die
Texteigenschaft auf den Titel unseres Spiels. Benennen Sie dann auch
unsere Buttons und bearbeiten Sie ihre
Texteigenschaften auf Neues Spiel. Fahren Sie fort. Einstellungen, Credits und Beenden oder andere Schaltflächen du gerne auf dem Titelbildschirm
deines Spiels haben möchtest. Lassen Sie uns
diese Schaltflächen auch
mithilfe eines vertikalen Box-Containers anordnen mithilfe eines vertikalen Box-Containers wie wir es beim Pausenmenü getan haben und sie in Menüschaltflächen umbenennen. organisieren Mithilfe von Ankern können wir
diese Elemente schnell und
einfach auf unserem
Bildschirm Ich möchte zum Beispiel, dass
der Titel
horizontal auf dem Bildschirm zentriert und um horizontal auf dem Bildschirm zentriert und ein Drittel vom
oberen Bildschirmrand nach unten ausgerichtet wird Wenn die Titelbeschriftung
ausgewählt ist und der Layoutbereich
erweitert wird, ändere ich die
Voreinstellungen für den Anker auf Benutzerdefiniert Anker sind
als Zahlen von 0 bis 1 definiert stellen den Prozentsatz der Breite oder Höhe
der übergeordneten Elemente dar Breite oder Höhe
der übergeordneten Elemente den Titel
horizontal in
der Mitte des Bildschirms positionieren können den Titel
horizontal in
der Mitte des Bildschirms positionieren,
indem Sie den linken
Anker auf 0,5 setzen. Der rechte Anker wird
automatisch
entsprechend aktualisiert, Der rechte Anker wird
automatisch
entsprechend aktualisiert da der rechte Anker nicht kleiner als der linke sein
darf Ebenso würde die Positionierung des Titels
ein Drittel vom oberen Bildschirmrand bedeuten,
den oberen Anker auf 0,333 zu setzen Diese Position
ist noch nicht ganz so, wie ich es mir wünsche, da die Anker in der oberen
linken Ecke des Labels befinden Der Text wird einfach nach rechts und unter
dem Ankerpunkt abgespielt rechts und unter
dem Ankerpunkt den Unterabschnitt
Wachstumsrichtung erweitern, können
wir sowohl die horizontale als auch die
vertikale
Wachstumsrichtung auf beide festlegen vertikale
Wachstumsrichtung auf beide Wenn wir den Unterabschnitt „
Ankerversatz“
auslagern, können wir sie alle auf Null zurücksetzen Jetzt sind die Anker innerhalb des Labels
zentriert Ich werde auch den
Button-Container auf die gleiche Weise positionieren Button-Container auf die gleiche Weise Der vertikale
Anker befindet sich jedoch zu zwei Dritteln nach unten, sodass er unter
dem Spieltitel erscheint. Du kannst jeden
deiner Kontrollknoten auch manuell positionieren. Denke
aber daran, dass die Verwendung von
Ankern deine Layouts
flexibler macht und sich an
unterschiedliche Bildschirmauflösungen anpassen Fügen wir nun
dem Knoten Mini-Buttons ein Manuskript dem Knoten Mini-Buttons und weisen ihm im Inspektor ein
Standard-Fokuselement So wie unsere Spielszene
ein Game Manager-Skript
an ihren Stammknoten angehängt hat , benötigen
wir auch ein
Titel-Manager-Skript an den Stammknoten der
Titelszenen
angehängt ist. Und hier können wir mit dem Add-On Ready einen Verweis auf
das Skript für die Menüschaltflächen
während der Bereitschaftsphase
abrufen das Skript für die Menüschaltflächen . Sagen Sie dann den Menütasten, dass sie sich in der Bereitschaftsfunktion
öffnen sollen. Das Menü war bereits sichtbar,
aber wenn wir es anweisen, es zu
öffnen, weisen wir auch das
Standard-Fokuselement an, den Fokus zu übernehmen. jeden
der Button-Knoten auswählen, können
wir unserem
Title-Manager-Skript für alle einen
Funktionsaufruf
hinzufügen, der gedrückt gehalten wird. Vorerst werden wir uns nur mit der
neuen Spieltaste
befassen. Der Rest kann einfach Zeichenketten
ausdrucken, um uns
mitzuteilen, dass wir
diese Funktionen später implementieren sollen. Der Zweck der neuen
Spielschaltfläche wird darin bestehen,
unser Spiel von der
Titelszene zur Spielszene zu wechseln . Das können wir erreichen, indem einen Verweis
auf den Szenenbaum abrufen und dann auf eine Methode
namens Change Scene to File zugreifen. Diese Methode benötigt
ein String-Argument, das einen Dateipfad zu
der Szene darstellt, die wir laden möchten. Die Vorschläge enthalten eine Liste aller Szenen
in unserem Projekt, sodass wir die
Spielszene von hier aus auswählen können. Alternativ können
wir
auf der Registerkarte Dateisystem nach der
Spielszene suchen und mit der rechten Maustaste klicken, dann Pfad kopieren auswählen und sie als Text einfügen. Denken Sie jedoch daran, dass Zeichenketten in
Anführungszeichen eingeschlossen werden
müssen. Bisher haben wir die Schaltfläche „
Aktuelle Szene ausführen“ verwendet , um unser Spiel zu testen. Aber wahrscheinlich hast du inzwischen
versehentlich
mindestens einmal
die Schaltfläche „Projekt ausführen“ gedrückt ,
wodurch die Hauptszene
unseres Projekts eingestellt wurde wodurch die Hauptszene
unseres Projekts eingestellt . Dies ist die erste
Szene, die geladen
wird ,
wenn wir das Spiel
starten sollte diese
Szene sein, die Titelszene. Falls du das noch nicht eingestellt hast, kannst
du auf die Schaltfläche „Aktuell
auswählen“ klicken, um die Titelszene als Hauptszene
des Spiels
festzulegen. Die Schaltfläche „Neues Spiel“ aktiviert den
Fokus, wenn das Spiel beginnt. Wenn Sie auf jede der Schaltflächen klicken, werden unsere Kontoauszüge
ausgedruckt, und wenn Sie auf die Schaltfläche „
Neues Spiel“ sofort
zur Spielszene gewechselt Wir können die
Hauptszene des Projekts auch jederzeit
in
den Projekteinstellungen auf der Registerkarte Allgemein
unter Anwendung ausführen Min. Szene bearbeiten in
den Projekteinstellungen auf der Registerkarte Allgemein . Unsere Titelszene ist
jetzt funktionsfähig, sieht
aber nicht besonders gut aus. Zunächst können wir mithilfe eines Textknotens einen
Splash-Hintergrund hinzufügen. Nennen wir es Hintergrund. im Layout-Bereich Wenn Sie im Layout-Bereich die Anker auf Full Wreck
voreinstellen,
wird sichergestellt, dass der Hintergrund das gesamte
Fenster abdeckt Wir können die Textureigenschaft so bearbeiten , dass jedes beliebige
Zwei-D-Bild angezeigt Mithilfe der Eigenschaften
im Inspektor können
wir ändern, wie das Bild angezeigt
wird, sodass es entweder
seine ursprüngliche Größe beibehält oder ob es in
der Breite oder Höhe innerhalb der Ankerpunkte liegt. Wir können auch festlegen, dass
das Bild
sein Seitenverhältnis beibehalten soll , um zu verhindern, das Bild so gestreckt wird
, dass es in das Fenster passt. Schließlich ordnen wir es
oben in den Szenen (Kinder) an, sodass es zuerst gezeichnet wird,
hinter allem anderen. Schauen wir uns als Nächstes die Eigenschaften
der Titellabelknoten an. Die meisten
Labeleinstellungen haben mit Ausrichtung
und Umbruch zu tun, was für unseren Titel nicht wirklich
relevant ist. Die Einstellungen, die wir ändern möchten,
befinden sich unter den Eigenschaften, die wir von der Steuerung
übernommen haben , im Abschnitt zum Überschreiben
des Themes. Hier können wir
die Schriftfarbe anpassen. Fügen Sie einen Schatten oder eine Kontur hinzu, die
auch im Unterabschnitt
Konstanten angepasst werden können auch im Unterabschnitt
Konstanten angepasst werden Wir können die Schriftgröße
und auch die Schrift selbst ändern und auch die Schrift Ich habe ein paar
kostenlose Schriftarten von dafont.com heruntergeladen. Vergewissere dich, dass alle Schriften, die du
in deinen Spielen verwendest, kostenlos sind. Da Font zeigt die Lizenzierung für ihre Schriften über
dem Download-Button an. Das funktioniert gut für
unseren Spieletitel
, der auffallen soll, aber einzelne
Eigenschaften auf
diese Weise für alles in
unserem Projekt zu bearbeiten , wäre mühsam Für die Bearbeitung unserer Menüschaltflächen sollten
wir stattdessen ein gemeinsames Thema
erstellen, sollten
wir stattdessen ein gemeinsames Thema
erstellen im gesamten Spielprojekt
verwenden können Auswahl des
Button-Container-Nodes. Erweitern Sie diesmal
den Themenbereich. Das Themenfeld ist leer. darauf klicken, können wir ein
neues Thema auswählen , um eine neue
Themenressource für unser Projekt zu erstellen. Wenn Sie auf die Themenressource klicken,
wird
im unteren Bereich unseres
Fensters eine neue Registerkarte hinzugefügt , ein Theme-Editor. Der Theme-Editor
enthält eine Vorschau verschiedener Kontrollknoten, ein spielbares Bedienfeld,
verschiedene Arten von
Schaltflächen, Umschaltern, Dropdown,
Farbauswahl, Textfelder,
Bildlaufleisten, Trennzeichen,
Tabs Alle verwenden das Standarddesign, das von Gadot
bereitgestellt wird. auf unsere
Theme-Ressource im Inspektor-Panel zurückblicken , können
wir die Standardschrift und
Schriftgröße für alles
in unserem Theme bearbeiten Schriftgröße für alles
in unserem Theme Lassen Sie uns die Schriftart ändern
und die Größe anpassen. Wir können die Effekte sowohl in
der Vorschau als auch in unseren
Schaltflächen unseres Titelmenüs sehen . Dies hat keinen Einfluss auf
die Bezeichnung des Spieltitels da das Thema nicht auf diesen Knoten angewendet
wurde. Es wurde nur auf den Container mit
den Menüschaltflächen angewendet. Selbst wenn das Thema auf den Titelknoten
angewendet würde, die Theme-Overrides verwendet, die wir würden
stattdessen
die Theme-Overrides verwendet, die wir
gerade angewendet Die Schaltflächen übernehmen ihr Thema
von ihrem übergeordneten Element
in der Szenenstruktur Im Theme-Editor
können wir neue Einstellungen
für jeden Kontrollknoten hinzufügen , indem wir auf die Plus-Schaltfläche
klicken Da unser Menü
nur Schaltflächenknoten enthält, fügen
wir Einstellungen
für Schaltflächenknoten hinzu. Es gibt viele verschiedene
Einstellungen zum Anpassen der Schrift- und Symbolfarben in verschiedenen
Zuständen der Schaltfläche. Standardeinstellung, Deaktiviert,
Fokussiert,
Hover, Hover gedrückt und gedrückt, sowie eine Umrissfarbe Bevor wir
eine dieser Einstellungen anpassen können, müssen
wir sie dem Theme
hinzufügen, indem wir auf die
Plus-Schaltfläche neben ihnen indem wir auf die
Plus-Schaltfläche neben eine dieser Einstellungen anpassen, können
wir ihre
Auswirkungen in der Vorschau sehen,
einschließlich der Zustände beim Bewegen des Mauszeigers, des Fokus
und des Drücken, wenn
Sie auf die Schaltflächen klicken Es gibt zusätzliche
Einstellungen und andere Registerkarten zum
Anpassen von Konstanten, Schriftarten und Schriftgröße Die Schriftart und
Schriftgröße
wurden bereits von der
Theme-Ressource selbst festgelegt Wir müssen sie hier nicht
anpassen. Wir können auch das Aussehen
der Schaltfläche selbst
mithilfe von Style-Boxen ändern . Jeder der Schaltflächenstatus
kann einer
anderen Stilbox zugewiesen werden. Fangen wir mit Normal an.
Wenn wir auf die Plus-Schaltfläche klicken, können
wir ein flaches
Stilfeld verwenden, um einfach ein flaches farbiges
Rechteck für die Schaltfläche zu
erstellen, oder wir können ein
Texturstilfeld verwenden um ein importiertes Zwei-D-Bild zu verwenden. Wenn Sie auf die
Style-Box-Ressource klicken, wird sie
im Inspektorfenster geöffnet ,
wo wir
das Texturfeld mit
einer Zwei-D-Bilddatei füllen können das Texturfeld mit
einer Zwei-D-Bilddatei Möglicherweise möchten Sie an den
Rändern der Schaltfläche
etwas Abstand hinzufügen ,
damit sich der Schaltflächentext nicht mit den Rändern des Bildes
überschneidet den Bereich mit den
Inhaltsrändern erweitern, können
wir die
Größe der Ränder anpassen , damit der Text besser
in das Bild passt ein gedrücktes Stilfeld hinzufügen, können
wir die Textur ändern, die zum Zeichnen der Schaltfläche verwendet wird. Durch das Kopieren derselben Einstellungen wird
das normale Stilfeld bereinigt, aber der obere Abstand wird vergrößert, sodass der Text beim Drücken
nach unten verschoben Es wurden weitere Stilfelder für
deaktivierte Hover- und
Fokusstatus hinzugefügt deaktivierte Hover- und
Fokusstatus Möglicherweise verfügen Sie nicht über
unterschiedliche Texturen für all Ihre verschiedenen
Schaltflächenstatus Aber wir können immer noch neue
Style-Boxen für diese Zustände erstellen. Verwenden Sie dieselbe normale
Textur und dieselben Einstellungen, fügen Sie
jedoch
eine
Farbmodulation hinzu, um
der Schaltfläche in diesem Zustand ein anderes Aussehen zu verleihen . Wir können die
Farben der Textur mit etwas wie
Gelb multiplizieren , sodass sie deutlich
anders
aussieht , wenn sie bedeckt ist Oder wir können einfach
ein anderes Bild in
einer anderen Farbe verwenden , um den Fokus
zu betonen Wenn diese Option deaktiviert ist, können wir
die Alpha-Farben multiplizieren , um für
mehr Transparenz zu sorgen. Wir können all diese
verschiedenen Style-Boxen
einfach in der Vorschau
im Theme-Editor testen . Jetzt sieht das
Restmenü besser aus Lassen Sie uns auch das Pausenmenü
in der Spielszene entsprechend bearbeiten . Anstatt
dem Pausenmenü ein neues Thema hinzuzufügen und
alle Änderungen erneut vorzunehmen, können
wir stattdessen
zur Titelszene zurückkehren, die Ressource
suchen und auf das
Dropdown klicken Wählen Sie Speichern und speichern Sie das Thema in unserem
Projektressourcenordner In der Spielszene können
wir dieses Thema
jetzt dem Pausenmenü zuweisen, und die Schaltflächen
werden automatisch aktualisiert, sodass sie
dem neuen Thema entsprechen. Das Game Manager-Skript öffnen. Wenn der Spieler
die Exit-Taste drückt, können
wir auch
zur Titelszene wechseln. Wenn wir unser Spiel ausführen,
beginnen wir in der Titelszene. Die neue Spieltaste
wechselt zur Spielszene. das Spiel pausieren und
Beenden wählen , kehren Sie zur Titelszene zurück Wir haben jetzt eine
Titelszene und können zwischen unseren beiden Szenen hin und her
wechseln In der nächsten Lektion glätten wir
den Szenenübergang, indem wir ihn zu Schwarz ausblenden Wir sehen uns in der nächsten Lektion.
4. Übergänge: Hallo Freunde. In
der vorherigen Lektion haben wir eine Titelszene erstellt und eine
Verbindung zur Spielszene hergestellt. In dieser Lektion
sorgen wir mit einer visuellen Überblendung für einen
reibungsloseren Übergang mit einer visuellen Überblendung für einen
reibungsloseren Die meisten Spiele beginnen
mit einem schwarzen Bildschirm. Fügen wir unserer Titelszene einen neuen Knoten
hinzu, einen farbzerstörten Knoten Nennen wir es Fade.
Im Inspector können
wir die
Farbeigenschaft auf Schwarz setzen. Stellen Sie dann die Ankervorgaben auf Full Wrack, um
das gesamte Fenster abzudecken Wenn das Spiel beginnt, können
wir dieses Objekt sanft ausblenden, sodass es vollständig
transparent ist die
Titelszene dahinter zum
Vorschein Selbst wenn ein Objekt in
unserer Szene transparent ist, werden
Mausereignisse nur ausgelöst, wenn sie das
erste Mal treffen. Das bedeutet, dass das Bewegen der
Maus oder das Klicken auf unsere Tasten durch das Ausblenden
blockiert wurde. In den Eigenschaften, die wir von der
Steuerung übernommen haben, können wir im Bereich Maus die
Filtereinstellungen unserer Überblendung so ändern, dass sie ignoriert werden, sodass
die Mausereignisse durch die Überblendung auf
die Objekte dahinter
übertragen werden können. Jetzt funktionieren die Tasten wieder
mit der Maus. Während wir im Editor an
unserer Szene arbeiten, wäre
es besser, wenn wir alles andere sehen könnten. Ich möchte,
dass der Fade standardmäßig sichtbar ist. Bevor wir ein Skript anhängen, beginnen wir damit,
unsere Skripte in
spezifischeren Ordnern zu organisieren, indem
wir einen Unterordner mit dem Namen UI
erstellen Wir können das Manuskript in
den Unterordner verschieben , da es zur Steuerung von UI-Elementen
verwendet wird Aber wenn Sie Ressourcen
auf diese Weise verschieben,
stellen Sie sicher, dass die Szenen, in denen sie
verwendet werden, zuerst geöffnet sind Andernfalls
könnten die Szenendateien den Überblick verlieren. Wenn das passiert, verschieben Sie
die Ressource einfach wieder dorthin,
wo sie ursprünglich war und stellen Sie sicher, dass
die Szenen, in denen
die Ressource verwendet wird, geöffnet sind,
bevor Sie sie verschieben. Jetzt können wir ein Skript
an den Fad-Knoten anhängen und es mit dem Browser
in den UI-Skriptordner sortieren Im Gegensatz zu unserem Manuskript, das jeden Kontrollknoten relevant sein
könnte, da es sich nur auf
die sichtbare Eigenschaft auswirkte, die von control übernommen wird Dieses FAD-Skript wird die Farbeigenschaft
des farbzerstörten Knotens ändern , sodass es nur von
Farbknoten oder deren Erben verwendet werden kann Farbknoten oder Fangen wir mit der Ready-Funktion an. Die Eigenschaft „Sichtbarkeit“
des Fa wird beim ersten Start der
Szene auf „true“ gesetzt, sodass das Fenster
komplett schwarz wird. Dann können wir eine öffentliche
Funktion deklarieren, die zum Löschen aufgerufen wird. Im Gegensatz zu den meisten Funktionen
in den meisten Skripten muss
dies im Laufe der Zeit
schrittweise geschehen und sich über mehrere Frames
erstrecken Das können wir mit einem
neuen Variablentyp, einem Tween, erreichen. Dies kann eine private Variable sein, nur lokal für
dieses Skript gilt, und ich nenne sie der Einfachheit halber einfach
Tween Der Name dieser
Klasse leitet sich von den englischen Wörtern in between ab, da sie am
häufigsten verwendet wird, um
Punkte zwischen einem Start- und einem
Endpunkt zu finden Punkte zwischen einem Start- und einem
Endpunkt Wir können jederzeit ein Tween erstellen, indem eingebaute
Methode create tween
aufrufen Diese Methode gibt
ein Tween-Objekt zurück, das wir
unserer Variablen zuweisen können, um es zu speichern Ein Tween ist eine komplexe Klasse
mit einer Vielzahl von Methoden,
aber die, die wir verwenden möchten,
heißt Tween-Eigenschaft, für
die mehrere Argumente erforderlich sind Das erste Argument ist der Knoten, auf den sich dieses Tween auswirken
wird. Dabei handelt es
sich um denselben Knoten, an den
dieses Skript angehängt ist können wir einen Verweis auf
diesen Knoten abrufen Schlüsselwort self können wir einen Verweis auf
diesen Knoten abrufen Die nächste ist die
Knoteneigenschaft, die wir ändern möchten, ein Eigenschaftspfad als Zeichenfolge. Wir werden die
Farbeigenschaft dieses Knotens ändern. Wenn Sie sich bezüglich
des Eigenschaftenpfads nicht sicher sind, können
wir im Inspektor nachschauen. Maus über eine Eigenschaft fahren, wird uns der
Eigenschaftspfad
angezeigt,
über den Sie darauf zugreifen können auch mit der rechten Maustaste klicken, um
den Eigenschaftspfad zu kopieren und als Text
einzufügen Das nächste Argument ist
der Endwert, auf diese Eigenschaft gesetzt werden soll,
wenn das Tween fertig ist Da es sich bei der Eigenschaft um eine Farbe handelt, setzen
wir sie auf eine
benutzerdefinierte Farbe, die wir definieren werden Nennen wir es klar. Und die letzte Eigenschaft ist die Dauer, die
das Tween dauern wird,
gemessen in Sekunden, ausgedrückt als Gleitkommazahl Stellen wir es vorerst auf 1
Sekunde ein. Der Wert von clear wird
etwas sein , das wir
definieren können, aber niemals ändern. Anstatt eine Variable zu deklarieren, können
wir eine Konstante
mit dem Schlüsselwort constant definieren Nennen Sie es ohne Schriftfarbe. Es ist üblich,
Konstanten ausschließlich in Großbuchstaben zu benennen. Weisen Sie dann den Wert
dieser Konstante als Farbe zu. den Klassennamen
gefolgt von Klammern schreiben, auf eine Konstruktormethode zugegriffen, die
es uns ermöglicht, die Farbe zu
konstruieren indem wir alle
erforderlichen Eigenschaften angeben Eine Farbe wird aus Gründen der
Transparenz durch vier Gleitkommazahlen definiert:
Rot, Grün, Blau und
Alpha A hat die Zahlen 0-1. Unsere klare Farbe wird
einfach Null,
Rot, Null, Grün, Null, Blau und Null Alpha sein, wodurch sie schwarz, aber auch vollständig transparent unsere Methode two
clear aufrufen
, wird die Farbeigenschaft innerhalb
von 1 Sekunde von ihrem aktuellen Wert
, der schwarz ist, auf transparent umgestellt. Wir können auch
eine andere Funktion
nach Schwarz schreiben , um das Gegenteil zu bewirken. Wir müssen
jedoch keine Konstante für
Schwarz definieren , da die
Farbklasse bereits eine hat. Wir können über den
Klassennamen mit einem Punkt darauf zugreifen
und sehen, dass es
eine große Anzahl
vordefinierter Farben gibt . Die, die wir
gerade wollen, ist schwarz. Schwarz ist definiert als Null, Rot, Null, Grün, Null,
Blau, aber ein Alpha. Lassen Sie uns für einen Moment zum
Titelmanager-Skript übergehen und abrufen ready einen Verweis auf den FAD Noe
während der
Bereitschaftsphase Wenn die Szene beginnt,
können wir Fate mitteilen, dass die Notiz
gelöscht werden soll Bevor wir dann
zur Spielszene wechseln, können
wir ihr sagen, dass sie schwarz wird. Der Vorgang des Ausblendens
zu Schwarz benötigt jedoch Zeit, und diese Funktion wird in
einem Frame ausgeführt und
wechselt sofort zur Spielszene, sodass wir es nicht sehen. Wir können diese
Funktion anweisen, eine Pause einzulegen und auf ein Signal zu warten,
bevor wir weitermachen, indem wir ein neues Schlüsselwort, eine Gewichtung, Eine Gewichtung benötigt ein
Signal, auf das wir warten müssen
, und wir können es von
der Funktion „Fade to Black“ zurückschalten. Zurück im FAD-Skript können
wir einen Rückgabetyp
für unsere Funktionen
vor dem Doppelpunkt angeben,
indem wir einen Bindestrich, einen Pfeil
gefolgt von einem Typ hinzufügen können
wir einen Rückgabetyp
für unsere Funktionen
vor dem Doppelpunkt angeben ,
indem wir einen Bindestrich, einen Pfeil
gefolgt von einem In diesem Fall wollen wir ein
Signal zurückgeben. Die Tween-Klasse enthält
ein Signal, das automatisch
ausgegeben wird, wenn
das Tween beendet ist, sodass wir es zurückgeben können Jetzt wartet der Titelmanager, bis
der FAD-Knoten schwarz
wird ,
bevor er die Szene wechselt Butts kopiert dieses Format auch
in die Funktion Two Clear. Obwohl es ein Signal
zurückgibt, muss
der Titelmanager diese Rückgabe
nicht akzeptieren oder
irgendetwas damit anfangen. In diesem Fall
wird das Tween gestartet und der Rest der Funktion
wird sofort fortgesetzt Wir können diesen FAD-Knoten
in die Spielszene kopieren. Bearbeiten Sie dann das Game
Manager-Skript, um während der Bereitschaftsphase
einen Verweis auf den FAD-Knoten Wenn die
Szene zum ersten Mal gestartet wird, wird sie ausgeblendet, und warten Sie, bis
sie schwarz wird, bevor Sie
zur Titelszene wechseln Aber diese Funktion
beim Beenden
wird aufgerufen, während
das Spiel pausiert ist Daher wird auch der F-Knoten angehalten und
seine Farbe wird dadurch nicht verändert Wir können zulassen, dass der FAD-Knoten
immer weiterverarbeitet wird, um sich fortzubewegen Es wäre aber auch
eine gute Idee, das Spiel zu unterbrechen, bevor man zwischen den Szenen
wechselt Lass es uns ausprobieren. Jetzt beginnt das Spiel mit einem schwarzen Bildschirm, der in
unseren Titelbildschirm übergeht.
Wenn Sie die neue
Spieltaste drücken, wird es schwarz zur Spielszene
gewechselt,
die wieder eingeblendet Pause einlegen und die
Exit-Taste drücken, wird es schwarz und es wird zur Titelszene
gewechselt, die ebenfalls wieder eingeblendet wird Wenn Sie eine Pause einlegen und die
Exit-Taste drücken, wird es schwarz und es wird zur Titelszene
gewechselt, die ebenfalls wieder eingeblendet wird
. Es gibt jedoch ein Flackern zwischen den
einzelnen Szenen. Wir können die Projekteinstellungen in der
Renderumgebung bearbeiten Renderumgebung und die
Standardfarbe auf Schwarz ändern Das ist ein wesentlich
sanfterer Übergang als das sofortige
Umschalten zwischen den Szenen Wenn unser Spiel groß genug
wird um längere Ladezeiten zu erfordern, können
wir dies
in einen Ladebildschirm umwandeln. Es kann jedoch zu Problemen kommen
, ein Tween
gestartet wird, bevor das
vorherige abgeschlossen ist Zurück im FAD-Skript können
wir überprüfen, ob das Tween
existiert, indem wir es mit Null vergleichen Im Godo-Skript können wir das
implizit mit Just if Tween tun implizit mit Wenn es existiert,
überprüfe auch, ob es läuft. In diesem Fall sollten wir
den Tween töten , bevor wir einen neuen
erstellen Dadurch wird verhindert, dass mehrere Tweens existieren und sich gegenseitig
stören, da das neueste Tween einfach die Oberhand
gewinnt Unsere beiden Funktionen „Durchsichtig“ und „
Schwarz“ sind sich sehr ähnlich, nur der
Farbwert unterscheidet Es wird sich als gute Praxis erweisen, hier
stattdessen eine
private Funktion zu deklarieren. Nennen wir sie zweifarbig und akzeptieren eine Farbe
als Parameter. Wir können
das alles dann nur einmal machen. die Farbe an die
Methode mit zwei Eigenschaften übergeben und die beiden Funktionen
„Klar“
und „Schwarz “ stattdessen diese
Funktion mit zwei Farben aufrufen. Wenn das
Rücksignal durch die Kette geleitet wird,
können die Manager es abwarten. Auf diese Weise muss für Änderungen an diesem Verhalten
nur ein Codeblock geändert werden . Möglicherweise möchten Sie, dass das
Skript anpassungsfähiger ist. Lassen Sie uns eine Variable
für die Dauer
des Tweens exportieren und ihr einen
Standardwert von 1 Sekunde zuweisen Ersetzen Sie dann das
1-Sekunden-Argument durch unsere Variable, und jetzt kann das Timing von einfach
im Inspektor angepasst
werden Mal sehen, wie der FAD
mit der Dauer von 2 Sekunden aussieht mit der Dauer von 2 Sekunden Wir können dies noch
flexibler gestalten, indem wir
den beiden Funktionen Clear und zwei
Black erlauben ,
einen optionalen Parameter zu akzeptieren , um die angegebene Dauer zu
überschreiben Nennen wir den Parameter
Dauer ohne Unterstrich, wodurch er sich
von der Variablen unterscheidet , die einen Unterstrich hat Und weisen Sie ihm einen Standardwert für die Dauer
unseres Unterstrichs zu. Wir müssen diesen Wert dann
an die Zweifarbenfunktion übergeben an die Zweifarbenfunktion Und füge es der
Liste der Parameter hinzu. Verwenden Sie dann den Parameter in der Tween-Eigenschaftsmethode
anstelle unserer Variablen Unsere Manager-Skripte
können
diese Funktionen weiterhin verwenden , ohne eine Dauer
anzugeben In diesem Fall wird der
exportierte Wert sein. Sie können aber auch
eine andere Dauer angeben und diese stattdessen verwenden. Die exportierte
Dauer sollte 1 Sekunde sein, aber der
Titelmanager kann das überschreiben und stattdessen für eine Dauer
von 2 Sekunden einblenden. Wir haben jetzt einen sanfteren visuellen Übergang
zwischen unseren beiden Szenen. In der nächsten Lektion werden wir Informationen zwischen den Szenen
weitergeben. Wir sehen uns in der nächsten Lektion.
5. Autoload: Hallo Freunde. In
der vorherigen Lektion haben wir unsere Szenen ein- und ausgeblendet, um einen
reibungsloseren Übergang In dieser Lektion
fügen wir dem Szenenbaum zusätzliche Knoten hinzu, auf die von jeder Szene aus
zugegriffen werden kann Wenn wir unser Spiel starten und
zum Remote-Szenenbaum wechseln. Wir können sehen, dass die Wurzel
des Szenenbaums nur ein Kind hat, nämlich die Titelszene. Beim Wechsel zur
Spielszene wird
die Titelszene aus
dem Baum entfernt und durch die Spielszene
ersetzt. Wenn wir
Informationen zwischen Szenen weitergeben möchten, können
wir dem Stammknoten
des Szenenbaums zusätzliche Kinder
hinzufügen , die dort bleiben,
solange das Spiel läuft. Diese werden als automatische Ladevorgänge bezeichnet, und wir können sie erstellen,
indem wir Skripte schreiben. Lassen Sie uns zunächst einen
speziellen Ordner innerhalb des Scripts-Ordners hinzufügen, in dem
unsere automatischen Ladeskripte gespeichert werden. Klicken Sie dann mit der rechten Maustaste auf diesen
Ordner, um ein neues Skript zu erstellen. Der Zweck des Skripts
besteht darin, Daten zu speichern, zu laden und Zugriff auf Daten zu ermöglichen. Ich möchte
dieser Skriptdatei einen Namen geben. Da dies
nichts darstellt , was gezeichnet werden muss, kann
es vom Knoten erben Dieses Skript wird
zwei Variablen enthalten, die separate
Informationssätze, die aktuellen Einstellungen des Spiels und den aktuellen
Spielfortschritt des Spielers Möglicherweise möchten Sie eine
dritte Variable zum Speichern von Fortschrittsinformationen verwenden, die
mit einem Benutzerkonto verknüpft ist, aber nicht an einen
bestimmten Speicherbereich gebunden ist, z. B. das Freischalten von
Schwierigkeitsstufen oder Erfolgen Diese Variablen sind für jedes andere Skript in
unserem Spiel in jeder Szene öffentlich zugänglich jedes andere Skript in
unserem Spiel in jeder Szene Öffne die Projekteinstellungen und wechsle zur Registerkarte Automatisches Laden. Klicken Sie auf das Ordnersymbol neben
dem Pfadfeld, um einen Browser zu
öffnen, navigieren Sie
dann
zum Dateiskript. Das Feld mit dem Knotennamen
wird automatisch so ausgefüllt, dass es
dem Namen des Skripts entspricht. Klicken Sie auf die Schaltfläche Hinzufügen, um dieses Skript zur
Liste der automatischen Ladevorgänge hinzuzufügen. Wenn wir das Spiel jetzt starten, können
wir im
Remote-Szenenbaum sehen, dass der Root-Knoten einen weiteren
untergeordneten Knoten namens file hat. auf diesen Knoten klicken, können
wir sehen, dass er
zwei Variablen namens
settings und progress hat . zur Spielszene wechseln, wird
die Titelszene entfernt und durch
die Spielszene ersetzt, aber der Dateiknoten bleibt erhalten, sodass wir ihn verwenden können, um
Informationen zwischen Szenen auszutauschen. Ich habe jedoch keinen Typ für
die Variablen
angegeben ,
da wir unsere eigenen Typen erstellen wollen , um
komplexe Informationssammlungen
zu speichern . Lassen Sie uns einen weiteren
Unterordner
im Ordner Scripts erstellen und ihn Custom Resources
nennen. Klicken Sie dann mit der rechten Maustaste, um ein neues Skript zu
erstellen. Nennen wir es Einstellungen. Anstatt
von einem Knotentyp zu erben, erbt das Skript
diesmal von einer Ressource Dann können wir einen weiteren erstellen. Nennen wir das Fortschritt. In den Ressourcenskripten können
wir eine beliebige Anzahl von
Variablen unterschiedlichen Typs hinzufügen, aber sie müssen in Typen eingebaut sein, keine Verweise auf andere Dinge. Zum Beispiel können wir
eine boolesche Variable speichern,
die entweder wahr
oder falsch ist, um festzulegen ob die
Kamerasteuerung auf der X-Achse invertiert ist, und eine weitere
für die Zahlen können als Gleitkommazahlen gespeichert werden,
was Dezimalstellen erlaubt was Sie können dies verwenden, um
die Lautstärkeeinstellung des Spiels
als Zahl zwischen Null,
Stummschaltung oder einer vollen Lautstärke zu speichern die Lautstärkeeinstellung des Spiels
als Zahl zwischen Null, Stummschaltung oder einer vollen Zahlen können auch als Ganzzahlen
gespeichert werden, also als Zahl, die keine Dezimalstellen
enthält, aber positiv oder negativ sein kann Wir könnten dies im Fortschrittsskript verwenden
, um
das Geld der Spieler zu speichern oder Wir können Zeichenketten auch verwenden, um Zeichenfolgen zu
speichern Vielleicht geben wir dem Spielstand des
Spielers oder dem Protagonisten einen Namen andere eingebaute Typen wie Können auch andere eingebaute Typen wie
Vektoren oder Farben verwendet werden Sammlungen
dieser Typen können auch entweder in einem
Array oder einem Wörterbuch gespeichert
werden,
z. B. in einer Reihe von Booleschen Werten, die angeben, ob der Spieler jedes Level abgeschlossen
hat
oder nicht jedes Level abgeschlossen
hat Jeder dieser
Variablentypen hat einen Standardwert. Boolesche Werte sind falsch, ganze Zahlen
und Zahlen sind Null. Zeichenketten, Arrays und
Wörterbücher sind alle leer. Wenn eine Ressource erstellt wird, ruft
sie automatisch eine eingebaute Funktion auf, die in ihr benannt Kurz vor der Initialisierung. Variablen angeben Wenn wir diese
Funktion überschreiben, können wir
beliebige Standardwerte für unsere Vielleicht beginnen wir unsere
Lautstärkeeinstellung mit 0,5 für eine oder geben dem Protagonisten
einen Standardnamen Um unsere Ressource zu erstellen,
müssen wir einen Klassennamen angeben, was
oben im Skript gemacht wird Normalerweise in derselben Zeile
wie das Schlüsselwort extends. Mit dem Schlüsselwort Klassenname können
wir dieser
Ressourcenklasse einen Namen geben, der von anderen Skripten
verwendet wird ,
um auf diese Klasse als Typ zu verweisen. Wir können diese
Klasseneinstellungen mit
einem großen S benennen , und diese Klasse,
Progress, mit einem P.
Herkömmlicherweise werden
Klassen in Pascal-Groß - und Kleinschreibung benannt, - und Kleinschreibung benannt wobei der erste Buchstabe
jedes Worts groß Zurück im Dateiskript
können wir nun die Typen
unserer Variablen als
Einstellungen und Fortschritt angeben unserer Variablen als
Einstellungen Im Moment können wir
diese Ressourcen einfach in
der Ready-Funktion erstellen . Verwenden Sie ihren Klassennamen,
gefolgt von Punkt Neu. Dadurch wird auch
die Init-Funktion ausgelöst, die Variablen
innerhalb der Ressource
initialisiert das Spiel ausführen, können wir
diese Variablen im
Remote-Szenenbaum sehen diese Variablen im
Remote-Szenenbaum Klicken Sie auf sie, sehen Sie sich
ihre Eigenschaftswerte an und bearbeiten Sie sie. Lassen Sie uns ihre
Werte ändern. Wechsle zur
Spielszene und vergewissere dich , dass die Änderungen während des Szenenübergangs bestehen bleiben
. Jedes Skript in unserem Spiel
kann dank des automatischen Ladens der Datei problemlos
auf
diese Ressourcen zugreifen . Öffnen wir das Spring Arm-Skript , das für die
Drehung der Kamera verantwortlich ist. Sein derzeitiges Verhalten
verwendet umgekehrte X- und Y-Achsen. Aber jetzt haben wir Variablen in unserer Einstellungsressource, die dies ein- oder ausschalten
sollten Beachten Sie, dass
das Drehen der Kamera um die X-Achse eine
vertikale Drehung ist, was die Spieler
als Y-Drehung verstehen werden,
und eine Drehung um die Y-Achse ist die horizontale Drehung
oder X-Rotation Wir können vor
jeder dieser
Berechnungen eine
if-Anweisung schreiben , um zu überprüfen , ob die entsprechende
Invertierungsvariable wahr oder falsch ist Multiplizieren Sie dann die
Formel mit minus Eins, falls sie falsch ist, um
das umgekehrte Verhalten
in „Nicht invertiert“ umzuschalten das umgekehrte Verhalten
in „Nicht invertiert Das bedeutet, dass fast
dieselbe Formel zweimal kopiert wird, mit dem einzigen kleinen Unterschied, ob sie mit einer negativen
Zahl multipliziert wird Wir können dies effizienter tun, indem wir eine
Neuformulierung verwenden. Zuerst zum
Originalformat zurückkehren dann mit
eins in Klammern multiplizieren, wenn die Dateieinstellungen invertiert werden, andernfalls mit minus Und wiederholen Sie dies mit
der horizontalen Drehung, indem Sie y in x ändern.
Drehanweisungen sind immer dann wirksam, wenn
Sie
einen Wert aufgrund einer
einfachen Mobbing-Bedingung ändern möchten einen Wert aufgrund einer
einfachen Mobbing-Bedingung L Lass es uns ausprobieren. Neigt man
den rechten Analogstick, wird
die X-Drehung der Kamera standardmäßig
nicht mehr invertiert, sondern die Y-Drehung ist den Remote-Szenenbaum öffnen, können
wir auf die Einstellungen zugreifen und sie
bearbeiten Und zurück zur Simulation:
Die Kamerasteuerung ist
jetzt entgegengesetzt. Wir haben jetzt
einige unserer Skripte erstellt , die von
verschiedenen Notiztypen
und auch von Ressourcen erben und auch von Ressourcen Wir können aber auch Skripte schreiben , die von unseren
eigenen benutzerdefinierten Klassen erben einem kurzen
Blick auf das FAD-Skript haben wir das Verhalten von zwei klaren und zwei schwarzen
zu einer kombinierten Funktion kombiniert Wir können ähnliche Verhaltensweisen
aus verschiedenen Skripten
auf ähnliche Weise kombinieren , indem wir eine Superklasse erstellen
und Vererbung verwenden um verschiedenen Skripten den Zugriff auf dasselbe Verhalten
zu ermöglichen Lassen Sie uns als Beispiel unsere
Manager-Skripte verwenden, da beide jetzt
den FAD-Übergang verwenden Es wäre eine gute Idee,
diese in einem separaten
Skriptordner abzulegen diese in einem separaten
Skriptordner Nennen wir es Manager. Sowohl den Game Manager den Title Manager
in diesen Ordner verschieben. Wir können auch
ein neues drittes Skript erstellen, nennen
wir es Scene Manager. Im Scene Manager-Skript geben
wir dem Skript einen
Klassennamen in der Groß-/Kleinschreibung. Jedes Mal, wenn Sie einem
Skript einen Klassennamen geben, müssen
Sie ihn speichern, bevor
die Engine ihn erkennt. Dann können
wir in den Game Manager
- und Title Manager-Skripten festlegen, dass diese
das Verhalten der
Scene Manager-Klasse erweitern . Jetzt wird
alles, was wir in das
Scene Manager-Skript eingeben sowohl vom Game
Manager als auch vom Titelmanager verwendet. Lassen Sie uns die FAD-Variable
in das Scene Manager-Skript verschieben in das Scene Manager-Skript In den Spiel
- und Titelmanagern ist es ihnen dann nicht erlaubt, eine
weitere Variable mit
demselben Namen zu deklarieren,
da
sie die Variable Fad
von
der Scene Manager-Klasse erben die Variable Fad
von
der Scene Manager-Klasse eine
weitere Variable mit
demselben Namen zu deklarieren,
da
sie die Variable Fad
von
der Wir können die Variable löschen, da sie jetzt von der Scene
Manager-Klasse geerbt Der Knotenpfad unterscheidet sich jedoch zwischen der Spielszene
und der Titelszene. Wir können das leicht umgehen, indem die Variable
exportieren,
anstatt sie auf ready zu verwenden. Wir müssen
den Wert für Fade
in beiden Szenen
im Inspektorfenster zuweisen . Wenn die Variable
nicht angezeigt wird, müssen
Sie
Godot möglicherweise schließen und erneut öffnen , damit die
Klassenvererbung funktioniert Funktionen werden ebenfalls vererbt, aber Unterklassen können
vererbte Funktionen
neu definieren vererbte Funktionen diesem Grund
hat jede Klasse, die
wir mit
einer Re- oder Process-Funktion geschrieben haben , ein blaues Symbol daneben, da sie
die geerbte Definition außer Kraft setzt , die bereits in
der Node-Klasse existiert Wenn unsere Scene Manager-Klasse über
eine Ready-Funktion verfügt ,
die angibt, dass das Fade ausgeblendet
werden soll, um es zu löschen, wird
dieses Verhalten
sowohl vom Game Manager
als auch vom Title Manager übernommen sowohl vom Game Manager
als auch vom Title Manager Wir können diese Funktion
aus dem Spielmanager entfernen, aber der Titelmanager öffnet
auch das Menü. dem
Titelmanager erlauben,
die von Scene Manager
übernommene Ready-Funktionsdefinition zu
überschreiben, müssen
wir nicht alles überschreiben. Unsere Unterklassen können mit
dem Schlüsselwort super auf die geerbte Definition
einer Funktion
zugreifen dem Schlüsselwort super auf die geerbte Definition einer Funktion Da der Titelmanager
von Scene Manager erbt, ist
Scene Manager die Oberklasse Indem wir Super Dot Ready aufrufen, sagen
wir dem
Fade, dass er von Fade zu Clear wechselt Aber dann sagen wir auch, dass das
Menü geöffnet werden soll. Die Struktur der
Oberklassen und Vererbung
wird nützlicher, wenn wir mehr Szenenmanager haben oder mehr gemeinsame Verhaltensweisen
aller unserer Szenenmanager Wir müssen nicht denselben Code in
mehreren Skripten
neu schreiben mehreren Wir haben jetzt einen automatisch geladenen
Node in unserem Scene Try, Informationen über
Spieleinstellungen und Spielfortschritte speichern
kann In der nächsten Lektion werden wir unserem Spiel
Hintergrundmusik
hinzufügen. Wir sehen uns in der nächsten Lektion.
6. MUSIK: Hallo Freunde. In
der vorherigen Lektion haben wir automatisch
geladene Knoten erstellt, mit denen Informationen
zwischen verschiedenen Szenen ausgetauscht
werden können . In dieser Lektion fügen wir Hintergrundmusik hinzu, die sich
mit jeder Szene unseres Spiels ändern kann . Für diese Lektion verwende ich Barns Musikpaket von Eric the Funny Barn
auf Itch Dot IO Unabhängig davon, welche Hintergrundmusik
Sie für Ihr Spiel verwenden, stellen Sie
sicher, dass sie
so konzipiert ist, dass sie wiederholt wird. Da Audiodateien
normalerweise sehr groß sind, empfehle
ich, sie nur dann in
Ihr Projekt zu
importieren ,
wenn Sie sie implementieren möchten. Sobald Sie sie importiert
und in einen Musikordner sortiert haben , wählen Sie einen aus und wechseln Sie vom
Betrugsfenster zum Importfenster. Möglicherweise müssen Sie
die Importeinstellungen für
Ihre Audiodateien bearbeiten , bevor
sie wiederholt werden können. Je nach Dateityp
kann es sich bei
der Loop-Einstellung um ein Kontrollkästchen oder ein Drop-down-Menü mit
mehreren Optionen handeln. In diesem Fall sollten Sie sie auf lineares Looping
ändern. Öffnen wir zunächst die Titelszene und
fügen ihr einen neuen Knoten hinzu Auf dem Audio-Stream-Player-Knoten. Achten Sie darauf, nicht die Varianten
zwei D oder drei D zu verwenden, da diese dazu dienen,
Hörgeräusche im Raum mit zwei
D oder drei D zu simulieren . Der normale
Audiostream-Player-Knoten wird nicht durch die Nähe oder
andere Elemente in der Szene
beeinträchtigt,
und der Ton wird einfach so wiedergegeben, wie er ist. Wir können die
Audiostream-Eigenschaft
im Inspektor auf einen
unserer importierten Songs setzen . Wenn Sie sich die Eigenschaften der
Notizen des
Audiostream-Players
im Inspektor ansehen , werden
Sie feststellen, dass die Lautstärke in Dezibel gemessen
wird, also
schwimmend , wobei der Standardwert Null zwischen
minus 80 und 24 liegt Es ist wichtig zu
beachten, dass diese Zahl nicht Eine Erhöhung von 1 Dezibel auf 2 Dezibel ist nicht Machen Sie sich jedoch keine Sorgen, wenn Sie
nicht verstehen, wie Dezibel funktionieren, da wir sie
nicht direkt verwenden werden Wir können den
Audio-Stream-Player-Knoten anweisen , automatisch abzuspielen, wenn
das Spiel Beim Ausführen des Spiels
beginnt die Musik mit voller Lautstärke, und wenn wir zur
Spielszene wechseln ,
hört sie plötzlich auf wir das, was wir
in den beiden vorherigen Lektionen gelernt haben, kombinieren können
wir einen
dauerhaften Audioplayer
für die Wiedergabe von Hintergrundmusik erstellen für die Wiedergabe von Hintergrundmusik und Musik auch
einblenden und nicht gleichmäßig abspielen. Da Spiele
häufig Hintergrundmusik in jeder Szene haben, wäre
es sinnvoll, einen automatisch geladenen Node
zu , der
permanent
im Szenenbaum verbleiben kann , um damit umzugehen. So können wir den
Audiotrem-Player-Knoten in unserem Szenenbaum löschen Audiotrem-Player-Knoten in unserem Szenenbaum Und erstelle ein neues Skript
im Auto-Lodes-Ordner. Nennen wir es Musik. Dieser automatisch geladene Knoten kann
vom Audio-Stream-Player erben, wodurch der Musikknoten Zugriff auf alle Eigenschaften
und Methoden
eines Audio-Stream-Player-Knotens Da wir
im Inspektor nicht auf
die Eigenschaften
eines automatisch geladenen Nodes zugreifen können , müssen
wir seine
Standard-Eigenschaftswerte
in der Ready-Funktion des Skripts festlegen in der Ready-Funktion des Skripts Ich möchte, dass die Lautstärke
bei dem niedrigstmöglichen Wert beginnt , der minus 80 Dezibel ist Wir können aber auch die lineare
Lautstärke verwenden, wenn wir wollen, was für die meisten
Menschen leichter zu verstehen ist verwenden eine eingebaute Funktion, linear to dB, kurz
für Dezibel,
die eine lineare
Skala in eine Dezibel-Skala umwandelt, sodass wir die Lautstärke linear auf Null setzen können,
was bedeutet, dass kein Ton
zu was bedeutet Wenn Sie möchten, dass die Musik auch während der Spielpause
abgespielt wird, müssen
wir den
Prozessmodus dieses Knotens ändern Anhand der Vorschläge können
wir ihn
auf Knoten, Punkt, Prozess immer setzen auf Knoten, Punkt, Prozess Danke. Okay. Wenn wir zuerst
darüber nachdenken, wie
dieser Knoten verwendet werden soll, benötigen
wir wahrscheinlich nur
zwei öffentliche Funktionen. Eine, um einen Musiktitel abzuspielen
und einen, um ihn auszublenden. Beim Abspielen eines Titels wird
ein Titel als Parameter vom
Typ Audiostream verwendet. Für das Ausblenden
sind jedoch keine Parameter erforderlich. In der Funktion Track abspielen können
wir auf alle Eigenschaften zugreifen, können
wir auf alle Eigenschaften zugreifen vom
Audio-Stream-Player-Knoten
übernommen wurden, einschließlich des Streams
, der gerade abgespielt
wird und der den
Standardwert Null hat. Wir können den Wert von
stream auf den Titel setzen , den
wir abspielen möchten. Sagen Sie dann dem
Audio-Stream-Player, dass er abspielen soll. Die Lautstärke ist
derzeit jedoch nicht hörbar. Lassen Sie uns ein Tween verwenden,
wie wir es beim visuellen Fade getan haben , um
die Lautstärke im Laufe der Zeit schrittweise
anzupassen, eine neue Tween-Variable
am Anfang des Skripts
deklarieren Wir prüfen zunächst, ob das
Tween bereits existiert, und wenn es existiert,
prüfen wir, ob es Und wenn ja, töte es. Wir können dann ein neues
Tween erstellen. Und Tween ist eine Immobilie Zugriff auf diesen Knoten selbst, die Volume-Eigenschaft, und schrittweise Änderung in
Dateipunkteinstellung Punktlautstärke über
die Dauer von 1 Sekunde Denken Sie jedoch daran, dass die Lautstärke
nicht linear skaliert, da sie
in Dezibel gemessen wird Anstatt die
Volumeneigenschaft direkt zu tweeten, können
wir stattdessen eine Methode tweeten Tween-Methode
benötigt keine Knotenreferenz, daher können wir
das erste Argument entfernen Der Eigenschaftspfad ist
jetzt eine aufrufbare Methode. Schreiben wir eine Funktion
namens set linear volume, die einen Float-Parameter
des linearen Volumens verwendet Diese Funktion legt
die Volumeneigenschaft fest nachdem sie von
linear in Dezibel umgewandelt wurde Aus Konsistenzgründen können wir dies in unserer
Ready-Funktion verwenden. Und verwenden Sie dies auch als unsere aufrufbare Methode im
Tween-Methodenaufruf Beachten Sie, dass, wenn Sie
eine Methode als Kabel verwenden, sie keine
Klammern am Ende Methode benötigt außerdem nicht
nur einen Endwert, sondern auch einen Startwert, da dies keine Eigenschaft
des Knotens mehr ist. Sie hat keine Möglichkeit zu wissen,
was der aktuelle Wert ist. Die Start- und Endwerte sind eigentlich ein
Argument, das an die
aufrufbare
Methode, das lineare Volumen, übergeben wird an die
aufrufbare
Methode, das lineare Volumen, übergeben Mit der entgegengesetzten
eingebauten Funktion können
wir Dezibel in lineare Werte umwandeln, um
das aktuelle Dezibelvolumen in
ein lineares Volumen als
Startwert umzuwandeln ein lineares Volumen als Wir können festlegen, dass
die lineare Lautstärke unserer Musik
von der aktuellen Lautstärke bis zur Einstellung der
Stopplautstärke über
1 Sekunde angepasst wird der
Stopplautstärke über
1 Sekunde angepasst Lassen Sie uns auch das fertige
Tween-Signal zurückgeben. Dann
will die Fade-Out-Funktion genau das
Gegenteil davon tun Die lineare Lautstärke wird
von einem beliebigen Wert auf Null getweetet. Warten,
bis das Tween beendet ist, Wiedergabe des Nodes wird
gestoppt und der
Track wird wieder auf Null gesetzt Wie bei der Farbe Fade können
wir diese Funktionen zu
einer privaten Funktion kombinieren Nennen wir es Lautstärke. Nehmen wir nur das lineare
Zielvolumen als Parameter. Die Lautstärke wird über einen
Zeitraum von 1 Sekunde von der aktuellen Lautstärke
auf die Ziellautstärke Und jetzt verwenden sowohl das Ein- Ausblenden dieselbe
Funktion Öffnen Sie die Projekteinstellungen und wechseln Sie zur Registerkarte Automatisches Laden Wir können das Musikskript
zur Liste der
automatisch geladenen Knoten hinzufügen . Im Scene Manager-Skript können
wir eine Variable exportieren, können
wir eine Variable exportieren, die den
Hintergrundmusiktitel für jede Szene
enthält, da jeder
Szenenmanager
die Variable erbt und ihr seinen eigenen Wert
zuweisen kann Unser Scene
Manager-Skript kann jetzt mithilfe seines Knotennamens einfach auf den
Knoten für das automatische Laden von Musik zugreifen
und den Musikknoten anweisen, und den Musikknoten anweisen den gewünschten
Titel für diese Szene
abzuspielen Lassen Sie uns jedem Titel
und jeder Spielszene einen
anderen Musiktitel zuweisen . Und achte auch darauf, dass
die Musik immer dann ausgeblendet wird, wenn
wir die Szene wechseln. Lass es uns ausprobieren. Die Musik der
Titelszene wird eingeblendet, durch Drücken der
Taste „Neues Spiel“ wird die Musik ausgeblendet und die Spielszene blendet
ihre eigene Musik Pause einlegen und auf
Beenden drücken, wird die Musik
ausgeblendet und die Titelmusik wieder eingeblendet Das funktioniert einwandfrei, solange wir nur
einen Musiktitel pro
Szene abspielen und stets darauf achten, ihn
auszublenden, bevor wir einen neuen Aber was wäre, wenn wir dem Musikknoten
sagen wollten, dass er
einen anderen Titel abspielen soll , während er
bereits läuft , oder
sogar denselben Es wäre eine gute Idee, der Play-Track-Funktion
einige zusätzliche Bedingungen hinzuzufügen . Beginnen wir mit der Überprüfung, ob der Musikknoten
bereits abgespielt wird. Überprüfen Sie dann auch, ob das,
was der Node
abspielt , mit dem übereinstimmt,
was wir abspielen möchten. Wenn das der Fall ist,
müssen
wir den Stream nicht ändern
oder ihm sagen, dass er abgespielt werden soll. Wir können einfach das fertige
Tween-Signal zurückgeben , das durch das
Abschalten der Lautstärke zurückgegeben wird Wenn bereits ein anderer Titel abgespielt
wird, sollten
wir diesen Titel ausblenden, bevor wir zu diesem wechseln Warten Sie, bis der Twin fertig ist, fahren Sie
dann mit den
restlichen Funktionen fort. Beachten Sie, dass diese
Funktion nun
zwei Ausführungen von Fad Volume innerhalb von
jeweils einer Sekunde durchführt zwei Ausführungen von Fad Volume innerhalb von
jeweils einer Sekunde Daher dauert es 2 Sekunden, bis der Titel
gewechselt ist. Machen wir das flexibler, indem wir die Dauer
wie beim FAD
exportieren und ihr einen
Standardwert von 1 Sekunde geben Erlauben Sie dann, dass die Funktionen „Track abspielen“ und „
Ausblenden“
einen optionalen
Dauerparameter mit
einem Standardwert für die
exportierte Variable akzeptieren einen optionalen
Dauerparameter mit einem Standardwert für die
exportierte Variable Übergabe des Duration-Parameters an die Fade-Lautstärkefunktion. Wir können es im
Tween-Methodenaufruf als Argument verwenden. Wenn man sich die Spiel
- und Titelmanager-Skripte anschaut, O bei gedrücktem Spiel und beim Beenden
der Funktionen jetzt ziemlich ähnlich Lassen Sie uns eine
vererbte Methode zum
Ändern von Szenen in unser
Scene Manager-Skript schreiben . Benannte Wechselszenen. Wir können sagen, dass die
Musik ausgeblendet wird. Warte, bis der Fade
zu Schwarz wird, unterbreche das Spiel,
falls es unterbrochen wurde, ändere
dann die Szene
mit dem Baum Übergeben Sie den
Dateipfad als Argument. Um die erwarteten
Ergebnisse zu erzielen, müssen
wir sicherstellen,
dass das
erwartete Signal das Signal mit
der längeren Dauer ist. Die Awart-Anweisung muss auch
die letzte sein , wenn wir wollen, dass alle Tweens parallel
ablaufen Wenn Sie aus irgendeinem Grund die Reihenfolge
dieser Anweisungen neu organisieren
müssen , sodass das
erwartete Signal nicht das zurückgegebene ist, können
Sie es auch in
einer Variablen speichern und in einer anderen Zeile
darauf warten Jetzt
kann der Titelmanager all das tun, indem seine geerbte Methode „Szene
ändern“
aufruft Pfad der Spielszenen als Argument
übergibt Ebenso kann der Spielmanager dies
auch beim Ändern
der Titelszene vornehmen. Vergessen Sie auch nicht, dass
Unterklassen
diese Verhaltensweisen immer überschreiben können , wenn Sie möchten sich
eine bestimmte Szene anders
verhält Wir haben jetzt
Hintergrundmusik, die mit
jeder Szene in unserem Spiel sanft ein- und
ausgeblendet In der nächsten Lektion fügen wir
ein Einstellungsmenü hinzu, mit dem Sie die Spieleinstellungen
ändern Wir sehen uns in der nächsten Lektion.
7. Einstellungen: Hallo Freunde. In
der vorherigen Lektion haben wir Hintergrundmusik hinzugefügt,
die sanft ein- und ausgeblendet In dieser Lektion fügen wir unserem Spiel ein
Einstellungsmenü hinzu. Fangen wir mit der Titelszene an. Im Gegensatz zu den Schaltflächen und
Menüs,
die wir bisher erstellt haben und die einfach vor allem schweben
, würde
ich es vorziehen, wenn die Spieleinstellungen in einem Panel zusammengefasst wären. Es gibt zwei verschiedene
Steuernotizen, die wir zu unserer Szene
hinzufügen können und die
sich unterschiedlich verhalten. Ein Bedienfeld ist nur ein einfaches
Fenster, dessen
Größe wir nach Belieben ändern und dessen untergeordnete Elemente auf beliebige
Weise neu anordnen können Größe wir nach Belieben ändern und dessen untergeordnete Elemente auf beliebige
Weise neu anordnen Ein Panel-Container passt sich
automatisch an seine
Größe an, um seine
untergeordneten Objekte einzukapseln,
ähnlich wie bei einem horizontalen oder vertikalen Beide haben Vor- und Nachteile
. Ich verwende gerne einen Panel-Container , um mir
Zeit und Mühe zu sparen, die Größe und Neuorganisation
untergeordneter Knoten ich
beim Aufbau
meiner Benutzeroberfläche für die
Größe und Neuorganisation
untergeordneter Knoten aufwenden Aber ich könnte
zu einem Panel wechseln, wenn ich
mehr Flexibilität bei der Feinbearbeitung
des
fertigen Projekts haben möchte mehr Flexibilität bei der Feinbearbeitung des
fertigen Projekts haben Da unsere Einstellungsklasse einige boolesche Variablen
hat. Wir können
für jede Variable entweder ein Kontrollkästchen
oder ein Häkchen hinzufügen , sodass der Spieler
seinen Wert entsprechend auf wahr
oder falsch setzen seinen Wert entsprechend auf wahr
oder falsch Fügen wir eine für die Kamerainvertierung x und eine weitere für die Kamerainvertierung hinzu. Ich füge jeweils einen hinzu,
damit ich sehen kann, wie sie
aussehen , und später entscheiden kann,
welcher mir besser gefällt der Lautstärkeeinstellung
handelt es sich um eine Float-Variable, die
in Menüs häufig über einen Schieberegler gesteuert wird. Da ein Schieberegler von Natur aus einen Mindest
- und Höchstwert
erzwingt Für jede dieser Einstellungen ist
außerdem
ein Label-Node erforderlich , der dem
Spieler mitteilt, wofür sie gedacht sind Ähnlich wie wir horizontale
und vertikale Box-Container verwendet haben und vertikale Box-Container , um Knoten automatisch zu organisieren. Wir können auch einen
Grid-Container verwenden, um die
Knoten
automatisch in einem Rastermuster zu organisieren. Die einzige Eigenschaft der Rasterknoten ist die Anzahl der
Spalten im Raster. Zeilen werden automatisch dem Rastercontainer
hinzugefügt und daraus
entfernt , um
der Anzahl seiner untergeordneten Objekte Rechnung zu tragen. diesen Wert auf zwei setzen,
können wir ganz einfach alle Labelknoten in
der linken Spalte
und die interagierbaren
Kontrollknoten auf der rechten Seite organisieren Labelknoten in
der linken Spalte und die interagierbaren
Kontrollknoten auf der rechten Seite Der Grid-Container komprimiert alle seine untergeordneten Objekte
so weit wie möglich Wir können jedoch für jeden von ihnen
Mindestgrößen angeben. Ich gebe dem Lautstärkeregler einen x-Wert von mindestens 100 Pixeln, wodurch die rechte Spalte
des Rastercontainers erweitert wird. Jetzt denke ich, dass die
Kontrollkästchen
in der Mitte der Spalte besser
aussehen würden . Wenn ich den Layoutbereich
und den Unterabschnitt zur Containergröße erweitere, stelle ich den horizontalen
Wert so ein, dass die Mitte verkleinert Jetzt ist das Kontrollkästchen
horizontal innerhalb der Spalte zentriert horizontal innerhalb der Spalte Und ich mache dasselbe
für den Check-Button. Nun, da wir unseren Slider sehen können, schauen wir uns seine
Eigenschaften im Inspektor an. Wir können die Minimal
- und Maximalwerte
sowie den Schrittwert festlegen , der den Abstand zwischen
Werten
darstellt, Abstand zwischen
Werten
darstellt auf den der
Schieberegler eingestellt werden kann. Bei Verwendung unserer linearen
Lautstärkeeinstellungen sollte
der Mindestwert Null sein. Ein Maximalwert von
eins ist
in Ordnung, da eins linear gesehen 0 Dezibel
entspricht Wir können aber auch zulassen, dass die
Lautstärke diesen Wert überschreitet. Da wir wissen, dass der
maximale Dezibelwert
des Audio-Stream-Player-Knotens 24 Dezibel beträgt Wir können tatsächlich eingebaute
Funktionen in dieses Feld eingeben, indem wir db auf linear setzen und 24
übergeben, erhalten wir 15,849, was der tatsächliche Maximalwert ist Dies kann jedoch zu einer
Verringerung der Audioqualität führen. In den meisten Fällen ist es in Ordnung
, die maximale
lineare Lautstärke auf eins einzustellen . Etwas so Flüssiges wie das Volumen kann normalerweise in sehr
geringem Maße eingestellt werden. Da mein Schieberegler 100 Pixel hat, setze
ich seinen Schrittwert auf 0,01, wobei jedes Pixel
einer Volumenänderung von 1% entspricht. Wir benötigen außerdem eine
Titelbezeichnung für dieses Menü. Und eine Schaltfläche, die es schließt. Aber diese gehören nicht
als Teil des Netzes. Wir können den
Titelrastercontainer und die Schaltfläche zum
Schließen in einem
vertikalen Box-Container sortieren . Das Titellabel und die
geschlossene Schaltfläche sind gestreckt, dass sie dieselbe
Breite wie der Rastercontainer haben. Ich werde den Titel mithilfe
seiner Ausrichtungseigenschaft zentrieren. Die Schaltfläche kann so eingestellt werden, dass sie
anfängt zu verkleinern , sodass sie sich in der
unteren linken Ecke befindet Verkleinern Sie die Mitte, um sie zu zentrieren, oder verkleinern Sie das Ende, um sie
in der unteren rechten Ecke zu platzieren Wenn Sie diese Container nicht
verwenden möchten oder sie zu einschränkend finden, können
Sie jederzeit ein
normales Bedienfeld verwenden und wir
positionieren jeden der untergeordneten Knoten manuell , um die Anordnung
zu erhalten Wir können die Theme-Ressource
für unser
Einstellungsmenü wiederverwenden , wenn wir möchten, aber vielleicht möchtest du
für
verschiedene Teile
deines Spiels unterschiedliche Button-Stile verwenden für
verschiedene Teile
deines Spiels unterschiedliche In diesem Fall kannst du ganz einfach eine neue Theme-Ressource
erstellen. Ich füge einfach eine
Panel-Container-Einstellung zu den vorhandenen hinzu. Ändern Sie
das Stilfeld in eine Textur. Und gib ihm einige
Inhaltsränder von 16 Pixeln. Die Kontrollkästchen übernehmen
ihren Stil von der Schaltfläche, sodass wir dies überschreiben können,
indem wir
dem Thema ein Kontrollkästchen hinzufügen und
alle zugehörigen Stilfelder ersetzen Ich verwende einfach leere Style-Boxen. Dann wiederhole den Vorgang
für den Check-Button. Okay. Ich denke, der Titel sollte eine größere
Schriftgröße haben als die anderen Labels. Ich überschreibe die Schriftgröße im Abschnitt zum Überschreiben des Themes. Jetzt habe ich sowohl
das Kontrollkästchen als auch das
Häkchen gesehen und kann sie
im Kontext des Menüs vergleichen. Ich glaube, ich bevorzuge
die Checkbox und ich werde die Kamera entsprechend
invertieren Nachdem das Menü fertig ist,
verankern wir es in der
Mitte des Bildschirms Wir haben bereits
ein Menüskript geschrieben , das sich um das
Ein- und Ausblenden eines Kontrollknotens kümmert und
auch beim Öffnen
eines Menüs den Fokus darauf legen kann . Lassen Sie uns das an
den Knoten im Einstellungsmenü anhängen. Und setzen Sie das
Standard-Fokuselement auf das erste Menüelement, das Kontrollkästchen „Kamera invertieren X“ Um die
Steuersignale mit unserem Skript zu verbinden, muss
es sich jedoch Steuersignale mit unserem Skript zu verbinden, um
ein anderes Skript handeln als das, das
von anderen Menüs verwendet wird Wir können dem
Manuskript einen Klassennamen geben dann ein neues Skript im UI-Skriptordner erstellen ,
das vom Menü
übernommen Nennen wir es Einstellungsmenü. dieses Skript auf
den Einstellungsmenüknoten ziehen, ersetzt
es das Manuskript Aber wir müssen das Standard-Fokuselement erneut
auffüllen. In unserem neuen Skript
müssen wir jeden
unserer Kontrollknoten so initialisieren, dass er den Werten
entspricht, die sich bereits in
der Einstellungsressource befinden Wir müssen also
Verweise auf jeden
unserer Kontrollknoten abrufen , indem wir At on ready
verwenden Dann können
wir in der Ready-Funktion die Werte auf die passende Variable in
der Dateieinstellungsressource setzen. Dabei sind unsere Einstellungssteuerelemente im Menü
sortiert
und initialisiert Wir können jetzt Signale von
jedem Steuerknoten mit dem
Einstellungsmanuskript verbinden jedem Steuerknoten mit dem
Einstellungsmanuskript Rufen Sie eine Funktion immer
dann auf, wenn eine Einstellung vom Player
geändert wurde. Die Checkbox- und
Check-Button-Knoten verbinden
das umschaltbare Signal und teilen uns mit, ob es auf „Wahr“ oder „Falsch“
gesetzt ist Und der Schieberegler verbindet
das Signal mit dem geänderten Wert
und gibt uns den neuen Wert, auf den
es gerade eingestellt wurde Wir können die Werte
der Variablen in
unseren Dateipunkteinstellungen so einstellen , dass sie allen Werten entsprechen ,
die mithilfe der Kontrollknoten
geändert wurden . Denn die
Kamerasteuerung liest direkt aus den Einstellungen, um zu
bestimmen, wie sie funktioniert. sind keine weiteren Maßnahmen erforderlich, damit diese
Einstellungen funktionieren. Die Lautstärkeeinstellung
wirkt sich jedoch nicht automatisch auf den
Musikknoten aus. Wir müssen die
Lautstärkeeinstellung manuell anpassen. Wenn sich die Lautstärkeeinstellung ändert, können
wir lineare Lautstärke
aufrufen neuen Wert
als Argument übergeben. Lassen Sie uns diese Szene nachspielen
und versuchen,
die Lautstärkeeinstellung anzupassen , um
den unmittelbaren Unterschied
bei der Musikwiedergabe zu hören . Ein abgeschlossenes Spiel wird wahrscheinlich mehr Audioknoten
haben, denen jeder seine eigene
Lautstärkeeinstellung hat. Möglicherweise möchten wir sie nicht alle
einzeln über
das Einstellungsmenü
anpassen . Um diesen Bedarf zu antizipieren, können
wir hier ein
Signal aussenden,
das der gesamten Szene mitteilt , dass die Lautstärkeeinstellung geändert
wurde Dann kann jeder Knoten, der darauf
wartet, dass dieses Signal
gesendet wird, darauf reagieren Am Anfang des Skripts können
wir Signale auf die
gleiche Weise deklarieren, wie wir Variablen deklarieren, indem wir das Schlüsselwort signal verwenden. Lassen Sie uns das Volumen geändert nennen. Es ist üblich,
Signale in der Vergangenheitsform zu benennen anzugeben
, worauf andere Skripte reagieren
sollten. Ähnlich wie bei einer Funktion können
wir am Ende
der
Signaldeklaration Klammern hinzufügen am Ende
der
Signaldeklaration , um ihr Parameter hinzuzufügen. Wir können nicht nur ausgeben, dass
die Lautstärke geändert wurde, sondern auch den neuen
Volumenwert als Float ausgeben. Wenn dieses
Signal mit einer Funktion verbunden wird, sollte
die Empfangsfunktion
einen Float-Parameter akzeptieren , der dem Signal
entspricht. Als Nächstes verbinden wir das Signal
zum Drücken der
geschlossenen Tasten mit der
Methode „Geschlossen“ der Menüklasse, um das Menü zu schließen. Bei den meisten Spielen können
die Einstellungen sowohl für
Titel als auch für Spielszenen geändert werden. Speichern wir den
Zweig des Einstellungsmenüs als eigene Szene. Kopieren Sie dann den
Einstellungsmenüknoten und fügen Sie ihn in
die Spielszenen I ein. Es ist immer eine gute
Idee, sicherzustellen, dass der Fade-Node vor allem anderen steht, also sortiere ich das
Einstellungsmenü
darüber und setze seine sichtbare
Eigenschaft de false. Wir können dem Pausenmenü ganz einfach eine
Einstellungsschaltfläche hinzufügen. Da beide Szenen
das Einstellungsmenü haben , können
wir,
ähnlich wie beim Fade, eine Variable aus
dem Scene Manager-Skript exportieren, sodass sowohl der Titelmanager
als auch der Gain-Manager sie verwenden können. Und in beiden Szenen
wird
das Einstellungsmenü von einem anderen Menü aus aufgerufen. Entweder das
Hauptmenü der Titelszenen oder das Pausenmenü der
Spielszenen. Wir können
innerhalb unseres Manuskripts eine sehr einfache
Breadcrumbs-Implementierung erstellen , sodass jedes Mal, wenn ein Menü von einem anderen Menü aus
geöffnet wird, es
geschlossen wird, automatisch
zum vorherigen Menü zurückkehrt zum vorherigen Menü In unserem Manuskript können wir eine weitere Variable
deklarieren. Nennen wir es Underscore
Breadcrumb vom Typ Menu. Fügen Sie dann der geöffneten Funktion einen optionalen
Parameter hinzu, der auch Wenn Breadcrumb beim Öffnen des
Menüs etwas anderes als Null ist, sollten wir
es in der Variablen speichern
und dieses Menü schließen, bevor wir dieses öffnen Wenn das Menü dann geschlossen ist der Breadcrumb nicht Null ist, sollte
das Menü
nach dem Schließen dieses Menüs geöffnet werden, dann kann es auf Null zurückgesetzt werden Sowohl das Titelmanager- das Game Manager-Skript können
jetzt das Einstellungsmenü öffnen,
wobei die Menüschaltflächen oder das
Pausemenü als Breadcrumb übergeben Pausemenü als Breadcrumb Die Szene mit dem Einstellungsmenü öffnen. Stellen wir sicher, dass das
Standard-Fokuselement
gesetzt ist und dass diese Knoten immer verarbeitet
werden, auch
wenn das Spiel unterbrochen ist Lass uns versuchen, das Spiel auszuführen. Die Spieleinstellungen ändern und zur Spielszene wechseln. Sowohl die Lautstärke- als auch die
Kamerasteuerung bleiben geändert, und wir können sie über das Pausenmenü
erneut ändern. Wir haben jetzt ein
Einstellungsmenü, mit dem Sie die Lautstärke und
die
Kamerasteuerung in Echtzeit ändern können . In der nächsten Lektion werden wir Übergangsereignisse
hinzufügen, um unseren Charakter
zwischen verschiedenen Leveln zu bewegen. Wir sehen uns in der nächsten Lektion.
8. Ausgang: Hallo Freunde. In
der vorherigen Lektion haben wir ein Einstellungsmenü hinzugefügt. In dieser Lektion werden wir erkennen,
wenn der Spieler
eine Tür betritt , und uns darauf vorbereiten , zu einem
anderen Level zu wechseln Fangen wir mit
dem Level an, das
gerade
in die Spielszene geladen ist gerade
in die Spielszene geladen Für mich ist das ein Raum drei. Es gibt zwei Türen, die aus diesem Raum
herausführen. Wenn der Spieler eine
dieser Türen betritt, sollte
er zu einem
anderen Level meines Spiels wechseln In ähnlicher Weise, wie
unser Charakterkörper mit dem statischen Körper auf dem
Boden kollidiert, können
wir Kollisionen mit
leerem Raum erkennen , wodurch
etwas passiert Der Knoten, der das tut, wird
als Area-Three-D-Knoten bezeichnet. Und genau wie ein Physikkörper benötigt
er eine
Kollisionsform, bevor er funktionieren kann. Fügen wir eine Kollisionsform drei D-Knoten hinzu und
machen wir daraus eine Kastenform. Damit es der
Größe meiner Bodenfliesen entspricht, mache
ich es in
Länge, Breite und Höhe auf 4 Meter. Benennen wir den Bereich drei in
D-Knoten in Transition um. Machen Sie es dann zu einer eigenen Szene,
indem Sie darauf klicken und
es in den Szenenordner auf der
Registerkarte Dateisystem ziehen es in den Szenenordner auf der
Registerkarte Dateisystem Öffnen Sie dann die neue
Übergangsszene zur Bearbeitung. Ich möchte, dass der
Ursprung der Übergänge deutlich
auf dem Boden liegt. Wir bewegen die
Kollisionsform entlang der Y-Achse nach oben, sodass sie die Hälfte ihrer Höhe von 4
Metern erreicht, was 2 Metern entspricht. Um auf
Kollisionen mit dem Spieler reagieren zu können, benötigt
der Übergangsknoten
ein Skript Lassen Sie uns ein neues
Skript erstellen, indem wir auf das Scrollsymbol klicken. Okay. Stellen Sie sicher, dass es
im Scripts-Ordner gespeichert ist. Der Standardname und die
Vererbung sind in Ordnung. Der
D-Knoten im dritten Bereich verfügt über eine Reihe
verschiedener Signale, um auf Kollisionen zu
reagieren Da unser
Charakterkörper als
physischer Körper gilt und wir
darauf reagieren wollen, dass der Charakter diesen Bereich betritt, ist das Signal, das wir wollen, dass
der Körper betreten wird Wenn dieses Signal mit
dem Übergangsknoten
selbst verbunden wird, entsteht die Funktion on
body entered, die den
Körper,
der
diesen Bereich betreten hat, als Parameter vom Typ Knoten drei
D akzeptiert der
diesen Bereich betreten hat, als Parameter vom Typ Knoten drei .
Die Typen der Parameter können wir
in der Liste der Signale sehen Die Typen der Parameter können wir
in der Liste der Signale Lassen Sie uns zunächst nur den Körper ausdrucken,
um zu sehen, wie unsere Kollision funktioniert. Wenn wir die Spielszene starten und den Übergangsbereich
betreten, der
Name des Körpers der Figur,
drei D-Noten gedruckt, aber auch die Namen der statischen
Körperknoten in unserer Szene. Wir wollen nicht, dass
irgendein Physikkörper diesen Bereich
betritt, eine Reaktion
auslöst, sondern nur der Spielercharakter. Wir können überprüfen, ob der Körper
einer bestimmten Klasse angehört. Oder überprüfe den Namen des Knotens, um zu
sehen, ob es sich um den
Spielercharakter handelt. Diese Lösungen
sind jedoch nicht sehr flexibel. Eine einfachere und sauberere
Methode besteht darin,
mithilfe der Kollisionsmaskierung sicherzustellen, dass nur der
Spielercharakter tatsächlich mit diesem Bereich
kollidieren kann nur der
Spielercharakter tatsächlich mit diesem Bereich
kollidieren Öffnen wir zunächst die
Charakterszene und
wählen den D-Knoten des dritten
Charakters Sie unter den Eigenschaften von
Kollisionsobjekt Three D
übernommen wurden, Erweitern Sie unter den Eigenschaften, die von
Kollisionsobjekt Three D
übernommen wurden, den Kollisionsbereich. gibt es zwei Gruppen von Zahlen Hier gibt es zwei Gruppen von Zahlen, die bis 32 reichen. Das sind Kollisionsebenen, denen wir
kontrollieren können, welche Objekte in unserem Spiel
miteinander kollidieren können und welche nicht? Bisher
existiert alles in unserem Spiel in der Standardebene eins und maskiert oder kollidiert nur
mit Ebene Da Ebene eins die Standardeinstellung ist
und standardmäßig alles
damit kollidiert Lass uns Ebene eins das Terrain des Spiels
sein. Aufgrund der Art und Weise, wie diese Ebenen in Achterblöcken
angezeigt werden, ich mir jeden Block gerne als Ebenen vor, die zusammen
gruppiert sind. Die ersten acht Ebenen
meines Spiels könnten für die Welt
- oder Umgebungsebenen
reserviert sein . Unser Charakter kann auf
einer anderen einzigartigen Ebene existieren. Lassen Sie uns Ebene
neun als Beispiel verwenden. Auf diese Weise kann der gesamte
zweite Ebenenblock für
Kollisionsebenen reserviert
werden, die sich auf den Spieler beziehen. die Projekteinstellungen
auf der Registerkarte Allgemein
unter Ebenennamen öffnen ,
können wir die Namen jeder
dieser 32 Ebenen ändern jeder
dieser 32 Ebenen , die für Three D-Physik existieren. Ich nenne Layer One Terrain
und Layer 9 Player. im Inspektor mit der Maus über
die Ebenen fahren, wird deren Name
angezeigt in der Übergangsszene nichts in der Lage sein muss
, Da in der Übergangsszene nichts in der Lage sein muss
, unseren Bereich zu erkennen oder mit
ihm zu kollidieren, muss er eigentlich auf keiner Ebene existieren gerne
eine Kollisionsebene für Übergänge reservieren , wenn Ihnen das hilft Der Übergang benötigt
nur eine Kollisionsmaske, um
Kollisionen mit dem Spieler zu erkennen Ebene eins ausschalten und
nur Ebene neun, den Spieler, maskieren Wir können
dies weiter erzwingen, indem wir
die Eigenschaften des D-Knotens
im Bereich drei ändern und ihm
sagen, dass er nach
anderen physikalischen Körpern Ausschau halten soll, aber nicht
von anderen physikalischen Körpern überwacht werden kann Der einzige Weg, dieser Bereich
drei D
eine Kollision auslösen kann, besteht darin,
dass er
einen physikalischen Körper auf Schicht neun erkennt einen physikalischen Körper auf Schicht Es wird nicht nach
anderen Ebenen suchen und für alles andere unsichtbar
sein. Der Übergangsbereich
kann so positioniert werden, er den leeren Raum
hinter der Tür
abdeckt, sodass es für
den Spielercharakter unmöglich ist ,
diesen Raum zu verlassen, ohne mit ihm zu
kollidieren Ich öffne all meine
verschiedenen Levelszenen. Ich kann mir vorstellen, dass dieser Übergang eine Verbindung zu Raum eins herstellen soll. Nennen wir es also zwei, Raum eins. Durch das Duplizieren des Knotens
wird das Duplikat
automatisch in zwei Zimmer zwei
umbenannt, und ich kann
es an der anderen Tür neu positionieren T Meine kleinen Level haben zwar jeweils nur zwei Sie können sich vorstellen es auf
einer großen komplexen Ebene dass es auf
einer großen komplexen Ebene
noch viele weitere gibt, die
schwer zu verfolgen sind. Wir sollten diese Knoten
also gruppieren , um sie
innerhalb des Szenenbaums zu sortieren. Fügen wir einen neuen Knoten hinzu, nur einen normalen Knoten, und nennen wir ihn Transitions. Dann werden ihm die
Übergangsknoten übergeordnet. Dadurch können sie nicht nur in unserem
Szenenbaum im Editor,
sondern später auch in unseren Skripten
leichter gefunden und verwendet werden. Wir können
diese Knoten kopieren und in
unsere Levelszenen einfügen und sie so neu positionieren , dass
sie alle Türen abdecken Wir benennen sie um, damit wir
wissen, wohin sie führen. das Fortschrittsskript öffnen, können
wir die Variablen ändern
oder neue hinzufügen, um den Namen des Levels,
in dem sich
der Spieler gerade befindet, als Zeichenfolge zu
speichern in dem sich
der Spieler gerade befindet, als Zeichenfolge Ich werde es so initialisieren
, dass es Raum eins ist. Damit diese Methode
funktioniert, muss
der Wert dieser
Variablen der exakten Schreibweise des Szenennamens der Ebene auf
der Registerkarte Dateisystem entsprechen Im Übergangsskript. Wir können diese Variable dann festlegen der Spieler
zwischen den Levels wechselt. Lassen Sie uns eine Variable exportieren
, die den Namen
der Ebene, zu der dieser Übergang
führt, als Zeichenfolge enthält. Wenn dann der
Hauptteil des Charakters diesen Bereich betritt, können
wir den Wert für den
Punktstatus der Datei festlegen. Soll der
Name der Ebene sein. Als Nächstes möchten wir dem Game Manager mitteilen, dass er
zu diesem Level wechseln soll. Wie im
Spielerskript können
wir jederzeit auf den Stammknoten der
Szenen zugreifen, indem wir
unseren Knotenpfad mit dem
Dollarzeichen Schrägstrich beginnen unseren Knotenpfad mit dem
Dollarzeichen Schrägstrich dann den Game
Manager mit dem Spiel Sagen wir einfach dem
Game Manager, dass er
eine Funktion namens Load Level aufrufen soll , die wir
noch nicht geschrieben Da der Name des Levels bereits in der
Fortschrittsressource gespeichert ist, muss
er nicht als Argument übergeben werden. Da
wir nur in dieser einzigen Instanz versuchen, auf
den Game Manager zuzugreifen , ist
es nicht nötig, ihn in
einer Variablen zu speichern oder Add On Ready zu verwenden Zumal logischerweise nur ein Übergangsereignis pro ins
Spiel
geladenem Level passieren kann pro ins
Spiel
geladenem Level passieren Jeder Übergang,
der die Variable deklariert und auf
den Spielmanager zugreift, obwohl nur einer sie
tatsächlich benötigt,
wäre also den Spielmanager zugreift, obwohl nur einer verschwenderischer im Game Manager-Skript Lassen Sie uns im Game Manager-Skript zunächst einen Verweis auf das Level finden, das in der
Szene bereits existiert Wir können auf den Knoten klicken und
ihn in
das Skript ziehen , um seinen Knotenpfad automatisch zu
erstellen, oder wir können sogar die Strg
- oder Befehlstaste gedrückt halten, während wir die Maustaste
loslassen, um ihn
automatisch in einer Variablen zu speichern. Ich benenne die Variable
in die aktuelle Ebene um. Deklarieren Sie dann die
Load-Level-Funktion wir über das
Übergangsskript aufgerufen haben. Zunächst müssen wir wissen, ob bereits ein Level geladen ist indem wir prüfen, ob diese Variable einen Wert
enthält
oder ob sie Null ist. Wenn sie einen Wert enthält, sollten wir zuerst
warten, bis f schwarz wird. können wir dann das
aktuelle Level aus
unserer Spielszene entladen Mit der
eingebauten Funktion Q können wir dann das
aktuelle Level aus
unserer Spielszene entladen. In der Lektion werden
wir die nächste
Szene überladen Lasst uns vorerst einfach warten, bis
Fate es gelöscht hat, und es ausprobieren. Wenn der Spieler die Tür
betritt, wird die Szene schwarz Das aktuelle Level wird
aus dem Szenenbaum entfernt
und dann kehren wir zurück
, um unseren Charakter
und den freien Fall zu sehen , da es kein Level mehr
gibt Unser Debug-Bedienfeld
gibt uns zwei Warnungen. Wir haben eine Variable deklariert, die nie im Skript verwendet
wurde, und es gibt einen unbenutzten Parameter in unserer Kollisionsfunktion Wir können ungenutzten
Parametern
einen Unterstrich voranstellen , um sie
für die Engine zu kennzeichnen , sodass
sie ignoriert werden können Wenn wir zum
Übergangsskript wechseln, wird
der Body-Parameter nicht mehr verwendet Wir können dem Namen der Variablen
das Präfix hinzufügen , um dieser Warnung zu
entsprechen. Im Scene Manager-Skript. Wir haben die Variable settings
manu in diesem Skript deklariert , aber sie wird in diesem Skript
nicht verwendet Wir haben das mit Absicht gemacht , weil die Variable
settings
many von allen
Erben dieser Klasse vererbt und verwendet wird Wir haben nicht die Absicht
, das Scene
Manager-Skript jemals direkt zu
verwenden, sondern verwenden es, um
all die ähnlichen Eigenschaften und
Verhaltensweisen einer Gruppe
verwandter Skripte zu enthalten all die ähnlichen Eigenschaften und Verhaltensweisen einer Gruppe
verwandter Skripte In anderen Sprachen wäre
dies als abstrakte Klasse
bekannt. Dieses Muster der Verwendung von
Vererbung auf diese Weise wird in der objektorientierten
Programmierung als Abstraktion
bezeichnet Wir können uns dafür entscheiden, jede Warnung zu
ignorieren indem wir mit
at warning ignore eine weitere Zeile vor der Zeile hinzufügen,
die die Warnung auslöst der Zeile hinzufügen,
die die Warnung Geben Sie dann die Warnung an, die
wir ignorieren möchten. In diesem Fall haben wir
eine unbenutzte private Variable deklariert . Nachdem beide
Debug-Warnungen behoben wurden, werden
beim Ausführen des Spiels keine Warnungen
mehr Das aktuelle
Level wird jetzt entladen wenn der Spieler eine Tür
betritt In der nächsten Lektion
laden wir das nächste Level und positionieren den Spieler
in der entsprechenden Tür auf der Wir sehen uns in der nächsten Lektion.
9. Betreten: Hallo, Freunde. In
der vorherigen Lektion hatte der Spieler
das Level durch eine Tür verlassen In dieser Lektion laden wir das nächste Level und positionieren
den Spieler darin Bevor wir das nächste Level laden, haben
wir zunächst
überprüft, ob es
ein aktuelles Level gibt , und wenn
ja, werden wir es entladen Wir können dann der Variablen
der aktuellen Ebene
einen neuen Wert zuweisen ,
da sie jetzt leer ist Mithilfe einer integrierten Funktion load können
wir jede Ressource
von unserem Dateisystem-Tab laden, einschließlich Szenen, indem wir
einen Dateipfad als Zeichenfolge angeben. Um unsere Szenen
besser zu organisieren, erstellen
wir innerhalb
des Szenenordners einen Unterordner mit dem Namen levels. Lege dann jedes
Level des Spiels in diesen Ordner. eine
der Level-Szenen auswählen, können
wir klicken und sie in die Klammern der Ladefunktionen ziehen, um sie mit
dem Dateipfad zu füllen Da sich alle Levels unserer Spiele im
Level-Ordner
befinden und alle mit
dem Punkt TSCN enden, können
wir diese
Teile der Zeichenfolge
mit dem
Operator Append, dem Pluszeichen, trennen mit dem
Operator Append, dem Pluszeichen, Ersetzen Sie dann den Namen
der Level-Szene durch die die in
der Fortschrittsressource gespeichert sind Die Ladefunktion
gibt eine Ressource zurück. Aber die aktuelle
Level-Variable ist ein Knoten drei d. Wir müssen
zuerst eine Funktion für
die Ressource aufrufen, um
sie in einen Knoten umzuwandeln , Punkt instantiate Fügen Sie sie dann
mit der Funktion add child zum Szenenbaum hinzu Da es sich um das
Game Manager-Skript handelt das an den Stammknoten der
Spielszenen
angehängt ist, wird
der Levelknoten
als untergeordnetes Element des Spielknotens hinzugefügt. Aber was ist, wenn
das Spiel zum ersten Mal startet? Oder wenn der Spieler eine sichere Datei
lädt? Wir können unsere Spielszene
ohne einen Levelknoten starten. den Level-Knoten
aus der Spielszene löschen, können
wir das Add-On
Ready aus der aktuellen
Level-Variablen entfernen . Lassen Sie uns die vom
Scene Manager übernommene
Ready-Funktion überschreiben und sofort
Load Level aufrufen. Bevor Sie die
Superklassendefinition von Scene Manager aus ausführen Superklassendefinition von Scene Manager aus diese Weise können wir
jedes Level in unserem Spiel laden, indem wir
einfach
seinen Dateinamen in
der Fortschrittsressource festlegen und Load Level aufrufen Es wird sauber
zwischen den Levels wechseln, indem zuerst zu Schwarz übergeht und die aktuelle Szene
entlädt, dann das nächste
Level lädt und wieder einblendet Wenn ein Level zum
ersten Mal geladen
wird und es kein aktuelles Level gibt,
wird dieser Schritt übersprungen und das Level wird
sofort Aber wir müssen
den Spieler innerhalb
des neuen Levels positionieren und sicherstellen, dass die Position mit dem Pfad
verknüpft ist , von dem aus er das Level
betreten hat. Fangen wir mit der
Übergangsszene an,
indem wir einen neuen Knoten hinzufügen, der nichts anderes
tut,
als einfach eine
Position im Drei-D-Raum zu markieren, einen Marker-Drei-D-Knoten. Der einzige Unterschied zwischen
einem Knoten mit drei D und
einem Knoten mit drei D besteht darin
, dass der Marker einen Gizmo
zeichnet und der Editor
zeigt, wo er sich befindet Benennen wir diesen Knoteneingang und bewegen ihn
entlang der Z-Achse vorwärts, sodass er sich außerhalb des
Gebietsknotens befindet und weit genug entfernt ist, dass der Spielercharakter nicht mit dem Gebiet kollidiert Im Übergangsskript können
wir ihn hineinziehen und die Strg
- oder
Befehlstaste gedrückt halten , um ihn als
Variable hinzuzufügen, ohne bereit Das ist die Position,
an der der Spieler in das Level
spawnen wird in das Level
spawnen wenn er
diesen Übergang durchläuft In unseren Levelszenen können wir jeden unserer
Übergänge so
drehen, dass
die Z-Achse und die
Eingangsmarkierung
auf eine entsprechende Stelle
innerhalb des Levels zeigen die Z-Achse und die
Eingangsmarkierung auf eine entsprechende Stelle
innerhalb des Levels Wenn
Sie aus irgendeinem Grund
eine einzelne Eingangsmarkierung verschieben müssen, eine einzelne Eingangsmarkierung ohne dass sich dies auf
andere Übergänge auswirkt, können
Sie jederzeit mit der rechten Maustaste auf
einen Übergangsknoten klicken und die bearbeitbaren untergeordneten Elemente aktivieren Auf diese Weise können Sie eine
bestimmte Eingangsmarkierung verschieben, um
beispielsweise Hindernissen oder
Schwankungen der
Bodenhöhe Rechnung zu tragen Schwankungen der
Bodenhöhe Bevor wir herausfinden können,
wie der Spieler positioniert werden soll, benötigen
wir die
Levelszenen, um ihre Übergänge
anhand des Skripts
verfolgen zu können. Fügen wir dem
Stammknoten der Ebene ein neues Skript mit dem Namen level
im Ordner scripts hinzu. Wenn wir den
Übergangsknoten mit der Maus hineinziehen, können
wir ihn in einer
Variablen speichern, in der das Add-On bereit ist. Aber wir wollen diesen Knoten nicht. Wir wollen all seine Kinder. Mithilfe einer eingebauten
Funktion get children speichern
wir eine Liste
aller untergeordneten Knoten zu diesem Übergangsknoten
in einer Reihe von Knoten. Die Reihenfolge der Knoten
im Array entspricht der Reihenfolge
im Szenenbaum. Wir können auf den
Inhalt eines Arrays zugreifen, indem eine Indexnummer
angeben, die bei Null
beginnt. Schreiben wir eine Funktion
in unser Level-Skript , die den Übergängen die
Indexnummer gibt und die
Koordinaten zurückgibt , an denen der
Spielercharakter platziert werden soll. Nennen wir es Get Entrance und akzeptieren den Übergangsindex
als Integer-Parameter. Und wir geben den Vektor drei zurück, die Position in drei D-Räumen der das Zeichen platziert werden soll. Wir können auf das
Transition-Array zugreifen und die Indexnummer
in eckige Klammern
setzen. Wenn die Indexnummer Null ist, erhalten
wir den obersten Knoten, gefolgt von eins, zwei usw. Als Nächstes ermitteln wir die
Eingangsmarkierung aus dem Übergang und die globale Positionseigenschaft des Drei-D-Knotens der
Eingangsmarkierung Da die Position der Notiz relativ zu ihrem übergeordneten Element
ist. Wir möchten die
globale Position wissen, so wie sie in der gesamten
Szene
existiert, damit wir sie zurückgeben können. Wir müssen
das Level-Skript
an die Grundnote
jedes Levels in unserem Spiel anhängen . Es besteht jedoch auch
die Möglichkeit, dass
sich der Charakter beim Laden des Levels vor der
Neupositionierung des Charakters zufällig bereits in
einem Übergangsbereich befindet In der Übergangsszene sollten
wir die
Überwachungseigenschaft standardmäßig deaktivieren dann im Level-Skript Wenn dann im Level-Skript ein Level geladen ist und der Charakter richtig
positioniert ist, können
wir eine Funktion aufrufen, um alle Übergänge zu
aktivieren. Ein sehr nützliches Merkmal von
Arrays ist unsere
Fähigkeit , mit Hilfe einer Schleife durch jedes
ihrer Elemente zu iterieren Beginnend mit dem Schlüsselwort vier können
wir einen Alias angeben, wir innerhalb der Schleife verwenden,
um auf das aktuelle Element zu verweisen Gefolgt vom Schlüsselwort in, dann dem Namen des
Arrays und einem Doppelpunkt. Alles, was wir
in den Loop-Block einfügen wird auf jedem
Element des Arrays ausgeführt, und wir können mit dem Alias auf das aktuelle
Element verweisen. Für jeden Übergang
in Übergängen können
wir seine
Monitoring-Eigenschaft auf
true setzen , um alle
Übergänge in dieser Ebene zu aktivieren. Im Game Manager-Skript können
wir einen Verweis
auf den Spielercharakter abrufen. Wenn dann ein Level geladen ist, können
wir den Spieler
am Leveleingang positionieren. Lassen Sie uns vorerst Null als
Argument verwenden. der Charakter nun positioniert
wurde, können
wir alle
Übergänge im Level aktivieren, da wir wissen, dass der Charakter keinen von ihnen berührt. Schließlich müssen wir die Werte für
jeden Übergang in jeder
Ebene im Inspektor
festlegen , damit jeder Übergang weiß, mit
welcher Ebene er verbunden ist. Beim Ausführen der Spielszene beginnt das
Spiel nun in Raum eins und der Spieler befindet sich
vor der Tür Das oberste untergeordnete Element des
Transitions-Knotens. Beim Betreten einer beliebigen Tür wird
das Level entladen und die Spielszenen befinden
sich im Aber egal, durch welche
Tür wir gehen, der Spieler befindet sich immer
vor derselben Fügen wir der Fortschrittsressource eine weitere Variable mit dem Namen
Transition ID vom Typ int Fügen Sie dann auch diese Variable
dem exportierten Übergangsskript hinzu. Wenn der Spielercharakter diesen Übergang
betritt, können
wir den Wert in
der Fortschrittsressource so einstellen , dass er der exportierten Variablen
entspricht. im Game Manager-Skript als
Argument, Verwenden Sie dies im Game Manager-Skript als
Argument, um
den Übergang auszuwählen , an dem der
Spieler platziert werden soll. wir uns ab Raum eins Schauen wir uns ab Raum eins den
Übergang zu Raum zwei an
, der jetzt eine
Transition-ID-Variable
mit dem Wert Null hat . Dies ist der Index
des Übergangsknotens, der
von Raum zwei zur Szene
zurückkehrt. Wir können sehen, dass
der Übergang zu Raum eins der oberste untergeordnete Knoten ist
, der Index Null ist. Das ist also richtig. Schauen wir uns den Übergang von
Raum zwei zu Raum drei an. Lassen Sie uns zur Szene
mit Raum drei wechseln, und wir können sehen, dass
der Übergang von Raum drei zu Raum
zwei Index eins ist. Wir müssen also
die Transition-ID
des Übergangs von Raum
zwei zu Raum drei auf eins ändern . Und die Übergänge, die Raum
drei verlassen , müssen ebenfalls auf einen geändert werden. Wenn wir die Spielszene ausführen, können wir jetzt zwischen
all unseren Levels hin- und herlaufen, sowohl im Uhrzeigersinn als auch gegen den
Uhrzeigersinn, und der Spieler ist jedes Mal
richtig positioniert Wenn Ihre Level
viele Übergänge haben, empfehle
ich Ihnen, für
Ihr Spiel
eine Konvention festzulegen , wie Sie Ihre Übergänge
organisieren, z. B. im Uhrzeigersinn von
Norden aus Möglicherweise möchten Sie auch
die Indexnummer in eine Zeichenfolge ändern und Ihre Übergänge in
einem Wörterbuch statt
in einem Array
organisieren einem Wörterbuch statt
in einem Array Ich
möchte auch sicherstellen, dass sowohl der Charakter
als auch die Kamera von dem Übergang
weggerichtet sind , von dem aus der Spieler ein Level
betritt. Im Level-Skript geben wir,
genau wie wir die globale
Eingangsposition einer Funktion
zurückgegeben haben , auch die
Rotation
der Übergänge aus einer anderen Funktion zurück. Jetzt kann das Game
Manager-Skript auf
diese Funktion zugreifen , um zu bestimmen , in welche Richtung sie zeigen
sollen. Wir können diese Information
an das Spielerskript weitergeben und damit
sowohl den Charakter als auch die Feder, die die Kamera
hält, drehen , eine Fiktion
nennen
und eine Fiktion
nennen die zurückgegebene
Drehung als Argument übergeben. Übergeben Sie die Richtung und akzeptieren Sie, dass
die Y-Drehung schwimmend ist. Die Drehung der
Federarme kann einfach entsprechend eingestellt werden. Der Federarm
muss jedoch um
180 Grad gedreht werden , damit er
sich hinter der Figur befindet. Da die Drehung im
Bogenmaß gemessen wird, bedeutet
das, dass wir entweder Pi
zu diesem Wert
addieren oder subtrahieren können , um
die Kamera in die
richtige Richtung zu richten die Kamera in die
richtige Wir können
diesen Rotationswert dann
entlang der Kette an
die Zeichenklasse weitergeben entlang der Kette an
die Zeichenklasse Und fügen Sie eine weitere
Funktion hinzu, um
das Charakter-Rig so zu drehen , dass
es sofort in die gewünschte Richtung zeigt. Lass es uns ausprobieren. Selbst wenn wir den
Charakter und die Kamera vor dem
Betreten der Tür in
seltsamen Winkeln positionieren , werden
sie beide von der Tür
auf der anderen Seite
abgewandt sein von der Tür
auf der anderen Seite
abgewandt Das hilft dem Spieler verstehen, aus welcher
Richtung sie gekommen sind Wir haben den Spieler jetzt in der Lage, zwischen den Levels
und unserer Spielszene zu wechseln. In der nächsten Lektion werden wir Fortschritt des
Spielers
speichern und laden. Wir sehen uns in der nächsten Lektion.
10. Speichern: Hallo Freunde. In
der vorherigen Lektion haben wir unseren
Levelübergang abgeschlossen. In dieser Lektion speichern und
laden wir den
Spielfortschritt der Spieler. Unser Dateiskript enthält mehrere
Variablen mit benutzerdefinierten Ressourcen, die wir
verwendet haben, um
die Spieleinstellungen und
den Fortschritt der Spieler zu verfolgen . Fangen wir mit der
Einstellungsressource an. In der Ready-Funktion
erstellen wir eine neue
Einstellungsressource, aber das sollten wir nur
tun, wenn noch keine
existiert
, die wir stattdessen laden können. Die I-Bedingung prüft zunächst ob die CETI-Ressource existiert, und wenn ja, wird sie geladen, andernfalls wird eine neue erstellt
und sofort gespeichert Diese Zeile wird eigentlich der Else-Block
einer IF-Anweisung Godo ermöglicht es uns,
jede Ressource mithilfe von
Singleton-Klassen zu speichern und zu laden jede Ressource mithilfe von
Singleton-Klassen Der Resource Loader
kann unsere Ressource laden, indem er die Lademethode aufruft und ein
Zeichenkettenargument und einen Dateipfad
übergibt Anstatt auf eine
Ressource innerhalb unseres Projekts zuzugreifen, möchten wir
diesmal
etwas aus dem System des
Benutzers laden . Der Dateipfad beginnt
mit einem Doppelstrich für den Benutzer. Die Godo-Engine verwendet
die Verknüpfung, um auf jedem System
einen geeigneten
Ort zum Speichern und Laden von Dateien
zu finden auf jedem System
einen geeigneten
Ort , die für jeden
Benutzer einzigartig Lassen Sie uns die
Dateieinstellungen benennen und ihr die
Erweiterung RS für Ressource geben Erweiterung RS für Ressource Diese Ladefunktion
gibt eine Ressource zurück, die wir
unserer Einstellungsvariablen zuweisen können. Bevor wir die Einstellungen laden, können
wir eine
ähnliche Funktion ausführen, um
zunächst zu überprüfen, ob die Datei existiert. Da der Dateipfad
jetzt zweimal geschrieben wird, werden
wir ihn auch häufiger
verwenden, und dieser Wert
sollte sich niemals ändern. Ich wäre effizienter, ihn als Konstante zu
deklarieren. Wenn die
Einstellungsdatei nicht existiert, können wir sie erstellen. Und speichern Sie es sofort mit
der Resource Saver-Klasse und rufen Sie die Save-Methode Die Speichermethode erfordert
eine Ressource zum Speichern, bei der es
sich um unsere Einstellungsressource handelt, und den Dateipfad, in dem sie gespeichert werden soll, was der Einstellungspfad ist Wenn jetzt das Spiel ausgeführt die Einstellungen für den Benutzer
vorhanden sind, werden sie geladen, und wenn nicht, werden sie erstellt. Wir müssen aber auch einige
Änderungen am Einstellungsmenü vornehmen. Alle unsere Einstellungen müssen auf die Werte
gesetzt werden , die geladen wurden die sich in
der Bereitschaftsfunktion befinden. Wir haben die anfängliche
Schiebereglerposition
der Lautstärkeeinstellung anhand der in
der Einstellungsressource gespeicherten Zahlen festgelegt. Wir
müssen aber auch die Lautstärke
des Musikknotens einstellen und das Signal
hier wie unten als
Reaktion auf die Änderung des
Schiebereglerwerts ausgeben hier wie unten . Wenn der Player
das Einstellungsmenü öffnet und einige Einstellungen
anpasst, ist es eine gute Idee,
diese Einstellungen zu speichern , wenn
das Menü geschlossen ist Wir können die Methode zum Schließen unserer
Menüklassen außer Kraft setzen Wenn das
Einstellungsmenü geschlossen wird, weisen wir die Datei beim automatischen
Laden an, die Einstellungen zu speichern Zurück in der Datei zum automatischen Laden können
wir die Funktion hinzufügen
, die die Einstellungen speichert. Die Fortschrittsressource
wird dagegen nicht in
der Ready-Funktion behandelt. Wir können jede
dieser Methoden in öffentliche Funktionen um auf verschiedene Arten auf die
Fortschrittsressource zuzugreifen. Überprüfe, ob sie existiert, starte ein neues
Spiel und lade sie. dasselbe Format
wie unsere Einstellungen verwenden, können
wir eine
Speicherpfadkonstante deklarieren. Die Funktion safe file exists gibt einen booleschen Wert zurück und gibt denselben
Wert
zurück, der
vom Resource Loader do exists zurückgegeben wurde Der
Speicherpfad wird als Argument übergeben. Eine neue Fortschrittsressource wird erstellt
, wenn ein neues Spiel aufgerufen wird. Speichern der Ressource
, wenn das gespeicherte Spiel
aufgerufen wird , und Laden der Ressource , wenn das Laden des Spiels aufgerufen wird. In der Titelszene
können wir jetzt ganz einfach
eine neue Fortschrittsressource erstellen ,
wenn auf Neues Spiel geklickt wird. Und die vorhandene sichere
Datei laden, wenn auf Weiter geklickt wird. Es wäre ein gutes UI-Design,
die
Schaltfläche „Weiter“ zu deaktivieren und sie nur zu aktivieren, wenn eine sichere Datei zum Laden vorhanden
ist. Lassen Sie uns
mithilfe von Add On Ready einen Verweis auf
die Schaltfläche „Weiter“ abrufen . Wenn in der Ready-Funktion eine sichere Datei existiert, können
wir die Schaltfläche „
Weiter“ aktivieren indem wir ihre Eigenschaft
disabled auf
false setzen und ihr dann auch sagen, dass
sie den Fokus übernehmen soll. Auf diese Weise ist die Standardoption „
Neues Spiel“,
wenn das Spiel zum ersten Mal gespielt wird, und danach wird jedes Mal
fortgesetzt. Wir müssen lediglich entscheiden,
wann das Spiel gespeichert werden soll. Da es sich bei diesem Dateiskript um einen Knoten zum automatischen Laden
handelt, kannst
du die
Speicherfunktion dazu ganz einfach über
das Pausenmenü oder das
Speicherpunktobjekt in deinem Spiel aufrufen . Ich lasse mein Spiel einfach
jedes Mal
automatisch speichern , wenn der Game
Manager ein Level entlädt Zurück im
Title-Manager-Skript vervollständigen wir auch
die Exit-Funktion So wie wir das Spiel einblenden, wenn
das Spiel beginnt, können
wir warten, bis es
schwarz wird, bevor wir es beenden Das Beenden des Spiels ist eine eingebaute Funktion des Szenenbaums, die wir
mit Get Tree zugreifen
und einfach die Q-Funktion aufrufen können und einfach die Q-Funktion aufrufen In unseren benutzerdefinierten Ressourcenskripten müssen
wir vor
allen Variablendeklarationen, die in die Safe-Datei geschrieben werden
sollen
, einen
Export hinzufügen allen Variablendeklarationen Safe-Datei geschrieben werden
sollen
, Alle Variablen, die wir nicht
speichern möchten, können
das Export-Tag einfach weglassen Wenn Sie beispielsweise
die für JRPGs
übliche Safe-Point-Methode verwenden , wäre die in
der sicheren Datei gespeicherte Variable eine ID-Nummer, die
dem sicheren Punkt zugeordnet ist, sodass diese exportiert Die Variablen, die
das aktuelle Level und die
Transition-ID enthalten, müssten jedoch nicht in der sicheren Datei gespeichert werden, da sie nicht zum Laden des Spiels
benötigt werden,
aber dennoch für den Übergang zwischen den Levels benötigt werden In diesem Fall müssten sie also nicht exportiert
werden. In meinem Spiel muss ich diese Variablen
exportieren, da ich mein Spiel bei
jedem Levelwechsel automatisch speichere. Ein letzter Hinweis im Skript zum automatischen Laden der
Datei. Mit der DOT-RES-Erweiterung schreiben
wir eine sichere
Datei als Binärdatei, was
dem Benutzer den Zugriff erschwert. ein T hinzufügen und die Erweiterung
TRes zur Textressource machen, schreiben
wir die sichere Datei
als allgemeine Textdatei, die
in jeder Textbearbeitungssoftware angezeigt und bearbeitet werden kann . Beides sind akzeptable Formate. Ich speichere die Einstellungen als
Text und den Fortschritt
als Binärdatei. Lass es uns ausprobieren. Beim Ausführen des Spiels ist die Schaltfläche
Weiter deaktiviert, aber wir können ein neues Spiel starten. In der Spielszene stoße ich auf ein
anderes Level, das mein Spiel speichern sollte. Wenn ich das Spiel pausiere, ändere ich
einige Spieleinstellungen. dann das Spiel und kehre zur Titelszene zurück Jetzt ist die
Schaltfläche Weiter aktiv, da die sichere Datei zum Laden
vorhanden ist. Aber lassen Sie uns zuerst das Spiel beenden, das schwarz
wird und das Spielfenster schließt Jetzt führe ich das Spiel erneut aus. Diesmal ist die
Schaltfläche „Weiter“ aktiviert, da unsere sichere Datei
zwischen den Spielsitzungen bestehen blieb setzen unser bestehendes Spiel fort Wir setzen unser bestehendes Spiel fort und beginnen im anderen Level, und die Spieleinstellungen sind auch
dieselben, wie wir sie verlassen haben Antwort: Lassen Sie uns nun
einen Blick auf die Dateien werfen, die auf meiner Festplatte
erstellt wurden. Die Einstellungsdatei
kann im Notepad geöffnet werden. Wir können die exportierten
Variablen und ihre Werte
deutlich sehen und
sie sogar bearbeiten und die Datei speichern Als Nächstes öffnen wir die Speicherdatei mit den Fortschritten der Spieler. Die meisten dieser Informationen sind. Selbst wenn wir
etwas bearbeiten und die Datei speichern würden, würde der
Versuch, die
SAF-Datei zu laden,
das Spiel zum Absturz bringen , da sie
nicht mehr korrekt formatiert ist Lassen Sie uns das Spiel noch
einmal ausführen und überprüfen, ob
unsere Einstellungsdatei, die wir manuell als Notizblock
bearbeitet haben, geladen
ist und die
Werte Das Speichern von Ressourcen im
Binärformat ist also
sicherer und Textressourcen lassen
sich sehr einfach bearbeiten Meiner Meinung nach ist es für
ND-Entwickler oft
vorteilhafter, Fehler beim Bearbeiten von
Speicherdateien mit
Ihren Spielern
beheben zu können Bearbeiten von
Speicherdateien mit
Ihren Spielern
beheben , als
Fortschrittsdaten auszublenden , um Cheaten zu verhindern Wir haben jetzt die Fortschritte der
Spieler, zwischen den Spielsitzungen
gespeichert und geladen In der nächsten Lektion werden wir mit
der Anzeige der Credits des Spiels abschließen . Wir sehen uns in der nächsten Lektion.
11. Teilgenommen haben:: Hallo, Freunde. In
der vorherigen Lektion haben wir die Fortschritte
der Spieler gespeichert und geladen. In dieser Lektion werden wir die Credits des Spiels
anzeigen. Beginnen wir damit, eine
neue Szene zu erstellen, die Kredit-Szene. Da dies normalerweise nur ein
schwarzer Hintergrund
mit weißem Text ist , denke
ich, dass ein
Benutzeroberflächenknoten als Stammknoten am sinnvollsten ist. Geben wir der Grundnote ein Skript und nennen
es Credits Manager. wird von Scene Manager Es wird von Scene Manager übernommen
und in den Scripts-Ordner des
Managers sortiert Wir können die F-Notiz aus
jeder anderen Szene kopieren und in die Abspannszene einfügen Dann weisen Sie sie im Inspektor und fügen einen
Musiktitel für die Abspannszene hinzu. Im Title-Manager-Skript können
wir nun das Verhalten
der Schaltfläche „Abspann“
im Hauptmenü so einstellen der Schaltfläche „Abspann“
im , dass
sie zur Abspannszene wechselt. Wir sollten die
Abspannszene auch im Szenenordner speichern . dann im Credits
Manager-Skript wir dann im Credits
Manager-Skript eine Funktion hinzu
, die zur Titelszene
zurückkehrt . In der Eingabefunktion. Wir können überprüfen, ob der Spieler eine bestimmte Taste
gedrückt hat. Ich verwende einfach die Sprungtaste und wenn ja, kehre ich
zur Titelszene zurück. Unsere Szenen sind jetzt miteinander verbunden und können
hin und her wechseln. den meisten Spielen, die sich noch in der
Entwicklung befinden , können
die Credits über das
Hauptmenü
aufgerufen werden, da das Ende des Spiels
noch nicht abgeschlossen ist. Es wird also
keine Möglichkeit geben, auf
die Kredit-Szene zuzugreifen , wenn man das Spiel
abschließt. Wenn du deine
Kredit-Szene
in die gesamte Entwicklung
deines Spiels einbeziehst , kannst du auch Überblick über alle
behalten, die gesamten
Lebenszyklus dazu beigetragen haben. Apropos, Credits
sind normalerweise nur eine Reihe von Textbeschriftungen, die
vertikal angeordnet sind und langsam nach oben scrollen Szene also einen vertikalen
Box-Container hinzufügen, nennen
wir ihn Scroll Und lassen Sie ihn am
unteren Bildschirmrand verankern. Aber mit der breiten Einstellung. Jetzt befinden sich die linken Anker
beide unten links dem Bildschirm und die
rechten Anker befinden sich beide unten
rechts auf dem Dies ist in der Regel der Ort, von dem die
Credits stammen. Leistungspunkte werden häufig
in Kategorien oder Berufsbezeichnungen unterteilt , gefolgt von einer Liste mit Namen
von Mitwirkenden
in dieser Kategorie. In unserem vertikalen
Feld mit allen Credits können
wir also weitere vertikale Felder hinzufügen
, um jede Kategorie aufzunehmen. Ich nenne das Spieldesign. Innerhalb der Kategorie sollte
es eine Bezeichnung für den Titel
der Kategorie geben. Und ich lasse Spieldesign
draufstehen. Die Credits sind normalerweise auf die Mitte
ausgerichtet. Ich mache die Schrift weiß. Größe 64 und verwende die schickere meiner beiden
Schriftarten für Kategorientitel Lassen Sie uns dieses Label
nein duplizieren , um ein weiteres
Label für unseren Namen hinzuzufügen Reduzieren Sie dann die Schriftgröße und ändern Sie die Schrift in eine, bei mehr Wert auf Lesbarkeit Wir sind jetzt
in unserer Spiele-Kredit-Szene als
Spieledesigner aufgeführt in unserer Spiele-Kredit-Szene als
Spieledesigner Aber die Credits beginnen
im Spielfenster. Sie sollten
am unteren Bildschirmrand beginnen. Kehren wir zum vertikalen Scrollfeld zurück
und ändern wir
die Anker-Voreinstellungen auf Benutzerdefiniert Dadurch bleiben die
Anker dort, wo sie sind, aber wir können
jede Einstellung einzeln ändern Wir möchten, dass die Wachstumsrichtung
dieses Steuerelements nach unten und
nicht nach oben geht , wodurch die
Einstellung von oben nach unten geändert Lassen Sie uns
die
Kategorie Spieldesign zusammenklappen und duplizieren , um
unsere nächste Kategorie, die
Spieleentwicklung, zu erstellen . Da alle
Einstellungen doppelt vorhanden sind, müssen
wir nur die Namen der Knoten und
die
Texteigenschaften der Labelknoten
ändern Knoten und
die
Texteigenschaften der Labelknoten und bei Bedarf jeder
Kategorie
zusätzliche Namen hinzufügen Bedarf jeder
Kategorie Und wiederhole diesen Vorgang, um weiterhin so
viele Kategorien hinzuzufügen, wie du für dein
Spiel benötigst, um sicherzustellen, dass alle Beteiligten gutgeschrieben werden Ich werde auch dem
Künstler,
der
die Charaktermodelle,
Animationen und
Umgebungsmodelle entworfen hat, K Laberg, Anerkennung zollen Penzila, die die Elemente der
Benutzeroberfläche erstellt hat, und Eric the Funny Baron, der die gesamte Musik produziert hat Und zum Schluss noch eine
Dankesnachricht an den Spieler. Ich werde die
Dankesnachricht auch vergrößern. Unsere Credits sind alle hier, aber sie sind alle eng
zusammengedrängt und schwer zu lesen Fügen wir dem vertikalen Box-Container eine
gewisse Trennung hinzu
, um die Kategorien voneinander zu trennen Ich werde jede Kategorie um 256 Pixel voneinander unterscheiden
, um ihnen viel Platz zu geben. Und wir können sehen, dass
der
Credit-Scroll sehr schnell sehr lang wird. Das Letzte, was ich
tun möchte, ist sicherzustellen, dass die Dankesnachricht
am Ende von selbst angezeigt wird. Also gebe ich ihm einen
benutzerdefinierten
Y-Wert für die Mindestgröße , der der
Fenstergrößeneinstellung meines Spiels entspricht,
720 Pixel, und zentriere den Text mithilfe der Eigenschaft für die vertikale
Ausrichtung
der Beschriftungen
vertikal innerhalb
dieses Bereichs . Zurück im Credits
Manager-Skript exportieren
wir eine Variable für die Scrollgeschwindigkeit und geben ihr einen
Standardwert von
etwa 32 Pixeln pro Sekunde Und schnappen Sie sich mit dem Add-On Ready einen Verweis auf die
Schriftrolle. Sie dann in der Prozessfunktion, die Delta
als Float-Parameter verwendet der die
Sekunden
angibt, die seit dem letzten Frame
vergangen sind, Ändern Sie dann in der Prozessfunktion,
die Delta
als Float-Parameter verwendet, der die
Sekunden
angibt, die seit dem letzten Frame
vergangen sind, die Y-Position
des Scrolls subtrahieren Sie dabei Geschwindigkeit mal Denn wenn Sie
in zwei Dimensionen arbeiten, befindet sich
Null oben
auf dem Bildschirm,
und wenn Sie etwas nach oben bewegen, bewegen Sie
sich in die
negative Richtung Wir müssen dann das Scrollen
beenden sobald die Dankesnachricht den Bildschirm
erreicht Wenn wir in unserer zweidimensionalen Ansicht den
Bildlauf
auswählen und Wert für
die Transformationsposition im Inspektor anzeigen, können
wir den Bildlauf nach oben bewegen bis er die
gewünschte Position erreicht, an der nur die
Dankesnachricht angezeigt wird Wenn wir uns die Transformation im
Inspektor ansehen, können
wir sehen, dass die
Y-Position des
Bildlaufs jetzt dem
Y-Teil der Größe entspricht, aber eine negative Zahl ist und der Höhe der Bildschirmgröße 720 zuzüglich
der Höhe Zurück im Skript können
wir überprüfen, ob die Y-Position der Schriftrolle diesen Wert überschritten
hat. C prüft, ob sie kleiner ist
als das Negativ der Größe Punkt Y plus der
Fensterhöhe von 720 Pixeln Wir können mit
dieser Berechnung noch
genauer sein , indem wir auf
die
Display-Server-Singleton-Klasse zugreifen die
Display-Server-Singleton-Klasse und sie nach der
aktuellen Fenstergröße fragen und dann auf den Y-Wert zugreifen Wenn dies zutrifft, ist das Ende des
Scrollvorgangs erreicht und die Dankesnachricht befindet sich
in der Mitte des Bildschirms An diesem Punkt möchten wir, dass das Scrollen aufhört zu scrollen Lassen Sie uns eine boolesche
Variable namens erstellen, die standardmäßig Wir können sie dann auf true setzen,
wenn die Schriftrolle
diese Bedingung erfüllt hat , und auch die Y-Position so
einstellen, dass sie
genau diesem Wert
entspricht , sodass sie perfekt
zentriert ist , falls sie die Markierung
überschreitet. Da wir
diese Berechnung zweimal durchführen, ändern
wir sie
in eine Variable und berechnen sie mit add on ready Am Anfang
der Prozessfunktion können
wir dann überprüfen, ob das
Scrollen am Ende ist, und wenn ja, zurückkehren, um das
Scrollverhalten zu verhindern Das funktioniert, aber anstatt einfach abzubrechen wenn der Spieler die Sprungtaste
drückt, hätte
ich lieber
die Scrollgeschwindigkeit und kehre erst am
Ende des Scrollens zum
Titelbildschirm zurück am
Ende des Scrollens zum
Titelbildschirm Wenn der Spieler in der Eingabefunktion die Sprungtaste drückt,
dann überprüfe auch, ob
das Ende des Scrollens erreicht
ist, bevor du zur
Titelszene wechselst zwei neue Variablen exportieren, nennen
wir sie langsame
Geschwindigkeit und schnelle Geschwindigkeit, beide als Floats mit
Standardwerten von 32 und 512 Pixeln pro Sekunde Die tatsächliche Scrollgeschwindigkeit muss nicht
mehr exportiert werden.
Stattdessen setzen wir sie
mit dem Add-On Ready auf die langsame Geschwindigkeit Wir können dann die
Scrollgeschwindigkeit auf die hohe Geschwindigkeit setzen wenn der Spieler
die Sprungtaste drückt bevor der
Scrollvorgang abgeschlossen ist Und stellen Sie es auf langsame Geschwindigkeit ein, wenn
sie die Taste loslassen. A Lass es uns ausprobieren. Wenn Sie auf die Schaltfläche Credits klicken, wird zur Kredit-Szene gewechselt. Die Credits beginnen langsam
vom unteren Bildschirmrand nach oben zu scrollen langsam
vom unteren Bildschirmrand Aber wir können es beschleunigen, indem wir die Sprungtaste gedrückt
halten. Sobald die
Dankesnachricht erreicht wurde, wartet
das Spiel auf ein erneutes Drücken
der Sprungtaste, um zur Titelszene
zurückzukehren. Und das war's mit den
Grundlagen der Spieleentwicklung. Sie haben jetzt ein voll
funktionsfähiges Skeleton-Projekt , mit dem Sie ein Spiel eines beliebigen Genres
entwickeln können.
12. Was kommt als Nächstes?: Willkommen zu meinem Kurs über Dialog - und Veranstaltungssysteme in Gado Dieser Kurs ist eine Fortsetzung der Grundlagen der Spieleentwicklung
in Gado, kann aber auf jedes Projekt angewendet werden , bei dem es um einen Charakter
geht, den der Spieler steuern kann, mit NPCs oder Objekten
zu interagieren indem er eine Taste drückt und
einen Dialog anzeigt Du kannst gerne
unserem Discord-Server beitreten um
gemeinsam mit deinen Kollegen an diesem Kurs zu arbeiten In diesem Kurs werden
wir uns mit der Erstellung von Dialogfeldern, Ereignissen
und Interaktionen befassen Verbinde sie dann
mit Fortschrittsmarkierungen, Kamerasteuerungen und
Charakteranimationen. Wenn Sie fertig sind, verfügen Sie über ein umfangreiches Dialog
- und Event-System für Ihr Spiel, mit dem Sie
hochwertige Zwischensequenzen und
komplexe, verzweigte
Erzählungen erstellen
können hochwertige Zwischensequenzen und , die
auf die Entscheidungen der Spieler reagieren und es ihnen ermöglichen, im Spiel voranzukommen Außerdem erlernst du nützliche Fähigkeiten um mit der
Gada-Game-Engine zu arbeiten und
deine Projekte so zu
organisieren und zu gestalten, organisieren und zu gestalten dass Sie werden lernen,
wie man mit dem GD-Skript programmiert, wobei alles ausführlich
erklärt wird Wir werden
objektorientierte Entwurfsprinzipien
in unseren Skripten,
Vererbung, Kapselung
und Abstraktion sowie andere Entwurfsmuster der
Softwareentwicklung
wie Singleton und
Composite Pattern anwenden objektorientierte Entwurfsprinzipien
in unseren Skripten, Vererbung, Kapselung
und Abstraktion sowie andere Entwurfsmuster der
Softwareentwicklung , um sie
für Projekte jeder Größe zu organisieren,
anpassbar und wiederverwendbar zu halten für Projekte jeder Größe zu organisieren,
anpassbar und wiederverwendbar Alle Projektdateien sind
auch auf Github verfügbar, falls Sie
das Projekt nach Abschluss jeder Lektion
überprüfen nach Diese Videos wurden
mit Gadot Version 4.2 0.2 aufgenommen. Das Projekt beginnt
mit Inhalten aus den Remaster-Paketen
K Kits Character und
Dungeon von K L Auberg und dem
Guy-Basispaket Alle können
kostenlos auf Dot IO heruntergeladen werden.