Transkripte
1. Einführung: Willkommen zu meinem
Einführungskurs über Three D Game
Development und Gada In diesem Kurs
behandeln wir alles, was du über
die Verwendung der Gudo-Engine zur
Entwicklung eines
Charakter-Controllers für Dritte wissen
musst Entwicklung eines
Charakter-Controllers für Dritte von den Grundlagen
der Arbeit im Drei-D-Raum bis hin
zur
Steuerung eines Charakters und einer
Kamera in einer Drei-D-Szene Wir werden untersuchen, wie
Sie mithilfe von Mathematik, Physik und Vektoren
das
Third-Person-Gameplay erreichen können, das Sie von den
meisten modernen Three-D-Spielen erwarten, bei dem der linke Stick
den Charakter
bewegt und dreht und
der rechte Stick die Kamera um ihn herum
dreht. Wenn ihr fertig seid, werdet ihr
über ein gutes Verständnis
der
Charaktersteuerung in der dritten Person verfügen und über eine voll funktionsfähige
Implementierung verfügen, die in
hohem Maße an
jedes Three-D-Projekt anpassbar ist , egal ob es sich um eine Plattform, Action
oder PG oder sogar um eine gemütliche Farmsimulation handelt. Sie können das Projekt
in jede gewünschte Richtung lenken. Sie werden auch nützliche Fähigkeiten erlernen um in 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 im
GD-Skript codiert , wobei alles ausführlich
erklärt wird Unsere Skripte
werden so geschrieben, hochgradig anpassbar
und wiederverwendbar sind. Alle Projektdateien
werden auch
auf GT Hub verfügbar sein , falls Sie das abgeschlossene Projekt
überprüfen müssen. Diese Videos wurden
mit Gada Version 4.2 aufgenommen. Von
HO heruntergeladene Assets von Kusberg.
2. 0-1 Einführung in die Programmierung: Hallo Freunde. musst
du
die GDOGameEngine von gdongine.org
herunterladen Falls du das
noch nicht getan hast, musst
du
die GDOGameEngine von gdongine.org
herunterladen. Die Engine ist kostenlos, aber du kannst
spenden, um das Projekt zu unterstützen, Es gibt keinen
Installationsvorgang. Sie können die
komprimierte Datei einfach entpacken und öffnen. Stellen Sie sicher, dass Sie die
ausführbare Datei an einen besseren Ort verschieben. Das erste Startfenster ist eine Liste Ihrer aktuellen Projekte Wenn Sie jedoch noch
keine Projekte haben, werden
Sie aufgefordert, sich
Demo-Projekte anzusehen. Wir können das ignorieren
und einfach
unser eigenes neues Projekt erstellen , indem wir
entweder auf diese Schaltfläche in der Projektliste oder auf die Schaltfläche Erstellen oben im Fenster klicken. Hier können wir
unserem Projekt einen Namen geben
, der normalerweise
der Name Ihres Spiels wäre. Ich werde nur eine Einführung in
die Programmierung geben. Das Projekt muss
auf der Festplatte unseres Computers gespeichert werden , und wir erstellen einen neuen Ordner mit dem gleichen Namen
wie das Projekt Standardmäßig möchte es alles im
Dokumentenordner
speichern,
aber es wäre besser, einen neuen Unterordner für
Godot-Projekte zu erstellen einen neuen Unterordner für
Godot-Projekte Der Renderer ändert,
wie bestimmte zwei D - und drei D-Objekte gerendert
werden, aber wir werden nichts
zeichnen, sodass wir diese Optionen ignorieren können Der Renderer kann auch später geändert
werden. Und die
Versionskontrollkompatibilität mit Github ist
standardmäßig enthalten , wenn Sie damit Ihr Projekt
sichern oder mit anderen
teilen möchten Ihr Projekt
sichern oder mit anderen
teilen Wenn Sie bereit sind zu beginnen,
klicken Sie auf Erstellen und Bearbeiten. Das GDOEditor-Fenster
öffnet unser neu erstelltes
leeres Projekt Der Editor ist
in fünf Hauptdocks unterteilt. Eine Vorschau unseres Spiels
befindet sich in der Mitte. Das untere linke Dock
enthält einen Dateibrowser der den Inhalt des Projektordners
anzeigt ,
den
wir gerade erstellt haben. Es
enthält derzeit nur das Gadot-Symbol. Das obere linke Dock
enthält den Szenenbaum, eine Liste von allem, was
sich in unserer aktuellen Szene ist derzeit leer, sodass wir einen
Stamm für den Szenenbaum erstellen Wir werden nichts zeichnen, also müssen wir nicht
angeben, ob es sich bei dieser Szene um
zwei D oder drei D oder um
eine Benutzeroberfläche handelt . Wir können also einfach einen anderen Knoten
auswählen. Es gibt viele verschiedene
Knoten, die wir erstellen können, aber wir sind nur daran
interessiert zu lernen, wie
man Skripte schreibt, also werden wir einfach
einen Standardknoten verwenden. Wir können unseren neuen Knoten umbenennen indem wir auf ihn klicken,
nachdem er
ausgewählt wurde , oder indem wir mit der rechten
Maustaste klicken, um
sein Kontextmenü zu öffnen , und Umbenennen
auswählen. Nennen wir diesen Knoten Lektion eins. Wenn Sie einen Knoten
im Szenenbaum auswählen werden seine Eigenschaften
im Inspektor angezeigt
, der an der
rechten Seite des Fensters angedockt ist Wir können den Namen des ausgewählten
Knotens und
seine Eigenschaften sehen, die
in erweiterbare Kategorien unterteilt
sind, aber keine dieser Eigenschaften aber keine dieser Eigenschaften trifft auf das zu,
was wir gerade Bevor wir etwas anderes tun, sollten
wir unsere neue Szene speichern, indem wir
entweder im Szenenmenü die Option Szene
speichern wählen oder
die
Tastenkombination Strg S oder Befehl
S verwenden . Dadurch wird ein
Dialogfeld geöffnet, in dem wir einen Namen für unsere
Szene mit der TSCNEtension
und einen Zielordner angeben
können und Lassen Sie uns einen neuen
Ordner für Lektion eins erstellen dann die Szene
in diesem Ordner speichern Wir können jetzt auf der Registerkarte
Dateisystem sehen, dass unser neuer Ordner für Lektion eins
erstellt wurde und dass er die Szene aus
Lektion 1 enthält, die mit
dem Clapperboard-Symbol gekennzeichnet ist Als Nächstes hängen wir ein Skript den Stammknoten unserer Szene
an, indem wir
entweder den Stammknoten auswählen und auf die
angehängte Skriptschaltfläche klicken oder indem wir mit
der
rechten Maustaste darauf klicken und das angehängte Skript auswählen Die Sprache ist GD Script, die
Programmiersprache die
wir lernen werden. Jedes Skript erbt standardmäßig von
dem Knotentyp, an den es
angehängt ist Da der Root-Node
ein Standard-Knotentyp ist, erbt
unser Skript vom Wir verwenden
weder eine Vorlage noch ein integriertes Skript, und wir können angeben, wo dieses Skript
innerhalb des Projekts gespeichert werden soll Lassen Sie uns das in
denselben Ordner legen. Lektion eins. Bei der Benennung von Skripten ist
es wichtig,
nicht willkürlich zu sein, sondern stattdessen
den Objekttyp
oder das Verhalten zu beschreiben , das wir
mit dem Skript erzeugen. Nennen wir das also Hello. Skripte haben die
Dateierweiterung Punkt gD. Klicken Sie anschließend auf Erstellen
, um das Skript zu erstellen. Dadurch wechselt unsere
Vorschau zur Skriptansicht unser neu
erstelltes Hello-Skript wird
angezeigt. Wir können unser Skript auch auf
der Registerkarte Dateisystem sehen , das mit einem Zahnradsymbol
gekennzeichnet ist, und der Stammknoten von Lektion 1 hat das Skriptsymbol, das
uns zeigt ,
dass ein
Skript angehängt ist Wenn wir den Mauszeiger darüber bewegen, wird uns der Name des Wenn Sie auf dieses Symbol klicken,
wird das Skript auch geöffnet, sofern es
nicht bereits geöffnet Unser Skript hat nur eine Zeile, die seine
Vererbung vom
Basis-Knotentyp mit
dem Schlüsselwort extends beschreibt . Das bedeutet nur, dass unser
Skript alles kann, was ein Knoten kann, plus
alles, was wir hier schreiben. Es ermöglicht uns auch, das Verhalten des Knotens,
das bereits existiert,
mit neuen eigenen Verhaltensweisen zu
überschreiben Knotens,
das bereits existiert . Knoten haben zum Beispiel
eine Funktion namens ready, aber sie tut nichts. Wenn wir also möchten, dass unser Skript dieses Verhalten
, nichts zu tun,
außer Kraft setzt, können
wir unsere
eigene Funktion mit
dem gleichen Namen mit
dem Schlüsselwort funk deklarieren . Funk folgt dann
der Name der Funktion, der normalerweise in
kleiner Schlangenschreibung geschrieben wird,
was bedeutet, dass alle
Kleinbuchstaben Wörter
durch Unterstriche trennen Vielen der durch
Knoten definierten Funktionen wird ein Unterstrich vorangestellt
,
und der Name
muss exakt übereinstimmen, um das Verhalten
zu überschreiben zu den Namen der Funktion müssen Klammern und ein Doppelpunkt
folgen Wir werden später besprechen, warum. Wenn Sie nach dieser Zeile die Eingabetaste drücken, wird
die nächste Zeile automatisch um eine Ebene
eingerückt Auf diese Weise
weiß GD Script, welche Zeilen in der
Funktion enthalten
sind und wo sie enden Die Zeile ist rot hervorgehoben , da Funktionen
nicht leer sein dürfen. Es ist also eine gute Idee
, das Wort Pass zu schreiben , um neuen Funktionen einen
Körper zu geben, der nichts tut. Jetzt, da der Fehler behoben ist, können
wir dieses blaue Pfeilsymbol
vor der
Funktionsdeklaration sehen . Dabei handelt es sich um
das Override-Symbol, das
darauf hinweist, dass
dieses Skript jetzt das
Bereitschaftsverhalten unseres Nodes überschreibt Anstatt nichts zu tun, möchten
wir, dass unser Knoten Hallo sagt, was wir mit
einer Print-Anweisung tun können, die die Zeile
ersetzt, in der
zuvor Pass stand Die Print-Anweisung sieht einer
Funktionsdeklaration mit
einem Namen gefolgt von Klammern
ähnlich einem Namen gefolgt von Klammern da sie
eine eingebaute Funktion aufruft Diese Funktion
benötigt ein Argument, das in die
Klammern gesetzt wird Und dieses Argument wird
gedruckt. Mit Anführungszeichen
können wir alles schreiben, was wir wollen, und es wird von
unserem Skript ausgedruckt , wenn
der Knoten bereit ist. Da das Skript Hello heißt, wollen wir ein Verhalten erzeugen dass der Knoten Hallo sagt. unser Skript fertig ist, können
wir unser Spiel mit der Schaltfläche „Aktuelle Szene ausführen oben rechts oder mit
der Tastenkombination F sechs ausführen. Dadurch wird
ein leeres Fenster angezeigt, da unser Spiel nichts
zeichnet, aber es
öffnet auch das fünfte Dock, in dem das Ausgabefenster
angezeigt wird. Und in unserer Ausgabe
können wir sehen, dass unser Node die Worte Hello
World
gedruckt hat , als er fertig war. Wir können diese Simulation beenden,
indem wir das Fenster schließen, auf die Stopp-Schaltfläche
klicken oder die Tastenkombination F 8 verwenden. Wir können den
gedruckten Text so ändern, dass er
alles sagt, was wir wollen, und ihn erneut
ausführen, um sicherzustellen, dass unser Node
alles ausdrucken kann, was wir ihm sagen. Wir wissen jetzt, wie man
Skripte an Knoten anhängt und sie ausführt. In der nächsten Lektion werden wir etwas
über Konstanten und Variablen lernen über Konstanten und Variablen Wir sehen uns in der nächsten Lektion.
3. 0–2 Konstanten und Variablen: Hallo Freunde. Wir beginnen
jede Lektion, indem wir zuerst einen neuen Ordner
für die Lektion
erstellen. Erstellen Sie dann eine neue Szene in diesem Ordner mit dem gleichen Namen. Doppelklicken Sie auf der Registerkarte Dateisystem auf eine Szene , um sie zu öffnen. mehrere Szenen geöffnet
sind, können wir zwischen ihnen wechseln,
indem wir
im Vorschaudokument auf die entsprechenden Tabs klicken. Heute werden wir
die Unterschiede zwischen
Konstanten und Variablen anhand von
Tagen als Bezugsrahmen erörtern Konstanten und Variablen anhand von
Tagen als Bezugsrahmen Lassen Sie uns also ein neues Skript an
den Stammknoten der
Szene anhängen und es Tage nennen Beginnen wir mit
Konstanten und deklarieren oben im Skript
mit dem Schlüsselwort const, gefolgt vom Namen
unserer neuen Konstante, die üblicherweise in Schlangengroßbuchstaben
geschrieben wird Eine Konstante ist wie ein Container in dem wir Informationen speichern können, aber diese Informationen dürfen sich
niemals ändern Etwas, das wir als
Konstante betrachten
würden , könnte die
Anzahl der Tage in der Woche sein. Da sie nicht geändert werden kann, muss ihr sofort ein
Wert zugewiesen werden, weshalb wir einen Fehler haben. Wir müssen dem Namen
ein Gleichheitszeichen folgen lassen, dem Zuweisungsoperator, um der Konstante einen Wert zu
geben. Die Anzahl der Tage in
der Woche beträgt sieben. Es ist vernünftig anzunehmen
, dass es immer sieben
sein werden und es ist für alle
gleich. Daher sollte es niemals
nötig sein, seinen Wert zu ändern. Umgekehrt haben wir Variablen, bei denen es sich auch um Container
zum Speichern von Informationen handelt, die
jedoch
so konzipiert sind, dass sie geändert werden können Wir können eine Variable auf
die gleiche Weise mit
dem Schlüsselwort VR deklarieren und ihr
dann einen Namen geben, ihr
dann einen Namen geben üblicherweise
in Kleinbuchstaben geschrieben wird. Das macht es einfach, den Unterschied
zwischen Konstanten und
Variablen in unseren Skripten zu
erkennen zwischen Konstanten und
Variablen in unseren Etwas, das
sich häufig ändert , könnte der Wert von heute Im Gegensatz zu Konstanten
dürfen Variablen leer sein. Lassen Sie uns die
Ready-Funktion
unseres Basisknotens überschreiben und die Werte sowohl für
die Anzahl der Wochentage als auch für den heutigen Tag ausgeben Wir können sehen, dass die Anzahl der
Tage in der Woche sieben beträgt, aber der Wert von heute
wird als Null ausgegeben,
was bedeutet, dass der Wert leer ist oder kein Wert vorhanden ist. Lassen Sie uns das beheben, indem wir den
heutigen Tag als Donnerstag initialisieren. Und wir können unsere Ausgabe
lesbarer machen , indem wir etwas Kontext hinzufügen, indem wir mit etwas
wie heute
beginnen, dann
ein Leerzeichen hinterlassen , danach ist ein
Pluszeichen, dann unsere Variable In diesem Fall wird das
Pluszeichen
verwendet, um zwei Satzteile aneinander
anzuhängen Wenn wir jedoch versuchen, dasselbe
mit unserer Konstante zu tun , führt
dies zu einem Fehler, da unsere Konstante eine
Zahl und kein Wort ist Als wir unsere Konstante deklariert
haben, haben wir ihr den Wert Sieben zugewiesen, was eine Zahl
ohne Dezimalstellen ist, die in der Mathematik als Ganzzahl
bezeichnet wird. Unsere Konstante hat also
eine Art Ganzzahl. Heute
wurde dagegen ein Wert zugewiesen, der aus
einigen Zeichen besteht, die in Anführungszeichen gesetzt sind. In der Programmierung
nennen wir das eine Zeichenfolge. Unsere Variable hat also
eine Art von Zeichenfolge. Der Plus-Operator
kann nur verwendet werden , wenn die Typen beider
Operanden kompatibel sind Wir können dies umgehen, indem wir eine eingebaute Funktion
verwenden, um den Typ, wie er hier verwendet
wird, in eine Zeichenfolge zu
ändern die Konstante als
Argument an die Funktion zu
übergeben Dadurch wird der Typ
der ursprünglichen Konstante nicht geändert,
sondern nur die Art und Weise, wie sie hier
im Kontext
der Anfügeoperation verwendet wird im Kontext
der Anfügeoperation Und wir können auch danach mit einer weiteren
angehängten Zeichenfolge weiteren Kontext hinzufügen , wobei wir
daran denken müssen, ein
zusätzliches Leerzeichen am Anfang hinzuzufügen Jetzt können wir unsere Konstanten und
Variablen
ausdrucken , indem wir sie in leicht
verständlichen Sätzen Lassen Sie uns nach diesen Zeilen
so tun, als ob ein Tag vergeht. Wir können
unseren Skripten zusätzlichen Kontext hinzufügen , der von Spielern
nie gesehen wird,
sondern nur dazu da ist, uns als
Entwickler zu helfen ,
unseren eigenen Code
oder den von anderen geschriebenen Code zu verstehen oder den von anderen geschriebenen Code Diese werden als
Kommentare bezeichnet und
mit dem
OctathorpPound-Zeichen oder dem Hashtag erstellt mit dem
OctathorpPound-Zeichen oder dem Hashtag Jeder Text, der nach diesem
Symbol geschrieben wird, wird grau
eingefärbt und hat keinerlei Auswirkungen auf die Ausführung
des Skripts Sie können sich in eigenen Zeilen oder am Ende einer Codezeile befinden. Lassen Sie uns also anhand eines Kommentars
erklären , dass wir
so tun, als ob
zwischen dem Code
über dieser Zeile und
dem Code unten ein Tag vergangen über dieser Zeile und
dem Code unten Wir ändern den
Wert von heute auf Freitag und drucken
einen weiteren Satz aus Heute ist plus Heute, was jetzt einen
anderen Wert hat. Wir können sehen, dass der Wert von
heute zuerst als
Donnerstag gedruckt und dann geändert wurde und der nächsten Zeile als
Freitag gedruckt
wird. Der Kommentar hatte keine Auswirkung
auf die Ausführung des Skripts. Wenn wir versuchen, den Wert
unserer Konstanten zu ändern, führt
dies natürlich zu einem Fehler, da Konstanten nicht geändert werden
dürfen Wenn wir einige
Codezeilen in unserem Skript nicht mehr
verwenden möchten , können
wir
sie einfach in Kommentare umwandeln, indem sie
markieren und Strg
K oder Befehl K drücken und das Kommentarsymbol vor jeder
hervorgehobenen Zeile
hinzufügen vor jeder
hervorgehobenen Zeile Durch erneutes Drücken werden die Kommentare
entfernt. Wir können den
Typ der Variablen
oder Konstanten angeben , indem wir nach dem Namen einen
Doppelpunkt hinzufügen. Gefolgt vom Typnamen wollen
wir auch diese
Konstante oder Variable einschränken. Beschränken wir unsere
Konstante auf den Typ int und heute auf
den Typ string. Neben Zeichenketten und Ganzzahlen
gibt es zwei weitere
primitive Typen, gibt es zwei weitere
primitive Typen wir zum Speichern
grundlegender Informationen verwenden können Wenn eine Zahl Dezimalstellen hat, handelt es sich nicht mehr um eine Ganzzahl,
sondern um einen anderen Typ,
der als Fließkommazahl bezeichnet wird
und sondern um einen anderen Typ,
der als Fließkommazahl bezeichnet wird den Typnamen float verwendet Fügen wir eine weitere Variable
für das heutige Datum hinzu und geben ihr eine Art
Fließkommazahl mit dem Wert 12,05,
was dem heutigen
Datum, dem 5. Dezember, entspricht Und der letzte Typ heißt Boolean und verwendet den
verkürzten Namen Boole
, der entweder
wahr oder falsch sein kann Also fügen wir eine weitere
Variable , ob
heute ein Feiertag ist oder nicht Ich beschränke das
auf einen booleschen Wert, gebe ihm
aber keinen
Anfangswert Fügen wir zwei weitere
Print-Anweisungen hinzu, um
die Werte dieser
Variablen mit Kontext auszudrucken die Werte dieser
Variablen mit Das heutige Datum ist ein Plus-Datum, und heute ist ein Feiertag. Colon Plus ist ein Feiertag. Wenn wir das jetzt ausführen, können wir unser Datum ausgedruckt
sehen, aber ist ein Feiertag falsch, obwohl wir ihm keinen Wert geben. Das liegt daran, dass alle primitiven
Typen einen Standardwert haben, aber der
Standardwert kann nur
zugewiesen werden , wenn wir
den Variablentyp angeben. Da wir angegeben haben, dass
ein Feiertag ein boolescher Wert ist, wurde
er
dem Standardwert
für einen booleschen Wert zugewiesen , Der Standardwert
für eine Ganzzahl und eine
Fließkommazahl ist beide Null, und der Standardwert für eine Zeichenfolge ist nur
eine leere Zeichenfolge, die nicht mit Null identisch ist, sondern eine Zeichenfolge
ohne Zeichen Wenn wir den
Typ einer Variablen nicht angeben, ihr Standardwert Null, aber ihr kann
ein Wert eines beliebigen Typs zugewiesen werden, und ihr Typ kann
sich jederzeit ändern. Lassen Sie uns den Typ aus dem Datum entfernen. Geben Sie ihm dann einen neuen Wert vom 13.
Dezember und drucken Sie
ihn ein zweites Mal aus. Der Variablen wird zunächst ein Wert in Form einer
Fließkommazahl
zugewiesen, wird von der
Print-Anweisung verwendet, dann wird ihr ein Zeichenkettenwert zugewiesen bevor sie erneut ausgedruckt wird. Dies ist zulässig
, da GD Script eine lose typisierte Sprache
ist Dies bietet mehr Flexibilität
beim Schreiben unserer Skripte,
aber auch mehr
Verantwortung, um
Typkompatibilitätsfehler zu vermeiden , wie
wir sie beim Plus-Operator gesehen haben Es wird empfohlen, dass Sie Ihren
Variablen
immer einen Typ geben, nicht nur um Fehler zu vermeiden, sondern auch, um die
Effizienz der Ausführung
Ihrer Skripte zu verbessern . Wenn die Engine den
Typ Ihrer Variablen kennt, weiß sie auch genau wie viel Speicher sie belegen
muss. Dies gilt auch für die Verwendung von Konstanten anstelle von Variablen Wenn die Engine weiß, dass sich der
Wert nicht ändern kann, kann er
effizienter verwendet werden In der nächsten Lektion lernen
wir, wie wir den
Ablauf unserer Skripte steuern können. Wir sehen uns in der nächsten Lektion.
4. 0-3 If-Aussagen und Bedingungen: Hallo Freunde. Ich habe
bereits eine neue Szene in einem
neuen Ordner für diese Lektion
erstellt. Heute lernen wir
, wie wir den Ablauf
unserer Skripts steuern können, um
verschiedene Codezeilen auszuführen und
zu entscheiden, ob wir sehen können oder nicht. Lassen Sie uns also ein neues Skript an
den Stammknoten unserer
Szene anhängen und es Vision nennen. Wir werden unser
Skript starten, indem wir
die Basisknoten-Definition
der Ready-Funktion überschreiben die Basisknoten-Definition
der Ready-Funktion Die einfachste Methode zur Steuerung
des Ablaufs unserer Skripten
ist die I-Anweisung, die mit
dem Schlüsselwort I beginnt. Auf sie
folgt eine
bedingte Anweisung , die entweder wahr oder falsch
sein muss Lassen Sie uns zunächst „wahr“ sagen, worauf dann ein Doppelpunkt
folgt. Ähnlich wie der Doppelpunkt am Ende unserer
Funktionsdeklaration markiert
dies das Ende
der Anweisung,
und wenn Sie mit der nächsten Zeile fortfahren, wird
sie automatisch um eine weitere Ebene
eingerückt Alle Codezeilen, die auf
diese if-Anweisung folgen und eingerückt sind
, werden nur ausgeführt wenn die Bedingung der if-Anweisung
wahr ist Lassen Sie uns also so etwas
wie die Bedingung als
wahr ausdrucken und dann
die aktuelle Szene ausführen , um zu sehen, ob unsere
Print-Anweisung funktioniert Wenn wir wahr in falsch ändern, können
wir sehen, dass die Druckanweisung dieses Mal
übersprungen wird Wir können nach den
if-Anweisungen, die den Hauptteil eingerückt haben, auf derselben Einzugsebene wie
die I-Anweisung eine weitere
Zeile hinzufügen if-Anweisungen, die den Hauptteil eingerückt haben, auf derselben Einzugsebene wie
die , einfach mit
dem Schlüsselwort se
gefolgt von Dadurch wird ein weiterer
Bedingungstext erstellt, der
nur ausgeführt wird , wenn die Bedingung
der ursprünglichen
I-Anweisung nicht erfüllt wurde Lassen Sie uns die
gedruckte Anweisung duplizieren und so ändern, dass sie
etwas anderes aussagt. Da die Bedingung falsch war, wurde
der se-Block
anstelle des I-Blocks ausgeführt. Und wenn wir die Bedingung
auf wahr ändern , passiert
das Gegenteil. Dies ist nicht sehr nützlich,
wenn wir immer wissen, dass das Ergebnis der bedingten Aussage wahr oder falsch ist, aber wir können
es durch eine Variable ersetzen. Deklarieren wir eine
boolesche Variable,
die angibt , ob das
Licht im Raum an ist oder nicht Boolesche Werte werden
üblicherweise
so benannt , dass sie
ihre Verwendung als Bedingung implizieren In diesem Fall bedeutet Licht ist an, je
nachdem, wie es benannt wurde, entweder wahr oder falsch Jetzt kann unsere if-Anweisung als Bedingung festlegen
, ob der Wert unserer
Variablen wahr ist
oder nicht Wenn wir zwei Werte vergleichen,
um festzustellen, ob sie gleich sind, verwenden
wir ein doppeltes Gleichheitszeichen, den
sogenannten Gleichheitsoperator, das sich von
einem einfachen Gleichheitszeichen unterscheidet das
wir zuvor als
Zuweisungsoperator verwendet haben. Wir drucken dann
entweder „Ich kann sehen“ oder „Ich kann nicht sehen“ aus, was
darauf zurückzuführen ist, ob das Licht an ist oder nicht, gleich wahr ist. Da der Standardwert
eines booleschen Werts falsch ist, können
wir die Ausgabe
so sehen, wie ich sie nicht sehen kann Aber wenn wir die
Variable auf true setzen, ändert
sie sich zu Ich kann sehen Da die Variable selbst ein
boolescher Wert ist , entweder wahr oder falsch, können
wir die
Vergleichsoperation ganz entfernen und einfach den booleschen Wert als Bedingung verwenden und genau
das gleiche Ergebnis erzielen Wir können den
Wert eines beliebigen booleschen Werts umkehren, d. h. wenn er wahr ist, falsch
oder wenn
er falsch ist, wird er
wahr, indem wir das Schlüsselwort not Wie bei der STR-Funktion, die wir in der vorherigen Lektion
verwendet haben, ändert
dies nur die Art und Weise, wie
sie
im lokalen Kontext verwendet wird , und ändert nicht wirklich den in der
Variablen gespeicherten Wert Wenn nicht, ist Licht an, dann können wir nichts sehen,
und sonst können wir sehen. Nichts kann auch
durch ein Ausrufezeichen dargestellt werden. Lassen Sie uns den Wert der eingeschalteten
Lichter ändern und es erneut ausführen. Ich setze diese Änderungen dann wieder auf den vorherigen Stand zurück Wir können unsere Bedingungen
viel komplexer machen, indem mehrere Bedingungen mithilfe von logischen Operatoren
miteinander
kombinieren mithilfe von logischen Operatoren
miteinander Lassen Sie uns eine weitere Variable
mit dem Namen Has dark vision erstellen. Diese Variable impliziert
, dass wir auch dann sehen können
sollten , wenn das
Licht nicht an ist. Wir können also zu unseren
If-Aussagen die Bedingung hinzufügen, dass
entweder das Licht an ist
oder dass wir eine dunkle Sicht haben. Und wenn eine
dieser Bedingungen zutrifft, dann können wir sehen. Nur wenn beide
Bedingungen falsch sind, führt das dazu, dass wir
nicht sehen können? Was ist, wenn
wir
statt Dunkelsicht eine
Nachtsichtbrille tragen, da wir damit nur im Dunkeln
sehen können, aber
nicht im Licht den Variablennamen ändern, muss sich auch
der Zustand unserer
I-Anweisung ändern Denn wenn beide
Bedingungen zutreffen, sollten wir nichts
sehen können. Nur wenn die Werte dieser
beiden Bedingungen unterschiedlich sind, sollten wir dann davon ausgehen, dass die zu prüfende
Bedingung erfüllt ist? Wir können den Operator „ungleich“ verwenden , um zu überprüfen, ob die beiden Werte nicht gleich
sind. Wenn Sie
mit logischen Operationen vertraut sind, wird
dies in anderen
Sprachen als ausschließliches Oder bezeichnet Jetzt können wir nur noch sehen, wenn entweder das Licht an
ist oder wir eine
Nachtsichtbrille tragen und nicht beides Als Nächstes nehmen wir an, dass unsere hypothetische
Person möglicherweise kein Mensch
ist, und fügen eine Variable für die Anzahl der Is hinzu, die sie hat, die als Ganzzahl
dargestellt werden sollte Vorerst geben wir
ihr einen Wert von zwei Is. die anderen Variablen ignorieren Was wäre die
Bedingung, die wir
setzen, um
anhand dieser Variablen sehen zu können, wenn wir die anderen Variablen Wenn die Anzahl unserer
Augen größer als Null ist, sollten wir sehen können Wir können dies auch
mit einem anderen Operator ausdrücken, größer oder gleich , und die rechte
Seite durch eins ersetzen. Sie müssen also Augen haben, die
größer oder gleich eins sind. Dies sind
Vergleichsoperatoren, die
ein boolesches Ergebnis zurückgeben , indem sie
den Wert von Zahlen auf
der linken und rechten Seite vergleichen den Wert von Zahlen auf
der linken und rechten Wir können logischerweise den Schluss ziehen , dass es für
jedes Lebewesen, ob Mensch oder
anderes, unmöglich sein sollte jedes Lebewesen, ob Mensch oder , eine
negative Anzahl von Augen zu haben Der Wert unserer
Variablen
sollte nur Null oder etwas
größer als Null Und die Bedingung
, sehen zu können, läuft
wirklich auf
diese beiden Optionen Haben wir keine Augen
oder Augen, die nicht Null sind? So wie die boolesche Variable implizit
als Bedingung verwendet werden
kann, kann auch
eine Ganzzahl auf diese
Weise verwendet werden, wobei Null falsche Bedingung und
alles andere als Null als wahr
betrachtet wird Dieselbe Logik wird auch auf
Fließkommazahlen angewendet. Wir können eine Float-Variable deklarieren, ihr den Namen
Sichtweite geben und
ihr einen beliebigen
Wert von 7,8 Metern geben. Wir können unsere
Vergleichsoperatoren verwenden, um festzustellen, ob diese Zahl größer als
kleiner oder gleich
einem bestimmten Wert ist , oder wir können sie implizit
in ihrer eigenen Bedingung verwenden wobei Null als falsch und alles andere als wahr angesehen
wird Was ist mit Saiten? Lassen Sie uns die Dinge etwas ändern und
eine Zeichenkettenvariable für das, was wir
gehört haben, deklarieren eine Zeichenkettenvariable für das, was wir
gehört haben und ihr den Wert
Bumps in the Night geben Dann könnten wir das logischerweise als
Wenn-Aussage verwenden als ob das, was ich gehört habe,
keine leere Zeichenfolge wäre, dann können wir sagen, ich habe
etwas gehört Ansonsten habe ich nichts gehört. Und genau wie bei den
anderen Variablentypen können
wir den
Vergleich fallen lassen und
die Variable selbst
als Bedingung verwenden . Bei allen Variablen werden
ihre Standardwerte als falsch
betrachtet, und alles andere wird immer als wahr angesehen,
wenn es als Bedingung verwendet wird. Wenn wir eine Variable
ohne Typ deklarieren, nennen
wir sie so, wie
ich es mir ansehe, geben ihr
aber keinen Wert, dann wissen wir bereits, dass ihr
Standardwert Null sein wird. Auch ohne einen Typ oder Wert kann
jede Variable
als Mobbing-Bedingung verwendet werden Jede Variable, die leer ist,
was bedeutet, dass ihr Wert Null
ist, wird als falsch betrachtet Wenn wir diese
Variable mit einem Objekt auffüllen würden, würde ihr Wert als Bedingung als wahr angesehen Wir haben derzeit keine
anderen Objekte, mit denen wir spielen können, aber wir können uns immer selbst benutzen Lassen Sie uns also den
Wert dessen, was ich mir ansehe, auf
das Schlüsselwort self setzen. Und das führt dazu
, dass man sehen kann. In der nächsten Lektion werden wir
Schleifen verwenden , um
Codezeilen mehrmals zu wiederholen. Wir sehen uns in der nächsten Lektion.
5. 0-4 While-Loops und Operatoren: Hallo Freunde. Heute lernen wir, wie man
Codezeilen mit Schleifen
mehrfach wiederholt , indem wir uns eine Frau
vorstellen , die sich zum ersten Mal verliebt hat, eine Blume in der Hand hält Also lasst uns ein neues
Skript schreiben und es Blume nennen. Überschreiben Sie dann die
Basisknoten-Definition der Ready-Funktion. Unsere imaginäre Dame hält
eine Blume mit einer
Anzahl von Blütenblättern in der Hand, die wir
in einer Variablen speichern und ihren
Typ auf eine Ganzzahl einschränken werden. Dann gib ihr einen Wert mit
einer beliebigen Zahl, sagen
wir fünf. Wir werden auch eine weitere
Variable namens He Loves Me
als booleschen Wert deklarieren , von der wir
glauben, dass sie ihren
Standardwert falsch hat Wir können unser
Drehbuch beginnen, indem wir
eine Geschichte über die verliebte
Dame ausdrucken , die ihre Blume hält Sie entfernt jedes Blütenblatt nacheinander von
der Blume und
sagt, entweder er liebt
mich oder er liebt mich Zuerst müssen wir
die Anzahl der Blütenblätter
auf der Blüte um eins reduzieren die Anzahl der Blütenblätter
auf der Blüte um eins reduzieren Wir beginnen also mit der Variablen
Anzahl der Blütenblätter und verwenden
dann den Zuweisungsoperator, verwenden
dann den Zuweisungsoperator um der
Variablen einen neuen Wert zuzuweisen. Der Wert, den wir ihr
zuweisen wollen, ist die Zahl, die sie bereits
hat, minus eins. Wir wollen dann den
Wert der Booling-Variablen ändern. Er liebt es, wenn ich sein Gegenteil bin. Er liebt mich also, ist
dem Nichts zugeordnet. Er liebt mich kehrt den Wert von
falsch wahr um oder umgekehrt Als Nächstes können wir die Ergebnisse
ausdrucken. Er liebt mich. Vielleicht möchten wir
diesen Teil in Anführungszeichen setzen, aber wenn wir versuchen, ein
Anführungszeichen in unsere Zeichenfolge zu setzen, markiert
es stattdessen
das Ende der Einige Sonderzeichen
wie Anführungszeichen
können innerhalb einer
Zeichenfolge mithilfe eines umgekehrten Schrägstrichs erstellt werden Wenn wir ein
umgekehrtes Anführungszeichen schreiben, steht
dies jetzt für ein
Anführungszeichen, nicht für das Ende der Zeichenfolge Und wir können
nach der Erklärung der Damen noch eine nach der Erklärung der Damen Lassen Sie uns diese
Zeile duplizieren und
die Erklärung dahingehend ändern ,
dass wir sagen: Er liebt mich nicht. Ein anderes Beispiel für ein
Sonderzeichen, das wir mit dem Backslash
schreiben können ,
ist der Backslash Wir können
die beiden
obigen Zeilen auch kombinieren und
sie mit dem Backslash N trennen, was eine neue Zeile darstellt. Sie werden also
von einer einzigen Druckanweisung aus
auf zwei Ausgabezeilen gedruckt Wir haben jetzt zwei Möglichkeiten
, die wir basierend auf dem Wert unserer booleschen
Variablen
ausdrucken möchten basierend auf dem Wert unserer booleschen
Variablen
ausdrucken Es scheint also, dass wir diese in eine if-Anweisung
packen sollten diese in eine if-Anweisung
packen Wenn er mich liebt, dann drucke das aus. Wenn er mich nicht liebt,
dann drucke das aus. Aber in Fällen, in denen
Anweisungen von einer einzigen booleschen Variablen abhängig
sind ,
um eine geringfügige Änderung vorzunehmen,
gibt es eine gibt es eine Kehren wir also zum ursprünglichen Format zurück
. Unsere Erklärung wird
sein, dass er mich liebt, wenn er mich liebt, sonst liebt er mich nicht. Dies ist trotz der
Verwendung derselben Schlüsselwörter nicht dasselbe wie eine if-Anweisung, sondern wird als
ternäre Operation bezeichnet Da sie keinen neuen Codeblock
mit Einrückung erstellt , wird
sie tatsächlich
effizienter ausgeführt
und es wird empfohlen, sie in einfachen Fällen
wie diesem zu verwenden Wir können die Größe
der Variante sogar noch weiter
reduzieren ,
indem wir sie nur so ändern, dass sie entweder ein
Ausrufezeichen
oder ein Leerzeichen ist,
gefolgt von dem Wort nicht, dann das Das funktioniert für den
Fall, dass er mich liebt, aber wenn wir den
Wert standardmäßig auf true ändern, dann sehen wir nur
im anderen Fall nichts Genau wie in der Mathematik gibt es eine bestimmte Reihenfolge von Operationen ,
in der unsere Skripte
mehrere Operationen
in derselben Zeile ausführen . Da sowohl die Zeichenfolge append auch
der ternäre I Operatoren sind, muss
einer
vor dem anderen ausgeführt werden, und in diesem Fall ist es die Zeichenfolge Und genau wie in der Mathematik werden
Klammern immer
zuerst ausgeführt Wir können also jede
Operation in Klammern setzen, um sicherzustellen, dass sie in der Reihenfolge
der Operationen
zuerst ausgeführt wird . Wenn wir unsere ternäre
Anweisung in Klammern setzen, wird
sie nun vor dem Anhängen
der Zeichenfolge ausgeführt und liefert uns das erwartete Ergebnis Jetzt haben wir also unseren Codeblock,
der
wiederholt werden muss, solange die
Blume noch Blütenblätter hat Mit dem Schlüsselwort WW können
wir, ähnlich wie bei einer if-Anweisung, ähnlich wie bei einer if-Anweisung, einen
Codeblock mit Einrückung wiederholen , solange die
Bedingung wahr bleibt Die Bedingung in
diesem Fall ist, dass die Anzahl der Blütenblätter auf
der Blüte nicht Null ist Unabhängig von der Anzahl der
Blütenblätter auf der Blüte wird sie jedes Mal
um eins reduziert. Nach der Print-Anweisung kehrt der logische Ablauf dieses
Skripts zum
Anfang von WWLoop zurück ,
um den Zustand erneut zu überprüfen Wenn die Anzahl der
Blütenblätter Null erreicht, ist
die Bedingung nicht mehr
erfüllt und die Schleife wird unterbrochen, sodass mit dem Rest
des Skripts fortgefahren wird, falls vorhanden Lassen Sie uns also
auf der Grundlage der Ergebnisse ein
kurzes Fazit
zu unserer Geschichte schreiben . Sie steht mit
Tränen in den Augen auf. Aber basierend auf dem endgültigen
Wert von He Loves Me ist
sie entweder glücklich oder traurig, und wir werden den
anderen letzten Satz ausdrucken. Wenn wir diese Szene abspielen, können wir
unsere Geschichte
im Ausgabefeld ausgedruckt sehen , und mit fünf Blütenblättern ist
die Dame glücklich. Wenn wir die Anzahl
der Blütenblätter auf sechs ändern, erhalten wir ein
anderes Ergebnis, da die Schleife sechsmal statt
fünfmal wiederholt. Aber was passiert, wenn wir
die Anzahl der Blütenblätter
auf der Blüte auf Null ändern ? Die Schleife läuft überhaupt nicht
und die Liebe war
von Anfang an zum Scheitern verurteilt Ich empfehle nicht, diesem Beispiel zu
folgen, sondern einfach zu beobachten, was
passiert, wenn wir
der Blume eine negative
Anzahl von Blütenblättern geben der Blume eine negative
Anzahl von Blütenblättern Das ist zwar
realistischerweise unmöglich, in unserem Code ist es
sehr problematisch Da die Bedingung unserer
Wandschleife niemals erfüllt werden kann, wird
sie niemals kaputt gehen, und das Skript ist
darin gefangen und wird nie fertig Dies ist eine Endlosschleife und sollte um jeden Preis vermieden werden. In diesem Fall können wir
die Endlosschleife verhindern, indem wir
unsere Bedingung so ändern unsere Bedingung so die Anzahl der Blütenblätter größer als Null
ist, da eine negative Zahl
die Schleife immer noch unterbricht. Als Abkürzung können wir einen anderen Operator verwenden ,
um die Anzahl der
Blütenblätter zu reduzieren. Da wir
den Namen unserer Variablen nicht zweimal schreiben müssen , können
wir
mit einem speziellen
Zuweisungsoperator einfache
mathematische Operationen an
unserer Anzahl von Variablen ausführen unserer Anzahl von Variablen . In diesem Fall kann der Operator minus
gleich diese Codezeile in die
Anzahl der Blütenblätter
minus eins
ändern Anzahl der Blütenblätter
minus eins Diese Abkürzungen existieren für alle grundlegenden
Rechenoperationen plus Gleichem multiplizieren gleich
oder dividieren gleich und können mit jeder Zahl
oder Variablen als dem anderen Operanden verwendet werden alle grundlegenden
Rechenoperationen plus
Gleichem multiplizieren gleich
oder dividieren gleich
und können mit jeder Zahl
oder Variablen als dem anderen Operanden verwendet werden. gibt es noch einen weiteren Operator, Grundrechenarten gibt es noch einen weiteren Operator,
den Modulo-Operator,
der durch das Prozentzeichen dargestellt wird Modulus führt eine
Divisionsoperation durch, gibt
aber nicht
den Quotienten als Ergebnis zurück, wie es der Divisionsoperator Stattdessen gibt er den
Rest der Division zurück. Das gesamte Drehbuch bestimmt,
abgesehen von der Geschichte, die erzählt
wird, eigentlich nur,
ob es sich bei der Anzahl der Blütenblätter auf der Blüte um
eine gerade oder ungerade Zahl handelt, aber das geschieht auf die
ineffizienteste Art und Weise, jedes
einzelne Blütenblatt
heruntergezählt Lassen Sie uns also
die gesamte Wandschleife auskommentieren und stattdessen Modulus verwenden
, um den Prozess zu beschleunigen wissen, dass alle geraden Zahlen durch zwei teilbar
sind, können
wir die Anzahl der
Blütenblätter als Modul zwei verwenden Das einzig mögliche Ergebnis
als Rest dieser
Division ist entweder Null, wenn die Anzahl der Blütenblätter gerade ist oder eins, wenn die
Anzahl der Blütenblätter ungerade ist Unser Skript könnte
dahingehend vereinfacht werden, dass
die Dame glücklich ist, wenn die Anzahl der Blütenblätter,
Modul
zwei, gleich eins ist Ansonsten ist sie traurig. Da wir wissen, wie ganze Zahlen
als Bedingungen interpretiert werden, müssen
wir
die Vergleichsoperation
hier nicht einmal durchführen , sondern können sie einfach auf I, Anzahl der
Blütenblätter
, Modul zwei, verkürzen I, Anzahl der
Blütenblätter
, Modul Das Ergebnis der
Moduloperation
könnte direkt
der booleschen Variablen zugewiesen werden, um dasselbe Ergebnis zu erhalten , ohne dass eine if-Anweisung
erforderlich wäre, und die Null oder Eins wird automatisch in falsch oder wahr umgewandelt Wir könnten noch weiter gehen, indem wir
die Variable entfernen und einfach die Modulus-Operation direkt
in
der Turny-Anweisung verwenden Modulus-Operation direkt
in
der in In der nächsten Lektion lernen
wir
Sammlungen
verwandter Variablen kennen Sammlungen
verwandter Variablen Wir sehen uns in der nächsten Lektion.
6. 0-5-Arrays und For-Loops: Hallo Freunde. Heute werden wir darüber nachdenken, wie wir
große Mengen von Variablen organisieren können, insbesondere wenn sie
verwandte Informationen enthalten. Ich habe bereits ein Skript namens
Census erstellt
und die Basisknoten-Definition
der Ready-Funktion außer Kraft gesetzt Basisknoten-Definition
der Ready-Funktion Für unser hypothetisches
Szenario in dieser Lektion stellen
wir uns einen
Volkszähler vor, der aufzeichnen muss,
wie viele Menschen in
jedem Haus an einer einzigen Straße in seiner Stadt leben jedem Wir können eine einzige Variable deklarieren , die all diese Informationen wir Und der Typ dieser
Variablen wird ein Array sein. Ein Array kann eine Liste von
Variablen aller
anderen Typen enthalten . In diesem Fall handelt es sich den
gesuchten Variablen um Ganzzahlen, die die Anzahl
der
Personen angeben, die in jedem Haus leben Wir können den
Inhaltstyp
eines Arrays angeben , indem wir
eckige Klammern hinter
dem Typnamen array verwenden und
den Typ des Inhalts
in die eckigen Klammern setzen den Typ des Inhalts
in die eckigen Klammern Jetzt kann dieses Array nur
ganze Zahlen als Inhalt enthalten. Bevor wir auf den
Inhalt eines Arrays zugreifen können, muss
es eine Größe haben, die Anzahl der Variablen, die darin enthalten
sind Im Gegensatz zu anderen
Variablen sind Arrays komplexer und haben
ihre eigenen Funktionen Wir können auf diese Funktionen zugreifen, indem dem Namen der
Variablen einen Punkt und
dann den Namen der Funktion
folgen dann den Namen der Funktion In diesem Fall die
Resize-Funktion, die die Anzahl der
Adressen innerhalb dieses Arrays festlegt und die Anzahl der Häuser an
der Main Street
darstellt, von der wir sagen, dass sie sechs ist Unsere vorgestellte Stadt ist
insofern etwas ungewöhnlich die Hausnummern an der
Main Street bei Null beginnen Unser Volkszähler
beginnt also am Haus an der Main Street
Null und
klopft an die Tür,
um den Bewohner des Hauses zu fragen wie viele Menschen in
dem Haus
leben Wir können einen Wert in einem
Array speichern, beginnend mit seinem Namen, dann mit
eckigen Klammern die Adresse
der
spezifischen Ganzzahl markieren , in diesem Fall Adresse Null, und
dann den
Zuweisungsoperator verwenden Wir können dieser Adresse eine Ganzzahl
zuweisen. Nehmen wir an, in der
Hausnummer Null an der Main Street leben fünf
Personen. Auf dem Weg zum nächsten Haus an Main Street, Adresse Nummer eins, beantwortet
jemand das Klopfen
an der Tür und teilt dem Volkszähler mit, dass in diesem Haus zwei Personen leben Am nächsten Haus,
Adresse Nummer zwei, befindet sich
das Haus im Bau
und hat ein Verkaufsschild,
was bedeutet, dass dieses Haus eindeutig unbewohnt
ist, und unser Volkszähler registriert die Anzahl der Einwohner mit Null An der Hauptstraße Nummer drei niemand die Tür, obwohl in der Einfahrt ein Auto steht und
es Anzeichen von
Besiedlung Was sollte
unserer Meinung nach
der Volkszähler als Zahl
der Wir könnten denken, dass
es Null sein könnte. Aber wie würden wir zwischen
einer unbekannten Anzahl von Bewohnern
und einem unbewohnten Haus
unterscheiden einer unbekannten Anzahl von Bewohnern
und einem unbewohnten Wenn wir bedenken, dass die
Zahl der Bewohner
eines Hauses niemals als negative Zahl
betrachtet werden sollte, könnten
wir die Zahl
negativ eins verwenden, um zu bedeuten, dass die Anzahl der Bewohner des
Hauses ein unbekannter Wert ist Und an der Main Street Nummer vier gibt es wieder keine
Antwort an der Tür Aber das Haus
scheint auch vernachlässigt zu sein, und wahrscheinlich hat
dort seit geraumer Zeit niemand mehr gelebt. Wir könnten annehmen, dass die
Anzahl der Bewohner Null ist vielleicht denselben negativen
Eins-Wert für eine unbekannte Anzahl
von Bewohnern verwenden Eins-Wert für eine unbekannte Anzahl oder negativere Wertcodes für
verschiedene Situationen erstellen,
wie z. B.
negative Zwei zu verwenden , um wahrscheinlich
unbewohnt, aber nicht bestätigt zu bedeuten Die Adresse Nummer fünf an der Main Street hat nicht
einmal ein Haus, aber es ist nur ein Also auch hier könnte dies mit einer Null
oder einem anderen negativen Wert
dargestellt werden , um eine Art von Besprechung zu
kodieren Lassen Sie uns die Ergebnisse der Volkszählung ausdrucken und sehen, wie sie
aussehen Wir können uns unser Array
als
kommagetrennte Liste von
Zahlen vorstellen , die in eckige Klammern gekapselt Dies stellt die Anzahl der Menschen
,
die
in jedem Haus an der Main Street leben, anständig dar Anzahl der Menschen
,
die
in jedem Haus an der Main Street leben Aber was wäre, wenn wir
diese Daten verwenden wollten , um
die Gesamtzahl der Bewohner aller Häuser
an der Main Street oder im Durchschnitt Wenn wir die Summe all
dieser Zahlen berechnen würden, die negative
Darstellung der unbekannten Zahlen die Ergebnisse verfälschen würde
die negative
Darstellung der unbekannten Zahlen die Ergebnisse verfälschen Einer der größten Vorteile der Verwendung
von Arrays zum Speichern verwandter Informationen auf diese Weise
besteht darin, wie einfach es ist, sie in einer Schleife
zu durchsuchen Mit dem Schlüsselwort vier schreiben
wir als Nächstes den Namen
einer neuen Variablen,
eine, die
jedes einzelne Element
innerhalb des Arrays repräsentiert , gefolgt vom Schlüsselwort in dann dem Namen des Arrays Handelt es sich bei
Anweisungen wie bei Funktionen um WA-Schleifen, folgt darauf ein Doppelpunkt und ein eingezogener Codeblock
, der wiederholt wird Diese Codezeilen
werden für jedes unserer sechs
Häuser an der Main Street
einmal wiederholt , und wir können dem
variablen Haus einen Namen geben, da es für den Zugriff auf
jedes einzelne Haus
innerhalb der Schleife verwendet wird jedes einzelne Haus
innerhalb der Schleife Nehmen wir an, wir wollen zunächst
die durchschnittliche Anzahl der Bewohner ermitteln die durchschnittliche Anzahl der Bewohner , die in einem bewohnten Haus leben Das würde bedeuten,
alle positiven Zahlen zu addieren dann durch die
Anzahl der bewohnten Häuser zu dividieren Wir benötigen also drei
neue Variablen, eine für die Gesamtzahl
der Bewohner, weitere für die Anzahl
der bewohnten Häuser, beide als ganze Zahlen und eine Fließkommazahl
für den Durchschnitt Für jedes Haus in der Main Street können
wir überprüfen, ob das
Haus bewohnt ist, ob die Zahl,
die im Array an dieser Adresse gespeichert ist, jetzt in der Hausvariablen gespeichert ist, größer als Null ist Wenn dies zutrifft, kann
die Gesamtzahl der
Bewohner in bewohnten Häusern von Haus zu Haus erhöht werden,
und die Anzahl der bewohnten
Häuser
kann um eins erhöht werden Nachdem alle sechs Häuser an der Main
Street überprüft wurden, wird die Schleife unterbrochen und wir haben
unsere beiden ganzen Zahlen. Wir können also den
Durchschnitt berechnen, indem wir
die Gesamtzahl der Bewohner
durch die Anzahl der
bewohnten Häuser teilen die Gesamtzahl der Bewohner
durch die Anzahl der
bewohnten Häuser Drucken Sie dann die Ergebnisse aus. Es gibt mehr bewohnte Häuser, plus bewohnte Häuser
an der Main Street, mit einem Durchschnitt von mehr Durchschnittsbewohnern plus
Bewohnern Aber wenn wir diesen Code ausführen, wird
der Durchschnitt
als Ganzzahl,
drei, dargestellt, was, wie wir wissen, nicht korrekt
ist Da in
zwei bewohnten Häusern insgesamt sieben Personen wohnen, sollte
der Durchschnitt bei 3,5 Dies geschah,
weil wir
eine Divisionsoperation
mit zwei ganzen Zahlen durchgeführt haben ,
weil wir
eine Divisionsoperation
mit zwei ganzen Zahlen und das Ergebnis der Operation ebenfalls eine Ganzzahl sein
wird, obwohl wir sie
einer
Fließkommazahlvariablen zuweisen einer
Fließkommazahlvariablen Godot warnt auch davor, Ganzzahlen
in
Divisionsoperationen zu verwenden Um dieses Problem zu lösen, können wir
unsere Integer-Variablen
in ihren Deklarationen in
Fließkommazahlen ändern unsere Integer-Variablen , oder wir können ihren Typ
lokal ändern , bevor wir die
Division durchführen Ähnlich wie wir ganze Zahlen
vor dem Anhängen in Zeichenketten umgewandelt
haben, können wir eine Ganzzahl in eine Fließkommazahl
umwandeln,
bevor wir eine Division durchführen Das Ergebnis
der Division wird ebenfalls in eine
Fließkommazahl umgewandelt. Das Ändern des Typs einer Variablen auf diese Weise wird als Casting bezeichnet. Wir wandeln eine
Ganzzahl in eine Gleitkommazahl um. Jetzt können wir die Ergebnisse sehen, die wir mit einem Durchschnitt
von 3,5 Bewohnern
pro bewohntem Haus erwartet
hatten von 3,5 Bewohnern
pro bewohntem Haus Ein Vorteil von GD Script, da es sich um eine lose typisierte
Sprache handelt, besteht darin, dass wir unserer Variablen
nicht spezifizieren müssen,
einschließlich der
Typen, die in einem Array
enthalten sind Wenn wir zulassen, dass unser Array jede Art von Variablen
enthält, können
wir ändern, wie unser
Volkszählungsmitarbeiter Nehmen wir an, dass die Adresse Null bei fünf Bewohnern gleich
bleibt Adresse eins enthielt aber auch die Namen der beiden
Einwohner, die dort leben Anstatt die
Bewohner als Nummer zwei aufzuzeichnen, könnten
wir ihre
Namen in einer Zeichenfolge aufzeichnen Die Adresse Nummer eins an der Main Street wird also von Jordan
und Ashley Smith
besetzt Haus Nummer zwei war unbewohnt, was wir als Null
darstellen konnten Wir könnten aber auch erwägen es stattdessen als
booleschen Wert
aufzuzeichnen
und ihm den Wert False
zu geben, was bedeutet, dass sich das Haus
im Bau befindet und
möglicherweise keine Bewohner haben kann In Nummer drei war
niemand zu Hause, aber es leben definitiv
Menschen dort Wir wissen einfach nicht, wie viele. Wir könnten
diesen Wert auch als
booleschen Wert speichern und ihm den Wert
true geben Bei Nummer vier
scheint es wirklich so, als ob dort niemand wohnt. Vielleicht möchten wir
es als null Insassen kennzeichnen. Bei Adresse Nummer fünf könnten
wir, da es dort nicht
einmal ein Haus gibt, da es dort nicht
einmal ein Haus gibt, in
Betracht ziehen, Null als
Wert zu verwenden , da Null
das Fehlen eines Werts bedeutet Wir können das Schlüsselwort Null verwenden, um diesen Wert dem
Array an Adresse fünf
zuzuweisen. Jetzt
sieht unser gedrucktes Array ganz anders enthält Variablen
aller Typen statt nur Ganzzahlen Und wir können mehr
Informationen daraus erkennen. Arrays können sogar andere
Arrays als Inhalt enthalten. Lassen Sie uns also unsere
Namensliste von
einer einzelnen Zeichenfolge in ein
Array von Zeichenketten ändern einer einzelnen Zeichenfolge in ein
Array von Wir können dieses
Array gleichzeitig
mit eckigen Klammern erstellen und
es dann mit
einer durch Kommas getrennten Liste von
Zeichenketten als Inhalt füllen einer durch Kommas getrennten Liste von
Zeichenketten als Inhalt Wenn wir also wissen wollten, wie viele Menschen an der
Adresse eins an der Main Street leben, könnten
wir das als
Mainstreet one dot SIE ausdrucken In der nächsten Lektion werden
wir mehr darüber erfahren, wie
Arrays verwendet werden können, um
dynamischere Datensammlungen zu erstellen Wir sehen uns in der nächsten Lektion.
7. 0–6 Stacks und Funktionen: Hallo Freunde. Heute werden wir auf unterschiedliche Weise
weiter mit
Arrays arbeiten unterschiedliche Weise
weiter mit
Arrays indem wir ein
Spiel von Old Made einrichten Ich habe bereits ein Skript namens
Old Made erstellt
und die Definition
der Basisknoten der Ready-Funktion außer Definition
der Basisknoten der Ready-Funktion Um Old Made spielen zu können, benötigen
wir ein Kartenspiel, das eine Sammlung von
Variablen ist , die wir in einem Array
speichern können Da sich das Spiel
Old Made nicht wirklich um die Farben
der Karten kümmert, können
wir diese Information ignorieren und jedes Element in der
Reihe muss nur
die Kartenrangfolge von Ass
bis König als Ganzzahl enthalten . Um unser Deck zu generieren, können
wir einen Vier-Loop-Modus verwenden. Aber anstatt die Vierer-Schleife
zu
verwenden , um durch ein Array zu iterieren, können wir
sie einfach verwenden, um unsere Kartenränge abzuzählen Beginnend mit vier können
wir
eine Variable deklarieren, die den Rang
einer Karte repräsentiert, gefolgt vom Schlüsselwort in, und dann eine Zahl angeben Wenn wir
King als Zahl betrachten würden, wäre das der 13. Rang. Lassen Sie uns vorerst einfach den
Rang ausdrucken , damit wir sehen können, was passiert. Die Vierer-Schleife beginnt mit einem Rangwert bei Null
und zählt bis zu 12, wobei diese Schleife und die
Druckanweisung 13 Mal wiederholt werden. Aus Gründen der Vernunft könnte
es eine gute
Idee sein, könnte
es eine gute
Idee sein, Karte Nummer zwei durch Rang zwei darzustellen, sodass Ass eins und König 13 wäre ist zwar sehr hilfreich, eine Vierer-Schleife bei
Null zu starten durch Arrays
zu iterieren, da ihre erste
Indexnummer Null ist, in diesem Fall ist
es nicht so hilfreich Wir können die Zählung
einer Viererschleife ändern, indem die 13 durch den
Funktionsaufruf range
ersetzen Funktionsaufrufen
folgen Klammern, die Argumente
enthalten Die Argumente für
diese Funktion sind die Unter- und
Obergrenzen des Bereichs Die Untergrenze wird in den Bereich
aufgenommen, die Obergrenze
jedoch nicht. Bereich 114 wird
alle Zahlen 1—13 enthalten, wir können sehen, dass das in der Ausgabe
ausgedruckt ist Eine andere Möglichkeit, Informationen
zu einem Array
hinzuzufügen , anstatt die eckigen Klammern und
die
Indexnummer zu verwenden eckigen Klammern und
die , besteht darin, eine
Funktion namens append zu verwenden Diese Anfügefunktion akzeptiert ein Argument des Werts
, der dem Array hinzugefügt wird Dadurch wird der hinzugefügte
Wert an das Ende des Arrays gesetzt,
wo auch immer das sein mag Und da es in einem Kartenspiel vier von
jedem Rang gibt, eine für jede Farbe, sollten wir diese Codezeile für jeden Rang
viermal
wiederholen. Wir können das mit
weiteren vier Schleifen machen Diesmal beginnen wir bei
Null und zählen bis, aber ohne vier. das Deck ausdrucken, können wir
sehen, dass unser Array vier von
jeder Zahl 1—13 hat , also
insgesamt 52 Karten Aber um altmodisch zu spielen, wollen
wir
drei der Damen entfernen, oder in diesem Fall 12. also in unserer Vierer-Schleife, die sich durch
die Kartenfarben
iteriert, Lassen Sie uns also in unserer Vierer-Schleife, die sich durch
die Kartenfarben
iteriert, überprüfen, ob der Rang 12 ist Und in diesem speziellen Fall wollen
wir nur das Hinzufügen von
112 zulassen, wobei wir das Schlüsselwort break
verwenden, das Schlüsselwort break
verwenden um sofort
aus dieser Schleife auszubrechen Break beendet nur die Schleife mit
den meisten Einrückungen, in der
es sich gerade befindet Wir beenden also den
Suit für Loop, aber nicht den Rang für Loop Dadurch wird
der Rang auf 13 erhöht und dem Deck werden
vier Dreizehner hinzugefügt Und wenn wir es ausprobieren, können wir
sehen, dass es nur 112 gibt. Das Erste, was in
unserem Spiel passiert, ist das Mischen
des Kartendecks, was im GD-Skript eine
einfache eingebaute
Funktion von Rayse ist einfache eingebaute
Funktion von Rayse Wir müssen
diese Funktion nur aufrufen und schon
können wir sehen, dass die Karten in unserem
Deck gemischt werden Außerdem benötigen wir
eine weitere Variable, eine Reihe von Kartenhänden, die unsere
Spieler repräsentieren Jede Hand innerhalb des Blatt-Arrays muss mehrere Karten enthalten, es handelt sich also auch um Arrays, die wir initialisieren müssen,
bevor wir sie verwenden können also von Null
bis vier zählen, können
wir eine neue
Hand an das Array anhängen Unsere Hand beginnt als leeres
Array, das
durch eckige Klammern dargestellt wird Wenn wir uns unser Kartendeck vorstellen, wobei
die Vorderseite der Karten die Seite mit Rang und Farbe ist,
die Rückseite der
Karte leer ist, dann könnten wir uns auch vorstellen, dass
das Deck verdeckt ist. Die Vorderseite der Reihe ist
die Unterseite des Decks, und die Rückseite der Reihe
ist die Oberseite des Decks. Das
Austeilen der Karten kann
durch iteratives Durchlaufen unseres Decks erfolgen, aber wir müssen nicht wirklich auf bestimmte Karten
verweisen,
da es eigentlich egal ist, um auf bestimmte Karten
verweisen,
da es eigentlich egal ist, welche es sich handelt, nur dass die Karte vom oberen Rand
des Decks genommen und einem Spieler
ausgehändigt Um also eine Karte von
der Oberseite des Decks zu entfernen, können
wir eine andere Funktion aufrufen Dieser heißt Pop Back. Es gibt nicht nur das
letzte Element im Array zurück, sondern entfernt
es auch aus dem Array. Wir wollen diese Karte dann der Hand
des Spielers hinzufügen und
beginnen mit Spieler eins,
vorausgesetzt, Spieler
Null ist der Dealer. So wie wir
Popback verwenden können, um eine Karte zu entfernen, können
wir auch eine
Karte mit Pushback hinzufügen Die Karte, die wir
auf den Handrücken
des Spielers legen, ist dieselbe Karte, die wir
von der Rückseite des Wir können
diesen Funktionsaufruf einfach in die Klammern
des Funktionsaufrufs setzen und
seinen Rückgabewert als
Argument für die Push-Funktion verwenden seinen Rückgabewert als
Argument für die Push-Funktion Die Verwendung von Pushback entspricht
exakt der Verwendung von append. Die Append-Funktion ist
ein Erbe von Zeichenketten, da sie normalerweise
als Zeichenarrays gespeichert werden,
während Push und Pop aus der Verwendung von Stacks oder Cues stammen , wie wir es Um unsere nächste Karte austeilen zu
können, müssen wir das
Blatt, an das ausgeteilt wird, erhöhen Speichern wir das
in einer Variablen als Ganzzahl und geben ihr den
Anfangswert eins die Zahl in unserem
Array-Index durch unsere Variable ersetzen, müssen
wir sie um
eins erhöhen , nachdem jede Karte ausgeteilt Aber das wird natürlich
nur bis 51 zählen, und es gibt nicht so viele Hände Also müssen wir diese
Zahl jedes Mal, wenn
sie vier erreicht, auf Null zurückkehren . Dies kann mit
unserem Trustee-Modulo-Operator erreicht werden , bei dem die
Zuweisung von Hand auf
Modulus gleich vier Wenn wir jedoch möchten, dass unser Code mit einer beliebigen
Anzahl von Spielern funktioniert, wäre
es besser, vier durch die Größe
unseres Hands-Arrays zu ersetzen vier durch die Größe
unseres Hands-Arrays Um zu sehen, wo wir uns bis jetzt befinden, drucken
wir unsere Hände aus,
indem wir durch
das Hands-Array iterieren und jedes einzelne
ausdrucken Drucken Sie dann das Deck aus. Wir können unsere vier Arrays sehen
und das Deck ist leer. Wir können sogar die
Anzahl der Spieler ändern und die Karten werden an
die richtige Anzahl von Händen verteilt. Unsere Bereitschaftsfunktion wird
immer umfangreicher. Wir können unseren Code
besser organisieren , indem wir
unsere eigenen Funktionen deklarieren Wir teilen unsere Logik
in kleine Teile auf und haben einen Abschnitt, der
unser erstes Kartendeck erstellt, einen, der die Hände des Spielers erstellt,
und
einen,
der die Karten die Hände des Spielers erstellt,
und
einen,
der die austeilt. Mit dem Schlüsselwort Funk können
wir jedem
dieser Codeblöcke
einen Namen geben , gefolgt von
Klammern und einem Deck initialisiert, Hände
initialisiert und Deal. Dann kann die Ready-Funktion
jede dieser
Funktionen nacheinander aufrufen jede dieser
Funktionen nacheinander Unsere Funktionen können auch Argumente
akzeptieren, z. B. die Anzahl der
Hände, die wir haben möchten. Übergeben wir vier als Argument. Um unsere Funktion so
zu schreiben, dass sie das Argument akzeptiert, müssen
wir einen
passenden Parameter
in die Klammern
der Funktionsdeklaration einfügen in die Klammern
der Funktionsdeklaration Ähnlich wie das Deklarieren einer Variablen hat
sie einen Namen und
optional auch Da wir dies verwenden,
um die Größe eines Arrays zu ändern, ist
es eine gute Idee,
es auf eine Ganzzahl zu beschränken Wir können dann den
Parameter innerhalb
der Funktion
genauso verwenden der Funktion
genauso , wie wir
jede andere Variable verwenden würden Das Letzte, was wir
tun müssen, um mit dem Spielen zu beginnen,
wäre , alle Paare
aus der Hand jedes Spielers zu entfernen. wir also jede
Hand in der Reihe der Hände durchgehen, können
wir eine weitere Funktion aufrufen um die Paare
aus dieser Hand zu entfernen, indem wir die Hand als Argument übergeben dieser Funktion
eine Definition geben, können
wir dann eine Hand
als Array-Parameter akzeptieren Wir müssen mit einer Variablen durch
die Hand iterieren. Nennen wir es Karte eins. Aber wir können aufhören, bevor
wir zur letzten Karte kommen. Also gehen wir nur von Null
auf die Größe der
Hand minus eins. Wir können dann auf die gleiche
Weise
ein zweites Mal
wiederholen , aber dieses Mal beginnen wir mit der Karte nach der
anderen und gehen bis zum Ende
der Handgröße Innerhalb dieser 24 Schleifen Karte eins und Karte zwei nun jedes einzelne Kartenpaar enthalten
Karte eins und Karte zwei nun jedes einzelne Kartenpaar
in unserer Hand, sodass wir
die beiden Karten leicht vergleichen können , um zu sehen,
ob sie zusammenpassen Wenn ja, können sie aus der Hand
genommen werden ,
beginnend mit Karte zwei. Wenn wir zuerst Karte eins entfernen würden, der Index von Karte würde sich dadurch der Index von Karte
zwei tatsächlich
ändern, da sich alle Karten um eine Position bewegen
würden. Wenn wir eine Übereinstimmung finden, wollen
wir
diese Schleife oder eine der beiden Schleifen nicht fortsetzen, sondern wir wollen
den gesamten Vorgang erneut starten. Ein einfacher Weg, dies zu tun,
wäre eine while-Schleife, eine boolesche Variable
, die angibt, ob wir ein Paar mit dem
Standardwert true
gefunden haben oder nicht ein Paar mit dem
Standardwert true
gefunden haben Wenn ein Paar gefunden wurde, können
wir es sofort auf
false setzen Dies ermöglicht es uns, in die Schleife
einzutreten, aber nicht hier zu bleiben, es sei denn, es wurde
ein Paar gefunden. In anderen Sprachen könntest du
das stattdessen mit einer
Do-Wile-Schleife machen Wenn wir ein Paar finden, können
wir die Variable auf true setzen dann auch aus
beiden Schleifen ausbrechen und die While-Schleife zurücksetzen Wenn beide vier Schleifen abgeschlossen sind, ohne dass
ein passendes Paar
gefunden wurde, ist das gefundene Paar falsch und
die While-Schleife wird unterbrochen Wir können unsere
Simulation wiederholt ausführen und sehen, dass keine Hand unserer Spieler jemals
passende Paare enthält
und die Spieler bereit sind, ihr
Spiel Old Maid zu spielen In der nächsten Lektion werden wir eine andere Form
der Flusskontrolle
verwenden Wir sehen uns in der nächsten Lektion.
8. 0-7 Match und Return: Hallo Freunde. Heute werden wir eine andere Form der Flusskontrolle , um komplexe Bedingungen zu vereinfachen. Ich habe bereits ein Skript mit dem Namen
months erstellt
und die Basisknoten-Definition
der Ready-Funktion Beginnen wir damit, eine Variable für den
aktuellen Monat zu
deklarieren und sie auf
Januar und eine zweite Variable für
die Anzahl der
Tage im Monat festzulegen Januar und eine zweite Variable , die standardmäßig auf Null gesetzt
wird Wir können einen einfachen
Satz ausdrucken, der besagt, dass die Anzahl der Tage
im Januar 31 ist Aber zuerst wollen wir unsere Variable
mit der Anzahl der Tage
füllen , die auf dem Wert des Monats
basiert Schreiben wir also eine Funktion
, die genau das kann. Weisen Sie die Anzahl der
Tage im Monat zu, die von einer
Funktion zurückgegeben
werden sollen,
die wir schreiben werden und die den
Monat als Argument akzeptiert. Um dieser Funktion
eine Definition zu geben den Monat als
Parameter vom Typ Zeichenfolge zu
akzeptieren, benötigt
sie auch eine weitere
Information , einen Rückgabetyp. Der von
einer Funktion zurückgegebene Wertetyp wird hinter
den Klammern mit einem Bindestrich
und einem größeren Lansinn in einem Pfeil definiert den Klammern mit einem Bindestrich
und einem , gefolgt vom In diesem Fall handelt es sich um eine Ganzzahl, die die Anzahl
der Tage im Monat
darstellt Wenn wir keinen Rückgabetyp angeben
, der Rückgabetyp für jede Funktion ist
der Rückgabetyp für jede Funktion, die
wir schreiben, standardmäßig Null. Innerhalb unserer Funktion
müssen wir eine Ganzzahl zurückgeben, was bedeutet, dass wir
eine Ganzzahl über ihr deklarieren sollten , und sie muss die
Anzahl der Tage im Monat enthalten. Dann geben
wir am Ende
der Funktion den Wert zurück, der in
dieser Variablen enthalten ist. Zwischen diesen beiden Zeilen müssen
wir
unsere Variable mit
der richtigen Anzahl von
Tagen basierend auf dem Monat auffüllen der richtigen Anzahl von
Tagen basierend auf dem Monat Wenn der Monat Januar ist, dann ist die Anzahl der Tage 31. Wir haben bereits erfahren
, dass wir
mit dem Schlüsselwort se eine Alternative
anbieten können , aber das bietet uns nur zwei der 12 Optionen,
die wir benötigen. Wir können ein anderes Schlüsselwort verwenden, if, kurz für se if, um
eine weitere Bedingung anzugeben , die
überprüft wird , ob die ursprüngliche
Bedingung falsch war. Wenn der
Monat also Februar ist, dann ist die Anzahl der Tage 28. Und wir können das so
oft wiederholen, wie wir müssen, für
jede Möglichkeit ein Argument
liefern. Viele dieser Optionen
führen jedoch zum gleichen Ergebnis, entweder 30 Tage oder 31 Tage. Wir könnten
die Effizienz dieser
IF-Anweisung erheblich verbessern , indem wir
das häufigste Ergebnis,
31 Tage als
Standardfall, kombinieren 31 Tage als und ersetzen am Ende alle
durch
ein einziges anderes
Schlüsselwort Wenn der Monat also nicht Februar
oder irgendein Monat mit 30 Tagen ist , dann muss die Anzahl der
Tage 31 sein Alle Fälle, die zu 30 Tagen führen
, können auch
mit dem Operator or zu einer einzigen Aussage
zusammengefasst werden . Wenn der Monat September ist oder wenn der Monat April ist oder
wenn der Monat Juni ist, oder wenn der Monat November ist, dann ist die Anzahl der Tage 30. Aber die Aussage ist bei mehr Fällen ziemlich
lang, sie könnte vom Bildschirm verschwinden. Für einfache, fallweise
Anweisungen wie diese gibt es ein klareres
und einfacher zu verwendendes Schlüsselwort als die
I-Anweisung namens match. Match folgt
der Name einer Variablen,
ein Doppelpunkt und dann ein
eingezogener Codeblock Innerhalb eines Match-Blocks können
wir eine beliebige Anzahl von
Sonderfällen für den
Wert der Variablen angeben Sonderfällen für den
Wert der Variablen Fangen wir mit Februar an. die Groß- und Kleinschreibung folgen außerdem ein Doppelpunkt und ein
weiterer eingezogener Codeblock Dieser Code wird nur ausgeführt wenn der Wert des
Monats Februar ist Wir können Fälle
in einer durch Kommas getrennten Liste zusammenfassen. So lässt
sich die
Bedingung, dass wir nur noch eine
Liste von vier Monaten angeben, zusammenfassen Wenn der Wert des Monats
September, April, Juni
oder November ist, dann wird die Anzahl
der Tage auf 30 gesetzt, und unser Block kann durch
einen Platzhalter ersetzt
werden , der durch einen Unterstrich dargestellt
wird, wodurch die Anzahl der Tage auf 31
gesetzt wird, falls der Wert
des Monats etwas
anderes ist, das oben nicht angegeben wurde Dies entspricht der Verwendung der
Standardeinstellung in anderen Sprachen. Jeder dieser
Codeblöcke wird als Branches bezeichnet. Und im GD-Skript führt eine
Match-Anweisung
immer nur den
obersten Zweig , dessen Bedingung erfüllt wurde In anderen Sprachen
ähnelt dies einer
Switch-Anweisung, unterscheidet sich
jedoch darin, dass
Switch-Anweisungen mehr als einen Zweig
ausführen können mehr als einen Zweig
ausführen wenn mehrere Bedingungen erfüllt sind Aufgrund dieser Einschränkung ist
es nicht erforderlich, Unterbrechungen in Match-Verzweigungen einzufügen. Wenn wir
die Anzahl der Tage
in jedem Monat ausdrucken wollten , würden
wir wahrscheinlich eine Schleife verwenden
wollen,
aber wir können
eine Zeichenfolge wie Januar nicht einfach
zählen oder inkrementieren , sodass sie
irgendwie Februar wird Daher ist es im Code üblich
, Dinge, die
in
einer sequentiellen Reihenfolge existieren, in
eine nummerierte Liste
aufzunehmen, die als , Dinge, die
in
einer sequentiellen Reihenfolge existieren, in eine nummerierte Liste
aufzunehmen, Aufzählung bezeichnet wird Eine Aufzählung im GD-Skript ist nur eine Gruppe verwandter Konstanten Wir könnten eine Konstante für
Januar mit einem Wert von eins haben, andere für Februar mit
einem Wert von zwei usw. Aber mit dem Schlüsselwort Enum können
wir die
Gruppe von Konstanten benennen, sie Monate
gefolgt von geschweiften Innerhalb der geschweiften Klammern können wir die Konstanten
gruppieren und ihnen wird jeweils
automatisch eine Zahl zugewiesen , die auf ihrer
Position in dieser Liste basiert Alles, was
in den geschweiften Klammern enthalten , muss
nicht in einer Zeile
bleiben und kann in ein
beliebiges Format aufgeteilt werden , um es
lesbarer zu machen Einrückungen spielen hier keine Rolle, aber wenn
etwas in geschweiften Klammern geschrieben wird, ziehen die
meisten Programmierer normalerweise den Inhalt ein
, sodass es Ich bevorzuge zwar, dass die geschweiften Klammern
vertikal angeordnet sind, aber
viele Programmierer ziehen es vor, die öffnende Klammer so in
die Deklarationszeile zu setzen öffnende Klammer so in
die Deklarationszeile Genau wie bei Constance werden
Aufzählungseinträge üblicherweise Da wir nun eine Aufzählung haben, kann
der Monat auf den Typ dieser Aufzählung
beschränkt werden Typ dieser Aufzählung
beschränkt Wir können ihm auch einen
Wert aus der Aufzählung zuweisen, beginnend mit seinem Namen,
gefolgt von einem Punkt dann dem Eintrag in der Liste Der Monat, der an
die Zeichenkettenausgabe angehängt wird, ist selbst keine Zeichenfolge mehr und muss in eine Zeichenfolge
umgewandelt werden , bevor
er angehängt werden kann Das Argument, das an
die Anzahl der Tage übergeben wird , ist keine Zeichenfolge mehr , sondern ein Monat, und wir können unsere Funktion so ändern ein Monat als
Parameter
akzeptiert Da Monat jetzt ein
Monat und keine Zeichenfolge ist, müssen
wir
unsere Bedingungen so ändern, dass sie übereinstimmen indem wir den Namen der Aufzählung
gefolgt von einem Punkt dann die Einträge in der Liste Aber wenn wir die Ergebnisse
ausdrucken, sehen
wir, dass
unser Monat nicht als Januar, sondern als Zahl Null geschrieben wird Der Typ unserer
Variablen ist zwar ein Monat,
also eine Aufzählung, der tatsächliche Wert wird als Ganzzahl
behandelt, seine Position innerhalb
der Aufzählung Da Januar
der erste Eintrag ist, ist
sein Wert als Ganzzahl Null Februar wäre
eins und so weiter. Auf diese Weise können wir
den Wert des Monats mit
einfacher Arithmetik ändern , sodass aus Januar plus eins Wenn wir diesen Code in eine
Schleife einbinden, die sich 12 Mal wiederholt, können
wir problemlos durch
alle 12 Monate iterieren Aber wie wäre es, den
Namen des Monats als Zeichenfolge zu schreiben? Wir könnten das auf
verschiedene Arten tun. Unser Aufzählungstyp hat
eine Eigenschaft namens keys, bei der es sich um alle unsere Einträge
als ein Array von Zeichenketten Wenn wir dieses Array
mit unserer Integer-Variablen indizieren
, erhalten wir den Eintragsnamen als Zeichenfolge
, die dieser Zahl entspricht Aber wenn wir uns an die Namenskonvention für
Großbuchstaben halten, möchten wir den Namen vielleicht nicht auf diese Weise
ausdrucken. Wir könnten stattdessen all
unsere Aufzählungsschlüssel in
Pascal-Groß- und Kleinschreibung umbenennen , oder wir könnten eine
Konstante deklarieren ,
die das Array von Zeichenketten enthält all unsere Monatsnamen in einem besser lesbaren Format enthält. Verwenden Sie dann den Monat als
Index für dieses Array. Eine andere Sache, die wir
mit Aufzählungen tun können, ist die Werte der Einträge
manuell mit
dem
Zuweisungsoperator festzulegen Einträge
manuell mit
dem
Zuweisungsoperator Nehmen wir an, wir möchten
, dass der Januar eins statt Null ist. Bei den übrigen Einträgen
werden die Werte automatisch aktualisiert, sodass der Wert von eins
erhöht wird, sodass der Februar jetzt zwei ist Dies entspricht jedoch nicht mehr
den konstanten Array-Indizes. Wenn wir
dies also verwenden wollten , um den
Namen der Monate zu schreiben, müssten
wir entweder
einen leeren Eintrag für den Index Null hinzufügen oder einen vom Monat
subtrahieren, der Indexierung des Arrays verwendet
wird In der nächsten Lektion
erfahren wir mehr darüber, wie die Engine unsere Skripte verwendet und
ausführt Wir sehen uns in der nächsten Lektion.
9. 0-8 Szenenbaum und Vererbung: Hallo Freunde. Heute erfahren
wir wie die Engine den
Szenenbaum verwendet, um unsere Skripte auszuführen. Ich habe noch
kein Skript an den
Stammknoten des Szenenbaums angehängt , aber wir beginnen diese
Lektion stattdessen damit, weitere Knoten hinzuzufügen. rechten Maustaste auf den Stammknoten wählen Sie
dann „Untergeordneten Knoten hinzufügen“ aus, immer noch ein normaler Knoten Wir können ihn in Präsident umbenennen und ist.
Wir können ihn in Präsident umbenennen und
so tun, als ob unser Szenenbaum
die Struktur eines Unternehmens darstellt Der Präsident-Knoten ist eingerückt , weil er ein untergeordnetes Element des Stammknotens
der Szene ist Wenn ein Knoten ausgewählt ist, können
wir auch
die Tastenkombination Strg
A oder Befehl A verwenden , um einen weiteren untergeordneten Knoten hinzuzufügen Nennen wir diesen einen
Operations Manager, und er hat
eine andere Ebene, weil er
ein Kind des Präsidenten ist Lassen Sie uns nun ein neues Skript an
den President-Knoten anhängen und es Employee nennen Wenn wir die
Basisknoten-Definition der
Ready-Funktion außer Kraft
setzen, können wir einfach den Namen
dieses Knotens ausgeben und append ist Dieses Skript kann an mehr als einen
Knoten angehängt werden. Lassen Sie uns also dasselbe Skript
an den Operations
Manager-Knoten anhängen , indem wir es von
der Registerkarte Dateisystem in
den Szenenbaum ziehen der Registerkarte Dateisystem in
den Szenenbaum Führen Sie dann die Szene aus
, um zu sehen, was passiert. Wir können sehen, dass der
Betriebsleiter bereit ist, dann ist der Präsident bereit. Beide Knoten, an die das Skript
angehängt ist, führen das Skript aus, und da sie
unterschiedliche Namen haben, war
die Ausgabe unterschiedlich. Wir können auch sehen, dass
der Betriebsleiter bereit
war, bevor der
Präsident bereit war. Um zu verstehen, warum wir mehr Mitarbeiter einstellen
müssen. Der Betriebsleiter wird eine Reihe von Betreibern
beaufsichtigen Ich füge dem Operations Manager einen weiteren untergeordneten Knoten hinzu und nenne ihn Operator One Hängen Sie dann das Mitarbeiterskript an. Wir können mit der rechten Maustaste
auf einen beliebigen Knoten außer
dem Stammknoten klicken und
Duplizieren auswählen , um
eine Kopie davon zu erstellen. Der Name der Duplikate wird automatisch um
eine steigende Zahl
erweitert, sodass wir Operator zwei, drei und vier usw. verwenden können Da an den Knoten, den wir dupliziert haben, ein Skript angehängt
war, ist an die erstellten Kopien auch
dasselbe Da die Operatoren
dieselbe
Einrückungsebene haben und alle dem
Operations Manager untergeordnet sind, werden
sie als Geschwister bezeichnet, und Geschwister dürfen
nicht denselben Namen haben Unser Unternehmen sollte
mehr als eine Abteilung haben. Lassen Sie uns
also die
gesamte Betriebsabteilung duplizieren, indem wir den
Betriebsleiter duplizieren Alle untergeordneten Knoten
sind ebenfalls dupliziert. Da es sich bei den Operatoren
nicht um direkte Geschwister handelt, dürfen
sie
ihre ursprünglichen Namen behalten Benennen wir den Manager in Marketingmanager
um, und dann werden
nur noch zwei Marketingexperten in seinem Team
arbeiten Übergeordnete Knoten können
auch ausgeblendet werden, um ihre untergeordneten Knoten
auszublenden, oder
erweitert werden, um sie anzuzeigen. Allen Mitarbeitern
dieses Unternehmens
ist dasselbe
Mitarbeiterskript beigefügt. Lassen Sie uns also die Szene durchspielen und uns
ein besseres Bild von der Reihenfolge ,
in der die Skripte ausgeführt
werden. Wir können sehen, dass der erste Operator
der erste ist, der bereit ist, gefolgt von jedem
Operator der Reihe und schließlich der
Operations Manager. Das Gleiche gilt für die
Marketingabteilung. Dann ist endlich der Präsident
des Unternehmens der
letzte, der bereit ist. Wie entscheidet Gadot über
diese Hinrichtungsreihenfolge? Die Engine startet am oberen Rand
des Szenenbaums und
arbeitet sich nach unten vor, betrachtet
aber keinen Knoten als
bereit , bis alle untergeordneten
Knoten bereit sind Der Präsident ist also
nicht bereit, weil der
Betriebsleiter nicht bereit ist. Der Betriebsleiter ist nicht bereit, weil die
Bediener nicht bereit sind. Die Bediener sind nacheinander
bereit, da sie keine Kinder haben. Sobald alle
Bediener bereit sind, ist der
Betriebsleiter bereit. Aber der Präsident
ist immer noch nicht bereit, weil der Präsident noch ein
Kind hat, das noch nicht bereit ist. Der Marketingmanager war erst bereit, als alle
Marketingfachleute bereit waren, und schließlich
ist der Präsident der Letzte, der bereit Da an den Stammknoten
kein Skript angehängt ist, entspricht seine Bereitschaftsfunktion der eines Standardknotens, der leer ist Neben Ready gibt es noch
andere Funktionen von Node, die wir überschreiben
können, damit sie
später ausgeführt werden, wenn ein Node bereit ist. Am gebräuchlichsten ist ein Prozess, ebenfalls
ein Unterstrich vorangestellt Die Engine versucht
ihr Bestes, um
die Prozessfunktion
jedes Knotens im Szenenbaum 60 Mal pro
Sekunde unter Verwendung
der standardmäßigen
Projekt-Framerate auszuführen die Prozessfunktion
jedes Knotens im Szenenbaum 60 Mal pro
Sekunde unter Verwendung
der standardmäßigen
Projekt-Framerate Daher verwendet der Prozess einen
Parameter namens Delta, bei dem es sich um eine
Fließkommazahl handelt, die die Anzahl der Sekunden angibt, die seit dem vorherigen Frame
vergangen sind. In den meisten Fällen wird es also ein Sechzigstel
sein, aber nicht immer. Wir brauchen diesen
Parameter heute für nichts zu verwenden, also können wir dem Namen dieses Parameters
einen Unterstrich hinzufügen, damit Gudo weiß, dass wir ihn nicht brauchen und uns nicht darum kümmern
sollten Aber um
die Prozessfunktion zu überschreiben, muss
sie dieselbe Anzahl
und dieselbe Art von Parametern haben Lassen Sie uns unseren Mitarbeitern sagen, dass sie in jedem Frame etwas Arbeit
erledigen sollen, indem eine Erklärung
ausdrucken, in der steht, dass ihr Name
an funktioniert Beim Betrachten dieser Szene stellen wir fest, dass alle unsere Mitarbeiter sehr hart
arbeiten ihre Kontoauszüge
60 Mal pro Sekunde
schreiben Das ist nicht dasselbe wie eine
Endlosschleife, denn die Arbeit wird tatsächlich so erledigt, wie sie beabsichtigt
ist, und
nichts ist kaputt. Lassen Sie uns das
etwas
verständlicher machen, indem wir jedem Mitarbeiter nur
erlauben, Arbeitseinheit mit
einer Bolan-Variablen zu
erledigen , hat Arbeit mit dem
Standardwert False
erledigt der Mitarbeiter in der Prozessfunktion Wenn der Mitarbeiter in der Prozessfunktion keine Arbeit verrichtet
hat, erledigt er
seine Arbeit und
ändert den Wert auf „Wahr“ Eine 60stelsekunde später, da die Variable wahr ist, werden
sie nicht mehr arbeiten. Wenn wir diese Variable jedoch
innerhalb der Prozessfunktion deklarieren , dann existiert sie nur innerhalb der Prozessfunktion und nur für eine einzige
Iteration derselben Im nächsten Frame, wenn die Prozessfunktion zum zweiten Mal
ausgeführt wird, wird
die Variable
erneut deklariert und hat immer noch den
Standardwert False Das wird also keine Wirkung haben. Damit unsere Variable bestehen bleibt, muss
sie außerhalb des Kontextes
der
Prozessfunktion existieren des Kontextes
der
Prozessfunktion Also deklarieren wir sie außerhalb der Funktion
ohne Einrückung hier deklarierte Variablen kann überall
im gesamten Skript
zugegriffen werden überall
im gesamten Skript
zugegriffen Dieses Konzept wird als
Bereich bezeichnet und ist einer
der Hauptgründe, warum wir Einrückungen
in unseren Skripten verwenden So können wir sehen, welche Variablen in welchem Bereich
existieren. Wenn wir die Szene jetzt betrachten, können
wir sehen, dass jeder
unserer Mitarbeiter erklärt, dass
er bereit ist zu arbeiten Erst wenn
alle bereit sind, erledigen
sie jeweils eine Arbeitseinheit, aber jetzt in einer anderen Reihenfolge Die Reihenfolge, in der Knoten
und der Szenenbaum
ihre Prozessfunktionen ausführen , folgt der exakten Reihenfolge des
Szenenbaums von oben nach unten. Eltern müssen nicht wie bei der Bereitschaftsfunktion
auf
ihre Kinder warten . Möglicherweise möchten wir, dass alle Mitarbeiter unseres
Unternehmens ähnlich
, aber nicht
genau gleich sind. Die Arbeit eines Managers ist nicht wirklich die gleiche wie
die eines Arbeiters. Wir können Vererbung verwenden, um
unterschiedliche Verhaltensweisen
für ähnliche Objekte zu erzeugen . Auf die gleiche Weise schreiben wir
Skripte, die den Knoten erweitern, aber ändern, wie sie
vorbereitet werden und wie sie verarbeitet werden. Zuerst müssen wir diesem Skript
einen Namen
geben, den wir als Referenz
verwenden können, das Schlüsselwort classname
verwenden, gefolgt von einem Namen, der das Verhalten
des Skripts
beschreibt, normalerweise derselbe wie
der Skriptname, aber in
Pascal-Großbuchstaben geschrieben die Engine nun weiß, dass es sich um einen Mitarbeiter
handelt, erstellen
wir ein neues Skript
und geben diesem einen Namen Manager Aber anstatt vom Knoten
zu erben, können wir
dieses Mal vom Mitarbeiter
erben Da unser
Manager-Skript die Erweiterung Employee erweitert, gilt
alles, was
im Employee-Skript
steht , auch für dieses Skript, aber wir können weitere hinzufügen
oder Änderungen vornehmen Ein Manager ist immer noch ein Angestellter, aber die Art und Weise, wie er
arbeitet, ist anders. Wir sollten das an
unsere Manager-Knoten angehängte
Skript durch
das neue Manager-Skript ersetzen . Lassen Sie uns die
Definition der
Ready-Funktion durch den Mitarbeiter überschreiben . Wenn also ein Manager bereit ist, wird er nicht nur
sagen, dass er bereit ist, sondern er wird auch sagen, dass seine
gesamte Abteilung bereit ist. Damit unsere beiden
Manager den Namen
ihrer Abteilungen ausgeben
können, benötigen
sie eine
Variable,
die den Namen ihrer
Abteilung als Zeichenfolge enthält. Aber wie können wir diese Variable so
auffüllen , dass sie unterschiedliche Werte
für verschiedene Abteilungen enthält? Wenn wir unsere
Variablendeklaration
mit dem Tag beim Export fortsetzen , diese Variable andere Teile
der Gadot-Engine auf
diese Variable
zugreifen,
nämlich das Inspektor-Panel Damit eine Variable
exportiert werden kann, muss
sie auf
der Ebene des Skriptbereichs deklariert werden Wenn Sie den Operations
Manager und die Szenerie auswählen, gibt es jetzt ein Feld im Inspektorfenster, in
dem wir der
Abteilungsvariablen einen Zeichenkettenwert geben können Auf diese Weise
können der Betriebsleiter und der Marketingleiter und der Marketingleiter jeweils ihren
eigenen Wert für
diese Variable haben , den wir leicht kontrollieren
können die Szene ausführen, können wir sehen,
dass die Knoten, die das Skript des Managers angehängt ist,
jetzt deklarieren, dass ihre
Abteilung bereit ist, während die anderen
Mitarbeiter alle
die vorherige Definition
im Mitarbeiterskript verwenden . Die Prozessfunktion im
Mitarbeiterskript wird ebenfalls von den Managern
übernommen und
wird genauso ausgeführt wie zuvor. Lassen Sie uns also die Prozessfunktion unseres
Managers ändern. Manager werden
etwas anderes sagen. Name Plus leitet die Mitarbeiter
dazu, ihre Arbeit zu erledigen. Die Variable hat Arbeit erledigt
aus dem Mitarbeiter-Skript wurde ebenfalls übernommen und muss
hier
nicht deklariert werden, um verwendet zu werden. Tatsächlich können wir keine
Variable mit diesem Namen deklarieren, da dies zu einem Konflikt mit
der geerbten Variablen
desselben Namens führen würde . Lassen Sie uns die Szene
noch einmal durchspielen und sehen, wie unsere Manager
ihre Arbeit jetzt
anders machen als andere Mitarbeiter. In der nächsten Lektion erfahren wir
mehr über die Verwendung von Knoten im Szenenbaum und über
die Prinzipien der
objektorientierten Gestaltung. Wir sehen uns in der nächsten Lektion.
10. 0-9 Abstraktion und Verkapselung: Hallo Freunde.
Heute werden wir untersuchen ,
wie man Klassen schreibt, die
einfacher zu verwenden und zu verstehen sind . Stellen Sie sich ein Auto als
Referenzrahmen vor. Lassen Sie uns zwei
Knoten in unserer Szene erstellen, einen Fahrer und ein Auto als
Kind des Fahrers Hängen Sie dann jeweils ein neues Skript
mit demselben Namen an. Autos sind sehr komplexe
Maschinen,
und die meisten Menschen, die sie fahren, haben keine Ahnung, wie
sie tatsächlich funktionieren. Sie verstehen nur, wie
man ihr Auto bedient. Beginnen wir mit dem Auto-Skript und geben ihm den Klassennamen Auto Fügen wir
dann eine Variable für das Jahr des
Autos als Ganzzahl hinzu. Eine weitere für die
Marke des Autos als Zeichenfolge und
eine weitere für
das Modell, ebenfalls als Zeichenfolge. all das exportiere, werde
ich mein Auto auf
einen Honda Civic von 2007 einstellen. beim Erstellen einer neuen Klasse
darauf, das Skript zu speichern,
bevor Sie versuchen, es zu verwenden. Im Treiberskript benötigt
der Fahrer einen
Verweis auf das Auto
, den wir in einer
Variablen vom Typ Auto speichern können. Knoten können auf andere
Knoten im Szenenbaum zugreifen.
Meist verwenden ihre untergeordneten Knoten
ein anderes Tag, Meist verwenden ihre untergeordneten das dem
Export ähnelt, der auf ready aufgerufen wird. Mit dem Tag on ready können
wir den
Variablenwert zuweisen, nachdem der Knoten bereit ist,
was bedeutet, dass alle seine
untergeordneten Knoten ebenfalls bereit sind, aber bevor die
Ready-Funktion dieses Knotens aufgerufen wird. Wir können ihn
dem Rückgabewert
eines eingebauten Funktions-G-Knotens zuweisen , der einen
Knotenpfad als Parameter akzeptiert. Wenn wir den Namen
des untergeordneten Knotens in
Anführungszeichen angeben , haben
wir jetzt einen Verweis auf den untergeordneten Knoten, der
in einer Variablen gespeichert ist, und wir können auf seine
Eigenschaften und Funktionen zugreifen, einschließlich
der Eigenschaften und Funktionen im angehängten Skript. Wenn wir die Definition
der Ready-Funktion außer Kraft
setzen, können wir auf den Fahrzeugknoten zugreifen und dessen
Jahr, Marke und Modell ausdrucken Die Ready-Funktion wird
nach den On-Ready-Tags ausgeführt. gibt es eine Abkürzung für dies
zu vereinfachen, gibt es eine Abkürzung für
die Funktion get node das Dollarzeichen,
gefolgt von demselben Knotenpfad. Gehen wir zurück
zum Car-Skript und
fügen eine weitere Variable hinzu. Diese gibt als boolescher Wert an, ob der Motor
läuft oder nicht Als Fahrer wissen wir, ob
der Motor läuft, und wir haben die Kontrolle darüber, ob der
Motor läuft oder nicht, da wir mit dem Schlüssel wählen können, ob der Motor gestartet oder
gestoppt werden soll mit dem Schlüssel wählen können, ob der Motor gestartet oder
gestoppt Wir würden diese
Variable also als öffentlich betrachten. Eine weitere Eigenschaft unseres
Autos könnte die Anzahl der Zylinder im
Motor als Ganzzahl sein, und ich weise ihr
einen Wert von vier zu. Dies ist etwas, das der
Fahrer nicht wissen muss, nicht einfach darauf zugreifen
kann und niemals ändern
darf. Im Gegensatz zur öffentlichen Variablen würde
diese Variable also als privat betrachtet werden, und wir können sie als privat kennzeichnen, indem wir ihrem Namen
einen Unterstrich hinzufügen Im Treiberskript können wir den Wert von Engine is
on auf true
setzen , indem wir
den Schlüssel in die Zündung stecken und sie drehen Aber zuerst sollten wir das Bremspedal
drücken. Lassen Sie uns eine Funktion verwenden, um den
Druck einzustellen ,
der auf
das Bremspedal wird. Wir gehen davon aus, dass er bis zu einer maximalen Kraft von 20
Kilogramm beträgt. Um unser Auto zu starten, sollten
wir also
den Bremsdruck wahrscheinlich auf
etwa 10 Kilogramm einstellen . Zurück im Auto-Skript müssen
wir
diese Funktion definieren, müssen
wir
diese Funktion definieren die
den Bremsdruck einstellt. ob die Engine auf einer Variablen steht, würde man
dies
als öffentliche Funktion bezeichnen, da sie
von einem anderen Skript verwendet wird. Diese Funktion akzeptiert
eine Fließkommazahl als Parameter,
der
angibt, wie viel Druck auf das Pedal
ausgeübt wird. Aber was macht das
Auto eigentlich wenn wir Druck
auf das Bremspedal ausüben? Aus Sicht
des Fahrers entscheidet sich
der Fahrer dafür, einen bestimmten
Druck
auf das Pedal auszuüben, ohne jemals die genaue Position zu kennen. Aus Sicht des Fahrzeugs wird
die Position des
Pedals gemessen und
verwendet, um das Auto anzuhalten. Das Auto verwendet die Position
des Bremspedals, um
den Druck einzustellen, der auf Bremssättel ausgeübt
wird, die Bremsbeläge an Bremssättel ausgeübt
wird, die den Rädern des Fahrzeugs
halten, ganz zu
schweigen von der Komplexität von Antiblockiersystemen
oder anderen Systemen Wenn wir also tatsächlich ein echtes Auto
programmieren würden, müssten
wir
hier
mehrere komplexe Funktionen schreiben ,
die die einfache Aktion des Fahrers, der
Druck auf
das Bremspedal ausübt, in die komplexe Mechanik
des Zusammendrückens der
Bremssättel umwandeln Fahrers, der
Druck auf
das Bremspedal ausübt, in die komplexe Mechanik
des Zusammendrückens der
Bremssättel komplexe Mechanik
des Zusammendrückens der Das ist Teil der
internen Funktionen
des Fahrzeugs und nichts
, was für den Fahrer auf
andere Weise als
durch
Drücken auf das Bremspedal gesteuert
oder zugänglich ist Fahrer auf
andere Weise als
durch
Drücken auf das Bremspedal gesteuert
oder zugänglich andere Weise als Bremspedal Wir würden diese
Funktionen also als private Funktionen betrachten, da sie nur für die Nutzung
durch das Auto selbst bestimmt sind. Und wir können unsere
privaten Funktionen kennzeichnen indem wir ihre Namen
mit einem Unterstrich Beachten Sie, dass dies mit den Funktionen „Prozess“ und
„Bereit“ identisch Funktionen „Prozess“ und
„Bereit Die Art und Weise, wie GDScript
private Variablen und
Funktionen verwendet , ähnelt eher der Art und Weise, wie andere Sprachen geschützte Variablen und
Funktionen
verwenden , da sie für Erben
zugänglich sind GD Script
setzt diese Datenschutzbestimmungen
jedoch nicht wirklich durch, und Skripte können
weiterhin auf private Mitglieder zugreifen Diese Konventionen
dienen ausschließlich dazu, eine bessere
Klassenstruktur und ein besseres Design zu ermöglichen. Eine andere Möglichkeit,
Kommentare in GD Script zu verwenden ,
besteht darin, Bereiche unserer
Skripte zu erstellen, die miteinander verwandt sind Verwenden Sie dazu das Schlüsselwort region gefolgt vom
Namen der Region. Wir können eine Region mit
dem Schlüsselwort und der Region beenden. Lassen Sie uns also
in unserem Auto-Skript
eine
öffentliche Region und eine private Region erstellen und
trennen, was für den Fahrer
zugänglich sein soll und was nicht. Einfachheit halber an, Nehmen wir der Einfachheit halber an, der
Fahrer muss
nur in der Lage sein,
den Motor ein- oder auszuschalten,
Druck auf das Gaspedal
auszuüben, Druck auf
das Bremspedal auszuüben
oder das Lenkrad zu drehen. Was
in jeder
dieser öffentlichen Funktionen tatsächlich passiert , ist die interne Mechanik
des Autos selbst. Der Fahrer muss nicht wissen, wie das funktioniert,
um das Auto zu bedienen. Wenn
Sie zum Beispiel Gas geben, das
Auto tatsächlich öffnet
das
Auto tatsächlich ein
Lufteinlassventil am Motor, wodurch mehr
Luft und
Sauerstoff in den Motor gelangen. Das Auto muss also einen
Sensor verwenden, um die Menge des
Luftstroms und die Menge an
Sauerstoff zu messen Luftstroms und die Menge an , die jetzt in den Motor
fließt Verwenden Sie diesen dann, um die
Kraftstoffmenge
einzustellen , die in die Zylinder
des Motors eingespritzt wird All diese Funktionen
sind privat, da wir nicht wissen
müssen, was sie eigentlich tun, um das Auto fahren
zu können. Weise, wie sich
unser Auto bewegt, hängt von der Prozessfunktion ab, und wir benötigen eine weitere private
Variable namens phase, um darzustellen, in welcher
der vier Phasen sich
jeder Zylinder gerade befindet. In der Prozessfunktion des Autos können wir bei laufendem Motor jeden
Zylinder des Motors
iterieren Wenn wir den
Zylinder und die Phase zusammenzählen, dann Modul vier, erhalten wir für jeden Zylinder
eine andere Phase diese Zahl zuordnen,
können wir jedem Zylinder anweisen eine andere
Phase
durchzuführen, nämlich den Einlasstakt, Kompressionstakt, den
Verbrennungstakt oder den Auslasstakt, wobei jeder den
Zylinder als Argument akzeptiert Erhöhen Sie dann die Phase
und fahren Sie wieder auf Null zurück
, wenn sie vier erreicht. Jede dieser Funktionen kann dann die Einlassventile,
Auslassventile, Einspritzdüsen
und Zündkerzen jedes
Zylinders steuern , um den Motor laufen zu lassen Die Kraft, die durch die
Verbrennungstakte
jedes Zylinders
erzeugt wird durch die
Verbrennungstakte
jedes Zylinders
erzeugt , würde das Fahrzeug
dann
vorwärts bewegen , während die
Bremsbeläge versuchen, das Fahrzeug anzuhalten, und die Lenkradposition ihre Richtung
ändert Die Position des Fahrzeugs
würde dann durch die Richtung, Geschwindigkeit und Delta-Zeit verändert. Sie sich keine Sorgen, wenn
das alles für Sie keinen Sinn ergibt ,
denn genau
darum geht es in dieser Lektion. Du
musst es nicht verstehen. Da sich all dies im
privaten Bereich des Skripts befindet, muss
der Fahrer nicht wissen wie das alles funktioniert,
um das Auto fahren zu können. Sie müssen nur wissen, wie man den öffentlichen Bereich
des Skripts
benutzt. Durch die Trennung von öffentlich
und privat werden
zwei wichtige Prinzipien der
objektorientierten Programmierung durchgesetzt zwei wichtige Prinzipien der
objektorientierten Programmierung Kapselung ist
der öffentliche Bereich, Zugang zu
öffentlichen Variablen oder Funktionen ermöglicht, die einfach zu
verwenden und leicht zu verstehen sind, und Abstraktion ist
der private Bereich, in dem die Details
komplexer Systeme oder
Mechaniken
verborgen werden, die
nicht
verstanden werden müssen, um effektiv genutzt zu werden verstanden Sie werden wissen, ob Ihre
Kurse
diese Prinzipien einhalten , wenn
Sie alle privaten Inhalte verstecken können und trotzdem leicht verstehen, wie
sie verwendet werden sollen Unser Fahrer kann jetzt also das Fahren des Autos
simulieren indem er nur auf die öffentlichen
Bereiche des Autoskripts zugreift, vom Drücken der
Bremse und
dem Starten des Motors bis hin zum
Lösen der Bremse, dem
Drücken des Gaspedals,
dem Drehen des Lenkrads usw. Diese Prinzipien sind nicht nur für unsere eigenen Skripte
wichtig,
sondern ermöglichen es uns auch, Skripte zu
verwenden, die von
anderen Entwicklern geschrieben wurden , ohne vollständig verstehen, wie
sie intern funktionieren Sie machen
R-Skripte auch flexibler. Stellen Sie sich vor, wir würden unser Gasauto gegen
ein Elektroauto austauschen Müsste irgendwas im
Drehbuch des Fahrers geändert werden? Elektroauto-Skript
müsste nur das Für ein
Elektroauto-Skript
müsste nur das Auto-Skript geändert werden, da alle
öffentlichen Variablen und Funktionen weiterhin
im Elektroauto-Skript existieren würden. Ebenso könnten wir das Treiberskript in
ein Autopilot-Skript
umwandeln, dem lediglich
ein Ziel zugewiesen werden muss und das
Auto dann automatisch
bedienen kann In der nächsten Lektion werden
wir noch mehr
über die Prinzipien des objektorientierten
Designs lernen über die Prinzipien des objektorientierten
Designs Wir sehen uns in der nächsten Lektion.
11. 0-10-Polymorphismus: Hallo Freunde. Heute behandeln
wir das letzte Prinzip
der objektorientierten Programmierung, den Polymorphismus erweitern die Konzepte der
Vererbung und Abstraktion und können Klassen schreiben, Wir erweitern die Konzepte der
Vererbung und Abstraktion und können Klassen schreiben, die abstrakteres Konzept
repräsentieren,
eine Sammlung von spezifischeren
Klassen, die Lassen Sie uns Tiere als
Beispiel verwenden, indem wir
ein Skript mit dem Namen animal erstellen ,
das den Knoten erweitert, aber wir müssen
dieses Skript nicht an irgendwelche Knoten
im Szenenbaum anhängen dieses Skript nicht an irgendwelche Knoten
im Szenenbaum Hier können wir dem
Skript einen Klassennamen geben dann Eigenschaften und
Verhaltensweisen definieren , die allen Tieren
gemeinsam sind, wie eine Variable, die den Plural des
Tieres als Zeichenfolge enthält,
und eine weitere für den Namen
einer Gruppierung dieses Und lassen Sie uns auch eine
Funktion definieren, mit der sich das Tier bewegen, essen oder Wir können
den Plural von Tier zwar leicht als Tiere definieren , es gibt kein Wort für
eine Gruppe von Tieren Wir können auch nicht definieren,
wie sich ein Tier bewegt oder frisst, ohne zu wissen, um
welche Art von Tier es sich handelt Die Körper dieser
Funktionen können also leer bleiben. Wir könnten jedoch davon ausgehen, dass einige
Verhaltensweisen so häufig
vorkommen , dass sie
eine Standardeinstellung haben sollten, z. B. das Sprechen. Es gibt zwar viele
verschiedene Säugetiere , die eine
Vielzahl von Geräuschen machen, die meisten Tiere,
einschließlich Fische und Insekten, tun dies nicht einschließlich Fische und Insekten Die meisten Menschen würden sie nicht als sprechen
beschreiben. Wenn wir also einem
zufälligen Tier sagen, dass es sprechen soll könnten
wir das
Standardverhalten als Schweigen betrachten. Fügen wir also
verschiedene Tiere zu unserem Szenenbaum hinzu,
angefangen mit einer Katze. Wir können jetzt
wie zuvor Vererbung verwenden, um eine beliebige Anzahl
verschiedener Tierskripte zu erstellen , die von Tieren wie Katzen
erben Wir überschreiben dann
die Ready-Funktion , um den Variablen,
die von animal geerbt wurden,
einen Wert zu geben von animal geerbt wurden , der für eine Katze
geeignet ist Der Plural wäre Katzen, und eine Gruppe von Katzen
wird Clouder genannt Die Verhaltensfunktionen
können auch überschrieben werden um das Verhalten beim stillen
Sprechen in Miauen Katzen laufen auf vier
Beinen, um sich fortzubewegen, und ich würde sagen, dass sie Fisch fressen Der tatsächliche Inhalt
dieser Variablen und
Funktionen ist nicht relevant, aber der Schwerpunkt liegt darauf, wie
sie
vom abstrakten Konzept
eines Tieres
auf ein spezifischeres
Beispiel einer Katze vererbt werden vom abstrakten Konzept
eines Tieres
auf ein . Wir können diesen Vorgang wiederholen , um viele weitere
verschiedene
Tierarten zu erstellen , die wir unserem
Szenenbaum hinzufügen können, z. B. einen Vogel oder einen Fisch. Und indem sie jedem ein neues Skript geben, das von Animal
geerbt
wurde, können sie jeweils ihre
eigenen eindeutigen Werte für
die Variablen und
Implementierungen
der Funktionen angeben die Variablen und
Implementierungen
der , die sie Der Plural von Vogel ist Vögel. Eine Gruppe von Vögeln
wird Herde genannt. Sie fliegen, um sich fortzubewegen, fressen Würmer und
zwitschern, um zu sprechen Ich verschaffe mir einen Vorsprung
bei meinem Fish-Skript indem ich den Inhalt
des Cat-Skripts kopiere Und der Plural von Fisch ist Fisch Eine Gruppe von Fischen wird Schule
genannt. Sie schwimmen, um sich fortzubewegen, sie fressen Algen, aber
sie sprechen nicht. Wenn die Sprechfunktion weggelassen wird, verwenden
Fische die
ererbte Definition aus der
Tierschrift zum Bisher haben wir nur
die objektorientierten Prinzipien verwendet, die wir bereits kennen, um die Eigenschaften
und Verhaltensweisen von Tieren zu erben, zu
abstrahieren
und wir bereits kennen, um die Eigenschaften
und Verhaltensweisen von Tieren zu erben, zu
abstrahieren
und zusammenzufassen. All dies ermöglicht es uns jedoch, Polymorphismus
zu verwenden, indem alle Tiere so
behandeln, als ob sie wir alle Tiere so
behandeln, als ob sie
gleich und austauschbar wären. Zuerst fügen wir dem Wurzelknoten
unserer Szene ein Skript
hinzu und nennen es Zoo, das vom Knoten erbt Unser Zoo ist voller
verschiedener Tiere, aber es spielt keine Rolle, um
welche Tiere es sich tatsächlich handelt wir die Definition
der Ready-Funktion für unseren Zoo außer Kraft
setzen, können wir ganz einfach unsere Tierliste
durchgehen und
sie alle so behandeln, als ob sie nur
Tiere wären Eine schnelle und einfache
Möglichkeit, all
unsere Tiere in
einer einzigen Variablen zu speichern unsere Tiere in
einer einzigen Nennen wir es Tiere, indem wir
eine Funktion des Knotens
namens Get children verwenden . Dies gibt ein Array von Knoten zurück, wobei alle untergeordneten Knoten
dieses Knotens praktischerweise in derselben Reihenfolge
wie der Szenenbaum
in einem Array
angeordnet sind. Da dies von den
untergeordneten Elementen abhängt, müssen
wir das Tag bei on ready verwenden. Da wir wissen, dass
alle Tiere
dieselben Eigenschaften
und Verhaltensweisen haben , können
wir
jedes Tier in unserer Tiergruppe wiederholen und jedem
Tier sagen, dass es sprechen soll Und obwohl
sie alle wie Tiere behandelt werden, spricht
jedes auf seine
eigene Art und Weise, wie es in
seinen eigenen
Skripten definiert ist, oder verwendet die vom
Tier übernommene Definition , wenn es
keine eigene hat Wir können so viele
Vererbungsstufen schaffen , wie wir möchten. Lassen Sie uns also ein weiteres
abstraktes Skript
für Säugetiere erstellen , die
vom Tier erben Säugetiere sind eine
Unterkategorie von Tieren, zu denen alle Tiere
gehören, die
Brustdrüsen haben und
diese zum Stillen ihrer Jungen verwenden. Dies sind einzigartige Eigenschaften
und Verhaltensweisen von Säugetieren, die auf andere Tiere nicht
zutreffen So können wir
dem Säugetier-Skript eine neue Variable
für die Anzahl der
Brustdrüsen dieses Tieres hinzufügen dem Säugetier-Skript eine neue Variable
für die Anzahl der Brustdrüsen dieses Tieres und
eine neue
Funktion namens Krankenschwester schreiben Auch hier ist der Inhalt
der Funktionen für diese Lektion nicht
relevant Dieses Skript
benötigt außerdem einen Klassennamen um
vererbt zu werden. wechseln
zum Katzen-Skript, da Katzen Säugetiere sind, und so können wir der
Anzahl der Brustdrüsen für Katzen
einen Wert geben , der acht sein sollte Und wir können unserem Zoo auch neue
Säugetiere hinzufügen, wie einen Affen Affen sind auch Säugetiere, aber sie haben nur
zwei Brustclans Ich
kopiere noch einmal den Inhalt eines anderen Skripts, um die Dinge
zu beschleunigen Der Plural von Affen ist Affen. Eine Gruppe von Affen
wird Truppe genannt. Sie bewegen sich, indem sie auf Bäume klettern. Sie essen Bananen und ich
sage, sie sagen oh. Unser Zoo-Skript kann nun diese neue
Vererbungsstruktur
nutzen , um einzigartige Bedingungen
speziell
für Tiere, die Säugetiere sind,
anzuwenden . Wir können
Klassennamen direkt in bedingten
Anweisungen verwenden , um zu sagen, dass ist wir zusätzlichen Code
ausschließlich für Säugetiere ausführen
werden ,
wenn das aktuelle
Tier ein Säugetier Ich drucke einfach ein
paar zusätzliche Zeilen aus die unsere Säugetiere beschreiben Und wir können sehen, dass unsere Ergebnisse sowohl für alle Tiere einheitlich sind, auch etwas Einzigartiges speziell für
die beiden Säugetiere bieten. Sie können sich vorstellen, wie wir unsere Liste der Tiere
in unserem Zoo so
ändern könnten , dass sie beliebige
Tierarten enthalten, und wir könnten unsere
Erbschaftsstruktur ändern um sie so
genau wie nötig zu kategorisieren In der nächsten Lektion lernen
wir
eine weitere Datensammlung kennen, mit der wir verwandte
Informationen gruppieren
können verwandte
Informationen gruppieren
können Wir sehen uns in der nächsten Lektion.
12. 0-11 Wörterbücher: Hallo Freunde. Heute werden wir eine Alternative
zu dem Array
verwenden, die manchmal wie eine Klasse
ohne Funktionen verwendet wird , die als Wörterbuch
bezeichnet wird. Stellen Sie sich eine Reihe von
Schließfächern vor, wie Sie sie in einer High
School oder einem Gymnasium finden
würden Wenn wir ein
Array von Variablen deklarieren, könnten
wir
den Array-Index jeder Variablen als die Zahl
der
Schließfächer betrachten jeder Variablen als die Zahl
der
Schließfächer Nehmen wir an, es gibt zehn Schließfächer, und wir können auf jedes
einzelne Schließfach zugreifen um etwas hineinzulegen, angefangen bei Schließfach Null, Eins usw. Was wir in jedes
Schließfach legen, spielt keine Rolle. Es kann sich um eine Ganzzahl, eine
Fließkommazahl, eine Zeichenfolge, booleschen Wert, eine Null oder eine
Instanz einer Klasse handeln Und wir können den Inhalt
der Schließfächer
ausdrucken , um sie zu sehen Stellen Sie sich nun vor, wenn wir etwas in
einen der Schränke
legen, schließen
wir nicht nur die
Tür des Schließfachs,
sondern befestigen auch ein Vorhängeschloss daran Dieses Vorhängeschloss benötigt Öffnen eine dreistellige
Zahlenkombination Bisher mussten wir, wenn wir den Inhalt
des Schließfachs
abrufen
wollten, den Inhalt
des Schließfachs
abrufen
wollten, nur die Nummer
des Schließfachs kennen, dorthin
gehen und den Inhalt
herausnehmen Jetzt können wir die Nummer des
Schließfachs ignorieren und müssen stattdessen die Kombination kennen, mit der das Vorhängeschloss
geöffnet Nehmen wir an, die
Kombination ist 149. Als Array würde die Zuweisung von
etwas zur Zahl 149 bedeuten, dass das Array 150 Schließfächer
haben müsste Wenn wir den Typ
unseres Arrays in ein Wörterbuch ändern würden , würde
das immer noch funktionieren,
außer dass wir keine Größe für das Wörterbuch festlegen
müssen Größe für das Wörterbuch bevor wir auf
seinen Inhalt zugreifen können Beachten Sie, wie sich die
Ausgabe geändert hat. Wörterbücher werden durch geschweifte
Klammern statt durch
eckige Klammern dargestellt , und jeder Eintrag ist eine Zahl, die einen Schlüssel
darstellt, gefolgt
von einem Wert dessen, was in dem durch diesen Schlüssel
gesperrten Schließfach
enthalten ist in dem durch diesen Schlüssel
gesperrten Schließfach
enthalten Das Wörterbuch enthält auch keine Einträge für Schlüssel, denen
kein Wert zugewiesen wurde Als Wörterbuch
ist diese Zahl weder ein Index noch eine Adresse. Es ist ein Schlüssel, mit
dem wir ein Schloss öffnen. Und so wie der Inhalt
des Schließfachs einen beliebigen Datentyp haben kann, können
die Schlüssel, die wir zum
Sperren verwenden, auch einen beliebigen Datentyp haben, mit Jeder Schlüssel muss einzigartig sein. Andernfalls können wir das Schließfach, das dem Schlüssel
entspricht, nicht finden. Versuchen wir also, ein Schließfach mit
einer
anderen Art von Schloss zu verschließen,
eines, das Buchstaben
anstelle von Zahlen verwendet. Der Schlüssel dieses
Wörterbucheintrags ist also eine Zeichenfolge, aber sein Wert ist eine Zahl. Das komplette Gegenteil
dieses Schließfachs, dessen Schlüssel eine Zahl
und dessen Wert eine Zeichenfolge ist. Sperren wir das nächste
Schließfach mit einem Drehschloss, dessen Entsperrung drei
Zahlen erforderlich sind, die wir in einem Array
speichern könnten. Unser Schlüssel für Wörterbucheinträge
ist also ein durch
eckige Klammern dargestelltes Array , das
eine durch Kommas getrennte Liste
von drei ganzen Zahlen enthält eine durch Kommas getrennte Liste
von drei ganzen Zahlen Vielleicht
enthält diese Schlossnummer einen Dezimalpunkt, der Schlüssel ist
also eine Und irgendwie ist dieses
Schließfach durch
Lichtempfindlichkeit verriegelt und kann nur geöffnet
werden, wenn das Licht aus Sein Schlüssel ist also ein boolescher Wert. Wir können sogar
benutzerdefinierte Klassen
entweder als Schlüssel oder als
Werte in Wörterbüchern verwenden entweder als Schlüssel oder als
Werte in Schreiben wir eine neue Klasse für Schlüssel, die von
nichts erben
muss , da sie
weder an einen Knoten
angehängt noch vererbt wird Unsere Schlüsselklasse benötigt einen Klassennamen und wird
eine Variable haben , die ihre Zähne
beschreibt Die Implementierung dieser
Klasse ist nicht relevant, aber wir können so tun, als wäre es ein Schlüssel Zurück im Locker-Skript können
wir eine Instanz
unseres Schlüssels in einer Variablen speichern Nennen wir es Schlüssel
eins vom Typ Schlüssel, indem es
dem Klassennamen des
Schlüssels
zuweisen . Nunu erzeugt einen neuen Schlüssel
, der unserer Variablen
zugewiesen wird Wir können diesen Schlüssel jetzt verwenden, um einen Eintrag im
Wörterbuch zu erstellen Wir können auch mehr Schlüssel erstellen
, um mehr Einträge zu erstellen. Da jeder Schlüssel, den wir erstellen, als einzigartig angesehen
wird. In der Ausgabe werden die Schlüssel nun
als Riffzählung
gefolgt von einer langen Zahl angezeigt . Die Namen, die wir in
anderen Klassen verwendet haben , wurden von Node
übernommen. Da der Schlüssel jedoch nicht vom Knoten
erbt,
hat er keinen Namen Ref Counted ist die Abkürzung für
Reference Counted Object und die
Basisklasse für GD-Skripte Wenn wir eine Klasse schreiben , die
von nichts erbt, erbt
sie von Reef
Counted und ihr wird eine zufällige lange Zahl zugewiesen Wir können das ignorieren
und einfach verstehen , dass es sich bei unseren Schlüsseln um Objekte mit
Referenzzählung handelt,
was bedeutet, dass Gadot
automatisch jede einzelne Instanz
jedes Objekts verfolgt jede einzelne Instanz
jedes Objekts Aber was wollen wir in den Schließfächern
aufbewahren? So wie Arrays andere Arrays
enthalten können, können Wörterbücher auch andere
Wörterbücher Entsprechend der Art und Weise, wie Wörterbücher gedruckt
werden, können
wir mithilfe von geschweiften Klammern im Handumdrehen unsere
eigenen Wörterbücher erstellen . Jeder Eintrag beginnt mit
einem Schlüssel, gefolgt von
einem Doppelpunkt und dann dem Wert
, der diesem Wörterbücher werden häufig nicht verwendet, um so etwas wie
dieses Locker-Szenario zu erstellen, sondern eher darin, so
etwas wie eine Klasse zu erstellen, wenn auch eine ohne
Funktionen, nur Variablen Nehmen wir an, dieser Schrank
enthält ein Plüschtier, das wir
mit einem Wörterbuch darstellen werden Und dieses Plüschtier
gehört zu einer Reihe von Plüschtieren zum
Sammeln, die sich
ähneln, aber auf ihre Art unterschiedlich
sind ähneln, aber auf ihre Art unterschiedlich Jedes der Plüschtiere ist eine andere Tierart
mit einer Farbe und einem Namen Jeder dieser
Schlüssel kann ein Schlüssel im Wörterbuch sein. Nehmen wir an, in diesem Schließfach
befindet sich Bruno, der Braunbär. Und das nächste Schließfach enthält
Arthur die weiße Ziege. Wir können unser
Wörterbuch Plüschtiere
im Wörterbuch der
Schließfächer sehen im Wörterbuch der
Schließfächer Zufällig ist Farbe auch eine bereits definierte
Klasse in Anstatt
unsere Farben also als Zeichenketten zu speichern, können
sie
unter Verwendung des Klassennamens color als Farben gespeichert werden Wie Sie sehen können,
gibt es viele vordefinierte Farben, die wir verwenden können, und wir können anhand ihrer
Benennung in Schlangengroßbuchstaben erkennen , dass dies Konstanten
der Farbklasse sind Wir könnten das sogar umdrehen und so tun, als ob die Plüschtiere ein NFC- oder
Nahfeldkommunikationsetikett
enthalten, was sie
zum Schlüssel für den Zugang zum Schließfach macht Und wir können nach
wie vor alles, was
wir wollen, in den Schrank legen , einschließlich Lassen Sie uns ein weiteres Plüschtier herstellen
, das wir im Schließfach aufbewahren können, das
mit Arthur als Schlüssel entriegelt wird Diesmal ist es Cutie,
der graue Elefant. Stellen Sie sich dieses Szenario noch einmal vor: In
der Nähe der Schließfächer steht ein NFC-Lesegerät und wir halten einen Plüsch
mit einem NFC-Tag in der Hand, so
etwas wie das, was Sie in einem Escape Room
finden könnten Wenn wir das
Plüschtier gegen das Lesegerät halten, müssen
wir überprüfen, welches Schließfach zum Plüschtier
passt, und es öffnen, falls ein Schließfach überhaupt Wenn wir jedoch versuchen, auf einen Schlüssel in
einem Wörterbuch zuzugreifen , dem kein Wert zugewiesen
wurde, verursachen
wir einen Fehler Ähnlich wie wir es tun würden, wenn wir versuchen
würden,
auf einen
Array-Index zuzugreifen, der sich außerhalb des zulässigen Bereichs befindet. Wir können
mit der Funktion has überprüfen, ob ein Wörterbuch einen Eintrag
enthält , der einem bestimmten Schlüssel
entspricht, den
Schlüssel
dann als Parameter übergeben. Auf diese Weise können wir überprüfen,
ob ein Wörterbucheintrag existiert, bevor wir versuchen auf seinen Wert zuzugreifen,
wodurch der Fehler vermieden wird. Wenn das Wörterbuch den Schlüssel
nicht enthält, drucke
ich eine
andere Nachricht aus. Anstatt
dasselbe Wörterbuch zweimal zu definieren, wäre
es besser, es in
einer Variablen zu speichern und
die Variable zweimal zu verwenden. In der nächsten Lektion werden
wir
einige verschiedene Techniken untersuchen , die Sie verwenden können wenn Sie nicht weiterkommen oder weitere Informationen
benötigen. Wir sehen uns in der nächsten Lektion.
13. 0–12 Debugging: Hallo Freunde.
Heute werden wir einige verschiedene Strategien durchgehen, mit
denen Sie Ihnen helfen können , wenn Sie
unweigerlich nicht weiterkommen. Ich habe bereits ein Skript mit dem Namen debug an
den
Stammknoten der Szene
angehängt Namen debug an
den
Stammknoten der Szene Sie haben wahrscheinlich die Funktion zur
automatischen Vervollständigung bemerkt, die verfügbar
ist, wenn Sie
den Typ Ihrer Variablen angeben diese Weise können
Sie nicht nur alle
Eigenschaften und
Funktionen der Klasse sehen , sondern nach der Auswahl einer Funktion auch die Typen
aller Funktionsparameter sehen, auch die Typen
aller Funktionsparameter sehen aller Funktionsparameter sodass Sie
passende Argumente angeben können A: Wenn Sie die Typen all
Ihrer Variablen kennen, Fehlpaarungen
deutlich sichtbar, und Sie werden vor
dem Fehler gewarnt ,
ohne ihn ausführen zu müssen Ohne strikte Typen weiß
die Engine erst, was falsch ist, wenn sie
versucht, die Zeile auszuführen Wenn Sie in einer
integrierten, klassenähnlichen Farbe blättern möchten , können
wir ganz einfach auf die
Informationen zugreifen, indem Sie auf eine der Schaltflächen in der oberen rechten
Ecke des Bedienfelds Online Docs öffnet in
Ihrem Standard-Webbrowser eine Registerkarte zur GADO-API,
die der Version des Editors entspricht , die Sie verwenden Hier findest du grundlegende
Informationen zu Gdo, Tipps für den Einstieg, ausführliche Tutorials
zu den Grundlagen,
Community-Links, in denen du zusätzliche Ressourcen
findest, und eine vollständige Kursreferenz Wie du siehst,
gibt es viele Klassen. Und wenn wir eine von ihnen auswählen, können
wir sehen, von was
sie erben
und von welchen anderen Klassen
sie geerbt werden Jeder hat eine Beschreibung
dessen, was er tut. Links zu Tutorials
zur Verwendung, eine Liste von Eigenschaften
und Methoden. Wenn wir über Klassen sprechen, neigen
wir dazu, Variablen als
Eigenschaften und
Funktionen als Methoden zu bezeichnen . Es gibt auch Signale,
etwas, das Gadot für die
automatische Kommunikation
zwischen Knoten,
Aufzählungen und Konstanten verwendet automatische Kommunikation
zwischen Knoten, ,
wie wir All diese haben
ihre eigenen Unterabschnitte und Beschreibungen Zurück im GDA-Editor öffnet die
Suchhilfe ein Fenster in
GDA, in dem Sie
eine Liste aller Klassen sehen können eine Klasse auswählen, können
wir
in unserem Editor
dieselben Informationen sehen , die auf
der GDA-Website verfügbar sind , sodass wir offline darauf zugreifen können zu unserem Skript zurückkehren, können
wir sogar
einfacher auf
diese Informationen zugreifen , indem wir
die Strg- oder Befehlstaste gedrückt halten ,
als auf einen Klassennamen zu klicken wir direkt
zu den
Referenzinformationen für diese Klasse Das Gleiche kann für
bestimmte Funktionen
und Variablen gemacht werden. Wenn Sie darauf klicken, wird nicht nur die
Referenzseite zur Klasse
geöffnet, sondern wir gelangen auch
zu der Funktion oder Variablen, auf die wir geklickt haben Es gibt auch globale Funktionen
, mit denen wir hauptsächlich mathematische Operationen
ausführen können ,
wie zum Beispiel Clamp Wenn wir diese Funktion verwenden, können
wir die Parameter sehen, die
sie erwartet und wir können sie verwenden, um
unsere Variable auf 0-1 zu begrenzen die Strg- oder
Befehlstaste gedrückt halten und auf
den Namen der globalen Funktion klicken , können
wir auf die Referenz
für diese Funktion zugreifen, einschließlich einer Beschreibung
und ihrer Verwendung Diese sind alle in
der globalen Scope-Klasse enthalten. Ich füge meinem Skript eine
weitere Variable und eine weitere Zeile hinzu. Wenn wir unsere Szene ausführen,
können wir uns den Szenenbaum der laufenden Simulation über
das Szenenfenster ansehen laufenden Simulation über
das , indem wir
auf den Fernschalter Dies ist nicht derselbe
Szenenbaum in der lokalen Registerkarte, den
wir erstellen, um die
Szene wie eine Blaupause zu definieren Dieser Szenenbaum wurde von
der Engine für die Ausführung der Szene
erstellt Wenn wir einen Knoten auswählen, können wir
seine Eigenschaften
im Inspektor sehen und wir können sehen, dass die
Ready-Funktion bereits
ausgeführt wurde , da die Farben unterschiedliche Werte
haben. Wir können auch die Werte
jeder dieser Eigenschaften ändern. Wir können print auch verwenden
, um zu jedem Zeitpunkt auszudrucken, wann immer wir sehen möchten, was unsere
Variablen enthalten. Und es hilft, Ihre Print-Statements so
aussagekräftig wie möglich
zu gestalten, damit keine Verwirrung
darüber entsteht , woher sie
kommen Aber wenn wir die Dinge ändern
und die Prozessfunktion verwenden, ändere ich die Farbe einfach
schrittweise im Laufe der Zeit füge
dann hier eine Druckaussage Da diese Prozessfunktion 60 Mal pro Sekunde
ausgeführt wird, ist 60 Mal pro Sekunde
ausgeführt wird, der Wert von Druckanweisungen
als Debugging-Tool
stark reduziert, da das Ausgabelog dieselbe Nachricht nur
schneller wiederholt , als wir sie
lesen oder darauf reagieren können Wir können die Simulation unterbrechen,
während sie läuft, indem wir die Pause-Taste verwenden
oder F 7 drücken Auf diese Weise können wir den
Remote-Szenenbaum so sehen, wie er gerade ist , und
den Inhalt des
Ausgabefensters überprüfen , während
die Simulation angehalten Dies ist jedoch immer noch
nicht sehr nützlich, da zwischen dem
Start
der Simulation und dem Zeitpunkt, an dem wir sie anhalten können, mehrere Frames abgeschlossen
werden der Simulation und dem Zeitpunkt, an dem Start
der Simulation und dem Zeitpunkt, an dem wir sie anhalten können Wenn wir links neben
eine Codezeile klicken, können
wir einen
automatischen Breakpoint hinzufügen durch einen roten Kreis
gekennzeichnet Wenn wir die aktuelle Szene ausführen, wird
die Simulation
angehalten, wenn sie
diese Zeile erreicht , bevor sie ausgeführt Dies ist viel
hilfreicher, wenn wir möchten
, dass unsere Simulation Frame für Frame ausgeführt
wird. Jetzt können wir sehen, wie sich bei jedem Bild die Farbe von Bild
zu Bild allmählich ändert. Lassen wir unsere Prozessfunktion eine andere Funktion aufrufen, um eine einfache Aufgabe
auszuführen. Ich ändere
die Farbe einfach schrittweise indem ich den Rotwert reduziere. Jetzt sollten wir also sehen, dass sich
die Farbe bei jedem Frame allmählich ändert und
weniger rot und mehr blau wird. Wenn sich der Breakpoint immer noch in der ersten Zeile der
Prozessfunktion befindet, führe
ich die Szene Es hört hier auf, und wir können sehen
, dass die nächste Codezeile ausgeführt werden
soll,
mit einem gelben Dreieck gekennzeichnet ist Während die Simulation auf diese Weise angehalten
wird, können
wir sie anweisen , jeweils
nur eine einzige Codezeile
und
nicht einen ganzen
Frame auszuführen , indem wir im Debug-Menü die Option Step over wählen oder die Tastenkombination F ten
verwenden Dadurch wird
nur die
Codezeile ausgeführt , auf
die das gelbe Dreieck zeigt, und
dann sofort wieder angehalten dann sofort wieder angehalten Wir können also die Änderungen sehen, die nur durch diese
einzelne Codezeile
vorgenommen wurden,
und wir können sehen, dass das
gelbe Dreieck die nächste Zeile zeigt, die
darauf wartet, ausgeführt zu werden. Wir können
unser Skript Zeile für Zeile weiter ausführen , indem
wir Schritt für
Schritt weitermachen, bis
die Prozessfunktion
beendet und der Frame abgeschlossen ist, und dann Schritt weitermachen, bis
die Prozessfunktion zum Anfang
der Prozessfunktion
zurückkehren, zum Anfang
der Prozessfunktion
zurückkehren um sie ein zweites Mal auszuführen Jetzt können wir beobachten, wie sich jede einzelne Farbe
ändert ihr Blauwert erhöht wird wenn
ihr Blauwert erhöht wird,
unabhängig davon, ob der
Rotwert gesenkt wird, obwohl sie
während desselben Frames auftreten Bei Funktionsaufrufen
gibt es eine weitere Möglichkeit, in die Funktion
einzusteigen. Wenn wir diese Option wählen
oder die Tastenkombination F 11 verwenden, springt der gelbe Pfeil stattdessen in die
aufgerufene Funktion und führt diese Zeile für Zeile bis sie abgeschlossen ist. Wenn die Funktion abgeschlossen ist, kehrt
der gelbe Pfeil zur ursprünglichen Funktion zurück, um mit
der Ausführung dieser Funktion
fortzufahren. Mit diesen Tools haben wir
einen sehr konzentrierten Überblick
darüber, einen sehr konzentrierten Überblick was unsere Klassen
tun und wann, wie sie sich verhalten, und wir können sie in
Zeitlupe beobachten um herauszufinden, was zu welchem
bestimmten Zeitpunkt schief
läuft welchem
bestimmten Zeitpunkt schief
läuft Wenn Sie
ein Problem nicht selbst lösen können, ist
die GDA-Community sehr hilfreich und immer
bereit, Ihnen unter die Arme zu greifen Es gibt Discord-Server
für GDA-Entwickler, einschließlich meines Servers, auf dem sich meine Schüler gegenseitig helfen Der Link zum Beitritt
befindet sich in meinem Profil. Es gibt auch Online-Foren auf Websites wie Redit, in denen
Sie auch Fragen stellen können Sie haben jetzt ein grundlegendes
Verständnis der meisten
GDScript-Syntax und der Tools, die benötigen, um diese
Konzepte weiter zu untersuchen Wenn du bereit bist, frage
mich bitte nach einem Rabattcode für einen meiner
Spielprojekt-Kurse, und viel Glück
14. Grundlagen: Hallo Freunde. Unser Ziel für den ersten Abschnitt
dieses Kurses ist es , einen
Drei-D-Charakter zu erstellen, den der Spieler Perspektive einer dritten
Person steuern
kann. unserer ersten Lektion
werden wir
eine grundlegende 3-D-Szene
und ein neues Projekt einrichten . Wenn wir Gada zum ersten
Mal öffnen, gibt es keine Projekte. Cadeau empfiehlt,
offizielle Beispielprojekte zu untersuchen. Drücken Sie auf Abbrechen, um
diese Empfehlung zu ignorieren. Wir werden ein neues
Projekt von Grund auf neu starten. Klicken Sie auf die Schaltfläche „Neu“
, um ein neues Projekt zu erstellen. Wir müssen
dem neuen Projekt einen Namen geben. Ich nenne meinen Kurs Gada
Three D. Und wählen Sie einen Ordner auf Ihrer
Festplatte aus, um ihn zu speichern. Ich empfehle, einen Ordner für
Gada-Projekte in Dokumenten zu erstellen Gada-Projekte in Dokumenten Klicken Sie dann auf die Schaltfläche „
Ordner erneut“, um an dieser Stelle
einen neuen Ordner mit dem Namen des Projekts Sie können die
Renderer-Einstellungen für Ihr Projekt ändern. Forward eignet sich am besten
für High-Fidelity-, PC- oder Konsolenspiele Oder der mobile Renderer
für mobile Geräte. Ich verwende den
Kompatibilitätsrenderer gerne für die meisten Projekte,
da er am besten mit
Web-Builds
kompatibel ist , die auf Websites wie Dot IO
hochgeladen werden können Websites wie Dot IO
hochgeladen Schließlich unterstützt God standardmäßig die Integration mit der GT
Tub-Versionskontrolle Klicken Sie auf Erstellen und Bearbeiten, um das Projekt zu erstellen und zur Bearbeitung zu
öffnen. Das Gdo-Editorfenster ist in mehrere Tabs
unterteilt. In der Mitte befindet sich eine Vorschau darauf, wie die aktuelle
Szene aussieht, sowie verschiedene Tools, mit denen
wir Dinge bearbeiten können Oben links
befindet sich die Registerkarte Szene, die eine Liste aller Elemente
der aktuellen Szene enthält. Darunter befindet sich die Registerkarte
Dateisystem, die alle importierten Elemente
für unser Projekt wie Modelle,
Texturen, Sounds und Musik enthält für unser Projekt wie Modelle,
Texturen, . Neben allen Dateien,
wie Szenen, , werden
wir mit
dem Gada-Editor erstellen Skripten
und Ressourcen Derzeit ist die einzige Datei
hier das Gada-Logo. der rechten Seite befindet sich
der Inspektor-Tab, auf dem wir, wenn
wir
etwas in der Szene auswählen, dessen Eigenschaften sehen
und bearbeiten können Alle diese Tabs
können nach Belieben in der Größe verändert und neu angeordnet werden, um sie optimal an
Ihren Arbeitsablauf anzupassen Unsere Szene ist ein riesiger
leerer Raum mit drei D durch drei farbige Achsen
geteilt wird Die rote X-Achse steht für
rechts und links. Die grüne Y-Achse
steht für oben und unten. Die blaue Z-Achse steht für
Vorwärts und Rückwärts. Lassen Sie uns beginnen, indem Sie auf
der Registerkarte Szene auf die Schaltfläche
mit den drei D-Szenen Dadurch wurde auf der Registerkarte Szene ein Stammknoten
für unsere Szene mit
dem Namen Node Three D erstellt Registerkarte Szene ein Stammknoten
für unsere Szene , was auch dem Knotentyp entspricht. Wir können diesen Knoten umbenennen,
indem wir
darauf doppelklicken oder mit der rechten Maustaste klicken
und Umbenennen auswählen. In vielen Spielen wird diese
Szene als Hauptszene
oder Spielszene bezeichnet . Du kannst sie auch nach
dem Spielstil benennen , der verwendet werden soll, z. B. nach der Plattformspiel-, Erkundungs
-, Kampf- oder Rätselszene Ich nenne mein Spiel. Dieser Wurzelknoten wird
unseren Szenenbaum bilden , wenn wir ihm Zweige
hinzufügen. Klicken Sie entweder auf die
Plus-Schaltfläche oder klicken Sie mit der rechten Maustaste auf den Stammknoten und wählen Sie Untergeordneten Knoten hinzufügen, um dem Szenenbaum einen
Zweig hinzuzufügen. Es stehen viele
verschiedene Knotentypen zur Auswahl, die
vielen verschiedenen Zwecken dienen. Knotentypen folgen einer
Hierarchie der Vererbung. Alle Knoten teilen sich also
den gemeinsamen Knotentyp. Aber dann gibt es Knoten
drei D, Canvas Item, Knoten zwei D, Control, jeweils mit vielen
verschiedenen Untertypen Wenn Sie wissen, wonach
Sie suchen, können
Sie den Namen des
Knotens in das Suchfeld eingeben Fügen wir eine
Mesh-Instanz mit drei D-Knoten hinzu. Sie können sehen, dass ein Knoten der
Netzinstanz drei D Eigenschaften
eines
Knotens der Geometrieinstanz
drei D, der
visuellen Instanz 3 D, des Knotens D und des
Knotens 3 erbt eines
Knotens der Geometrieinstanz
drei D, visuellen Instanz 3 D, des Knotens D und des
Knotens 3 Klicken Sie auf die Schaltfläche Erstellen, um
den
Knoten der Netzinstanz 3 D zum Szenenbaum hinzuzufügen den
Knoten der Netzinstanz 3 D zum Szenenbaum Sie können sehen, dass der Knoten
dem Szenenbaum hinzugefügt wurde,
aber er ist eingerückt, um zu implizieren, dass er ein
untergeordnetes Element des Wurzelknotens ist Jeder Knoten mit untergeordneten Knoten
kann reduziert
oder erweitert werden , um seine untergeordneten Knoten ein- oder
auszublenden Das sollte ein Drei-D-Bild
sein, aber
im Vorschaufenster wird nichts angezeigt. Das liegt daran, dass
diese Mesh-Instanz keine Mesh-Ressource hat, die
ihr sagt, was sie zeichnen soll. Bei der Mesh-Instanz sind
drei D-Knoten ausgewählt. Schauen Sie auf der Registerkarte „Inspektor“ nach, um Eigenschaften der
Knoten
anzuzeigen und zu bearbeiten. Die Eigenschaften sind in dieselben Typen unterteilt ,
die wir
bei der Erstellung des Knotens gesehen haben. So können wir sehen, welche
Eigenschaften von
verschiedenen Typen geerbt werden und welche für unsere Mesh-Instanz
spezifisch sind . Wir können sehen, dass das
Mesh-Feld leer ist. Wenn Sie auf das Drop-down-Menü klicken, gibt es mehrere Optionen, darunter einige
Grundformen, Box, Kapsel, Zylinder, Quad,
Prisma, Kugel und Torus Machen wir aus dieser Form ein Flugzeug. Jetzt können wir in unserer Vorschau eine
Form mit drei D zeichnen sehen. Wenn Sie auf die
Mesh-Ressource klicken, werden
ihre Eigenschaften erweitert , sodass wir sie auch
anzeigen und bearbeiten können. Hier können wir die
Größe der Ebene sowohl
in der X- als auch in der
Y-Dimension festlegen , indem entweder eine Zahl in
das Feld eingeben oder auf die Feldbeschriftung klicken und
sie ziehen Einheiten
gelten im Allgemeinen Meter oder etwa drei Fuß
in imperialen Maßeinheiten Es ist jedoch nicht erforderlich
, dieses Verhältnis zu verwenden. In einem Strategiespiel kann
eine Einheit ein
Kilometer oder eine Meile sein, oder wenn du
als winziges Insekt spielst, dann könnte eine Einheit ein
Zentimeter oder ein Zoll sein Da wir nun
etwas in unserer Szene haben , das uns einen Bezugspunkt gibt, wollen wir die
Szene etwas genauer untersuchen Es gibt ein Gitter aus
hellgrauen Linien,
die die X-Z-Ebene in
Einheiten unterteilen die die X-Z-Ebene in , wobei jede achte
Linie heller ist. Mit dem Mausrad können wir die Ansicht vergrößern oder verkleinern. herauszoomen, können wir sehen, dass dieses Muster fortsetzt,
da jede achte, größere Unterteilung ebenfalls markiert
ist, 64 Einheiten voneinander entfernt sind, was acht
Quadraten entspricht Und wieder ist jede acht oder
512 . Einheit acht
die Potenz Wenn Sie wieder hineinzoomen, wird die ursprüngliche Note wieder sichtbar das Mausrad gedrückt halten und die Maus
bewegen,
können wir
die Welt um die Y-Achse drehen und unsere
Perspektive
auch nach oben oder unten neigen die rechte
Maustaste gedrückt halten und
die Maus bewegen , können wir unsere Perspektive
drehen nach rechts, links, oben oder unten schauen. immer noch die
rechte Maustaste gedrückt halten, können
wir mit den
WASD-Tasten durch
unsere Szene fliegen und gleichzeitig
die Maus verwenden , um
unseren Blickwinkel zu orientieren Wenn es so aussieht, als ob du dich langsam oder gar nicht
bewegst, bist du wahrscheinlich ausgezoomt Auf diese Weise können wir unsere Szenen
schnell und einfach aus
jeder Position und jedem Winkel betrachten Das Netz definiert nur die
Form eines Drei-D-Objekts, nicht seine Farbbeleuchtung
oder etwas anderes. Diese sind alle vom Material abhängig. Erweitern Sie das
Drop-down-Menü mit der Bezeichnung Material, wählen Sie neues Standardmaterial
drei D aus. Klicken Sie anschließend auf die neu erstellte
Materialressource , um ihre Eigenschaften anzuzeigen und zu bearbeiten. Materialien verfügen über
zahlreiche Eigenschaften , mit denen sie steuern können, wie sie mit Licht
interagieren. Erweitern Sie den Albedo-Bereich. Hier können wir
die Farbe anpassen oder auch
eine Zwei-D-Bilddatei verwenden , um
Textur auf das Material anzuwenden Versuchen Sie, das Gada-Logo
in das Texturfeld zu ziehen. Wenn sowohl eine
Textur als auch eine Farbe vorhanden sind,
wird die Farbe jedes Pixels mit dem
Farbwert
multipliziert , um das Ergebnis zu erhalten. In der oberen rechten Ecke
befindet sich eine Reihe von Schaltflächen, von denen eine ein
Klapperbrett mit
einem Play-Symbol ist, mit dem die aktuelle Szene ausgeführt werden auf diese Schaltfläche klicken,
werden wir aufgefordert, die aktuelle Szene zu speichern, falls
wir dies noch nicht getan Andernfalls wird
die Szene automatisch gespeichert. Auf diese Weise können wir ausgehend von
dieser aktuellen Szene, die wir
bearbeiten,
eine Simulation unseres
Spiels ausführen ausgehend von
dieser aktuellen Szene, die wir
bearbeiten,
eine Simulation unseres
Spiels dieser aktuellen Szene, die wir
bearbeiten, . Es wird nichts angezeigt. Wir können das Fenster schließen
, um die Simulation zu beenden. Das liegt daran, dass sich in der Szene
keine Kamera befindet. Für die
Anzeige von drei D-Szenen ist eine Kamera erforderlich. Eine Kamera ist nur
ein weiterer Knotentyp. Wir können es also der Szene
auf die
gleiche Weise hinzufügen , wie wir
die Mesh-Instanz hinzugefügt haben. Wir müssen eine Drei-D-Kamera verwenden, um drei
D-Szenen zu betrachten. Die Kamera wird
am Szenenursprung
, also in der Mitte
des Bodens, hinzugefügt , also in der Mitte
des Bodens, und blickt in die
negative Z-Richtung. können wir erkennen, in welche Richtung des magentafarbenen Gizmos in
Form
einer Pyramide können wir erkennen, in welche Richtung eine Kamera blickt und wie breit Anhand des magentafarbenen Gizmos in
Form
einer Pyramide können wir erkennen, in welche Richtung eine Kamera blickt und wie breit
ihr Sichtfeld magentafarbenen Gizmos in
Form
einer Pyramide können wir erkennen, in welche Richtung eine Kamera blickt und wie Und das Dreieck zeigt uns auch
, welche Richtung nach oben zeigt. die Kamera drei D-Knoten im Szenenbaum
ausgewählt hat, durch Klicken auf den vorherigen Schalter wird uns
durch Klicken auf den vorherigen Schalter angezeigt, was
die Kamera Wo sich die Kamera
gerade befindet , kann sie nichts
sehen Klicken Sie
erneut auf den Pre-Toggle, um zurückzukehren. Wir müssen es vom Boden
wegbewegen und drehen, damit es auf den Boden
schaut Wir können die
Kamera einfach entlang
einer einzigen Achse bewegen , indem wir auf einen der
drei Pfeile klicken und ziehen rot für die X-Achse, grün für y und blau für Z).
Wir können die
Kamera auch entlang einer Ebene bewegen, indem wir auf
eines der drei Quadrate klicken und es ziehen Dadurch wird der
zugehörige X-, Y- oder
Z-Wert gesperrt , während wir
die Position entlang
der anderen beiden Achsen verschieben die Position entlang
der anderen beiden Bewegen Sie die Kamera entlang
der grünen Achse nach oben und entlang der Z-Achse
vorwärts. Abhängig von der
Perspektive Ihres Editors kann
vorwärts wie rückwärts erscheinen Gründen der Übersichtlichkeit bezieht sich der
Begriff „Vorwärts“ jedoch auf die
positive Z-Richtung, also die Richtung, in
die der blaue Pfeil zeigt Dies kann auch erreicht werden,
indem die rote Achse gesperrt und die Kamera auf diese Weise entlang
der Y-Z-Ebene bewegt wird. Als Nächstes müssen wir
die Kamera drehen , um auf den Boden zu schauen
. Wir können uns um
eine einzelne Achse drehen,
indem wir auf einen
der drei Kreise klicken und ihn ziehen Eine Drehung um die grüne Y-Achse ist so, als würde man den
Kopf nach links oder rechts drehen Eine Drehung um die
blaue Z-Achse ist so, als würde man den Kopf nach Seite
oder sogar auf den Kopf stellen Blick nach unten ist eine Drehung um die X-Achse, die rot ist Klicken Sie auf die Vorschau, um zu sehen, ob Ihre Kamera
den Boden deutlich erkennen kann. Wenn die drei
D-Knoten der Kamera ausgewählt sind, schauen Sie sich im Informationsfenster
die Eigenschaften an, die
von Knoten 3 D übernommen wurden. Wenn Sie die Transformation
erweitern, können Sie sehen, dass die Positions
- und Drehungswerte der Kamera bearbeitet wurden. Alle drei D-Knoten
übernehmen diese Eigenschaft zur Steuerung ihrer Position und
Drehung im Drei-D-Knoten. Hier können wir die Werte manuell
bearbeiten,
oder wir können auf die Beschriftungen klicken und sie
ziehen, um sie mit der Maus
anzupassen,
wie wir es bei der Ebene getan haben Die Skalierung ist ein Multiplikator für die Größe von
drei D-Objekten. Standardmäßig sind die X-, Y- und
Z-Werte miteinander verknüpft. Wenn Sie
also einen Wert
bearbeiten, werden alle drei Kameras haben keine Größe, daher hat eine Änderung des Werts
keine Auswirkungen auf die Kamera Wenn Sie die Skala jedoch
auf einen negativen Wert einstellen wird die Drehung der Skala effektiv
widergespiegelt Wir können die Skala
auf eins zurücksetzen, indem wir auf die Reset-Schaltfläche klicken und diese Eigenschaft
ignorieren. Wenn Sie die Vorschau überprüfen, kann die
Kamera jetzt den Boden sehen. Aber wenn wir die aktuelle
Szene abspielen, ist der Boden schwarz. Das liegt daran, dass es in unserer Szene keine
Lichtquelle gibt. Im Editor ist der
Boden beleuchtet, weil es eine Vorschau
von Licht und Umgebung gibt, die wir mit diesen Tasten ein- oder
ausschalten können sie ausschalten, wird der
Boden schwarz, was wir sehen,
wenn wir die Szene abspielen Damit die Kamera den Boden sehen
kann, müssen
wir der Szene also auch eine
Lichtquelle hinzufügen. Fügen Sie der Szene ein gerichtetes Licht mit
drei D hinzu. Wie bei der Kamera wird es am Szenenursprung hinzugefügt ,
der in die
negative Richtung zeigt. Ein gerichtetes Licht
simuliert Sonnenlicht und erzeugt parallele
Lichtstrahlen über die gesamte Szene Position hat keinen Einfluss auf sein Verhalten, sondern nur auf seine Drehung Wir können
es an einer beliebigen Stelle in der Szene bewegen und positionieren, am besten an einer Stelle, an der wir Gizmo mit dem weißen Pfeil sehen
können Dieser Pfeil zeigt in die
Richtung der Lichtstrahlen. Drehen Sie die Lichtquelle
so, dass das Licht
nach unten zum Boden zeigt und ihn für die Kamera
beleuchtet Wenn wir nun die Szene ablaufen lassen, kann
die Kamera
dank des Lichtes, das von ihm
reflektiert wird, den Boden sehen dank des Lichtes, das von ihm
reflektiert wird Jedes lauffähige Spiel benötigt diese drei
grundlegenden Komponenten:
etwas zum Anschauen, eine Kamera, mit der
man es sehen kann, und
eine Lichtquelle Wenn Sie mit
drei D-Positionen und Rotationen üben möchten ,
versuchen Sie, mithilfe von Mesh-Instanzen ein abstraktes
dreidimensionales Kunstwerk zu erstellen mithilfe Beachten Sie, dass Lichter standardmäßig keine
Schatten werfen. Um Schatten zu aktivieren, klicken Sie
auf den Lichtquellenknoten, erweitern Sie den Schattenbereich
unter Licht drei D und klicken Sie auf den Schalter Aktivieren Sie können der Szene auch zusätzliche
Lichter hinzufügen und die Energie oder
Farbe
anpassen, die Energie oder
Farbe
anpassen um eine
Vielzahl von Lichtverhältnissen zu erzeugen Sie können auch gerne
mit den verschiedenen Eigenschaften
von Materialien und deren
Wechselwirkung mit der Beleuchtung experimentieren . Wenn Sie fertig sind, sollten
Sie ein gutes Verständnis der
Beziehung zwischen Netzen,
Materialien, Kameras
und Lichtquellen Wie sie verwendet werden, um eine dreidimensionale Szene zu
erstellen, wie man Objekte
im dreidimensionalen Raum bewegt und dreht im dreidimensionalen Raum und wie man in der Szene navigiert In der nächsten Lektion werden wir beginnen, Anregungen vom Spieler zu
erhalten. Wir sehen uns in der
nächsten Lektion. Okay.
15. Skripte: Hallo Freunde. In
der vorherigen Lektion haben wir eine einfache
Drei-D-Szene mit Netzen,
Materialien, einer Kamera
und einer Lichtquelle eingerichtet Materialien, einer Kamera
und einer Lichtquelle In dieser Lektion akzeptieren wir die
Eingaben des Spielers. Klicken Sie in
der Menüleiste auf Projekt und öffnen Sie
die Projekteinstellungen. Wechseln Sie oben
im Fenster mit den
Projekteinstellungen zur Registerkarte Eingabekarte . Um
unser Ziel
, einen Charakter mit
drei D zu steuern, zu erreichen , müssen
wir Eingaben
für die vier
Bewegungsrichtungen
links, rechts, vorwärts
und rückwärts akzeptieren für die vier
Bewegungsrichtungen
links, rechts, vorwärts
und rückwärts Geben Sie ein und bewegen Sie sich nach links in das Feld Neue Aktion
hinzufügen. Klicken Sie dann auf
Hinzufügen, um die Aktion hinzuzufügen. Der Aktionsname ist
eine Beschreibung dessen wofür die Eingabe in unserem Spiel
verwendet wird üblicherweise in Kleinbuchstaben
geschrieben durch
Unterstriche getrennt Aktionen werden durch Ereignisse ausgelöst, die wir hinzufügen können, indem wir
auf die Plus-Schaltfläche klicken Ereignisse können Tastaturtasten, Mausklicks, Bewegungen
oder Eingaben von einem Joypad sein. Wir können nach
den gewünschten Eingaben suchen indem wir ihre Kategorien erweitern, die Suchergebnisse
filtern
oder das Listening-Feld verwenden, oder das Listening-Feld verwenden die Suchergebnisse
filtern
oder das Listening-Feld verwenden,
um einfach die gewünschte
Taste zu drücken. sich nach links zu bewegen, verwenden die meisten
Spiele die A-Taste oder den linken Stick eines nach links geneigten
Joy-Pads Durch das Hinzufügen mehrerer Ereignisse können
unterschiedliche Spielstile
besser berücksichtigt werden unterschiedliche Spielstile
besser Wir müssen auch in der
Lage sein, uns nach rechts,
vorwärts und rückwärts zu bewegen und für jede Aktion
eine neue Aktion hinzuzufügen Ich benutze die D-Taste oder den linken
Stick rechts für rechts. WK oder linker Stick hoch für vorwärts und S-Taste oder linker Stick
runter für rückwärts Der Wert für die tote Zone gibt
an, wie viel
Druck oder Neigung mindestens erforderlich ist
, um diese Aktion auszulösen Jetzt wartet der Motor auf
diese Eingabeereignisse und
löst diese Aktionen aus. Wenn Sie fertig sind,
klicken Sie auf die Schaltfläche „Schließen“ , um die Projekteinstellungen zu schließen. Lassen Sie uns einen neuen
Knoten erstellen, der auf die von uns erstellten
Eingabeaktionen
reagiert. Dieser Knoten muss kein physisches
Objekt in unserer Szene
repräsentieren, er kann
also nur ein einfacher
Knoten sein und einen Spieler benennen. Jedem in unseren
Szenen kann
Verhalten zugewiesen werden, indem
Skripte an sie angehängt Klicken Sie mit der rechten Maustaste auf den
Player-Knoten und wählen Sie Angehängtes Skript aus. Oder
klicken Sie bei ausgewähltem
Player-Node im Szene-Tab auf die
Schaltfläche mit dem angehängten Skript. Die Standardsprache
für Skripte in der Goda-Engine ist GodaScript, das sehr einfach zu erlernen und für die
Spieleentwicklung gut optimiert ist für die
Spieleentwicklung gut optimiert Skripte erben das Verhalten des Knotentyps, an
den
sie angehängt wurden In diesem Fall nur
ein normaler Knoten. Vorlagen werden für
verschiedene Knotentypen bereitgestellt , um grundlegende Funktionen
bereitzustellen. Die
Kontrollkästchen für Vorlagen sind standardmäßig aktiviert. Schauen wir uns an, was
die Standardvorlage für ein Node-Skript enthält. Wir erstellen ein neues Skript und verwenden
keines, das in die Engine
integriert ist. Wir können dem Skript einen Namen geben
, der
von der Engine empfohlen wird und der dem Namen des Knotens
entspricht, an den
es angehängt wird. Es ist üblich
, bei der Benennung von Skripten
wie den Eingabeaktionen Snake-Groß
- und Kleinschreibung zu verwenden . Kleinbuchstaben, getrennt durch
Unterstriche. Klicken Sie auf die Schaltfläche „Erstellen“,
um das Skript Der Editor
wechselt
automatisch zur
Skriptansicht, um es zu bearbeiten Sie können jederzeit zur
Drei-D-Ansicht zurückkehren indem Sie oben im Editor
auf die
Drei-D-Taste klicken. Wechseln Sie ebenfalls zur
Skriptansicht, indem Sie auf Skript klicken. Die oberste Zeile gibt
den Knotentyp an, dieses Skript
angehängt werden kann, nämlich Knoten. Das Schlüsselwort extends
ermöglicht es diesem Skript, die Eigenschaften
und Verhaltensweisen eines Knotens
zu erben, sodass wir sie
im Skript verwenden können Funktionen sind Verhaltensweisen, die das Skript auf dem
Knoten ausführen wird, an den es angehängt ist Unsere Skriptvorlage
beginnt mit zwei Funktionen:
Ready und Process. Grauer Text, der mit
einem Cathorp oder Kommentaren beginnt. Text, der nur
zu unserem Vorteil als Entwickler existiert , um
das
Skript in einfacher Sprache zu erklären Aus den Kommentaren geht hervor, dass
die Ready-Funktion
automatisch aufgerufen wird , wenn der Knoten den Szenenbaum
zum ersten Mal
betritt. Dies geschieht nicht, wenn wir
den Knoten im Editor erstellen, sondern wenn wir die Schaltfläche
Aktuelle Szene ausführen drücken. Die Simulation
erstellt den Szenenbaum, und wenn der Player-Knoten zum
Szenenbaum
hinzugefügt wird und bereit ist, wird dieses Verhalten aufgerufen. Die Prozessfunktion
wird für jeden Frame aufgerufen Bei
den standardmäßigen
Projekteinstellungen sind das 60 Bilder pro Sekunde. Diese Funktion hat einen
Parameter namens Delta, der die Zeit
in Sekunden angibt, die seit dem vorherigen
Frame
vergangen ist in Sekunden angibt, die seit dem vorherigen
Frame
vergangen Diese Variable wird
als Fließkommazahl dargestellt,
eine Zahl mit Dezimalstellen Wir können den Typ
jeder Variablen mit einem Doppelpunkt angeben, gefolgt vom Typnamen. Da das Gudo-Skript lose
geschrieben ist, ist dies optional, aber die Angabe eines
Typs verbessert
die Effizienz der Engine und
reduziert die Häufigkeit Es wird daher empfohlen,
immer den Typ
Ihrer Variablen anzugeben , es sei denn, Sie
müssen mehrere Typen zulassen Okay. Wir können den
Befehl print in unseren Skripten verwenden, um einfachen Text der Ausgabekonsole hier unten im
Fenster auszugeben. Der Befehl print verwendet
eine Zeichenfolge als Argument, sich um eine Folge
von Zeichen handelt die in
Anführungszeichen stehen. Lassen Sie uns während
der Bereitschaftsfunktion drucken und
während der Prozessfunktion weiterverarbeiten. Wir können auch
den Plus-Operator verwenden um Zeichenketten miteinander anzuhängen, sodass wir den Wert
von Delta an die Prozesszeichenfolge anhängen von Delta an die Prozesszeichenfolge Aber Delta ist ein Float, kein String, was nicht erlaubt
ist Wir können den
Delta-Typ
mit dem Befehl STR von einem Float in einen String umwandeln, wobei Delta als
Argument in Klammern übergeben wird. Führt die aktuelle Szene aus und
stoppt sie nach einem kurzen Moment. In der Ausgabekonsole
können wir sehen, dass Ready einmal gedruckt
wurde, gefolgt von Prozess 0,016 usw. viele Male, usw. viele Male, was der Bildrate
von einer 60stel-Sekunde Manchmal kann die Zahl höher
sein
, weil die Verarbeitung dieses Frames etwas
länger gedauert hat Wir können also sehen, dass
diese Verhaltensweisen automatisch
von der Engine aufgerufen werden. Lassen Sie uns diese
Print-Anweisungen
und die gesamte Ready-Funktion entfernen . Stattdessen
wollen wir überprüfen, ob der Spieler während
der Prozessfunktion irgendwelche Eingaben macht. Um diese Informationen zu speichern, müssen
wir oben
im Skript eine
Variable mit
dem Schlüsselwort VR deklarieren . Nennen wir es Bewegungsrichtung. Wenn dem Namen
der Variablen
ein Unterstrich vorangestellt wird,
wird sie als privat gekennzeichnet,
was bedeutet, dass sich nur dieses Skript damit befassen
muss Der Typ unserer Variablen
wird ein Vektor zwei sein. Ein Vektor zwei ist eine Struktur zwei Gleitkommazahlen mit den
Namen x und y enthält. Wir haben bereits mit Vektor
zwei
gearbeitet , wenn es um
die Größenänderung des Ebenennetzes geht, und Vektor Drei ist, wenn
die Position oder Drehung
von drei beliebigen D-Knoten bearbeitet die Position oder Drehung
von drei beliebigen D-Knoten Während der Prozessfunktion können
wir den Wert der Bewegungsrichtung auf
den aktuellen Status der
Bewegungseingabeaktionen setzen Bewegungsrichtung auf
den aktuellen Status der
Bewegungseingabeaktionen ,
die wir
zuvor mit dem
Zuweisungsoperator oder dem Gleichheitszeichen erstellt haben zuvor mit dem
Zuweisungsoperator oder dem Gleichheitszeichen Die Bewegungsrichtung
entspricht dem Eingabevektor. Input ist eine Singleton-Klasse, ein integriertes Skript, auf das wir anhand seines Typs verweisen
können, da es immer
nur eine Instanz davon geben wird Die Periode greift auf
Variablen oder Funktionen zu, die in diesem Fall
Methoden genannt werden, weil sie zu einer
Klasse gehören Die Methode, die wir aufrufen,
heißt get vector. Get vector akzeptiert vier
Zeichenketten als Argumente, das sind die Namen
der Eingabeaktionen , die verwendet werden, um einen zweiten Vektor zu
erstellen
, der dann in der Variablen
gespeichert wird. Ein negativer X-Wert
, der übrig bleibt, wird
von einem positiven X-Wert subtrahiert,
um den Wert von x im zweiten Vektor zu berechnen Ebenso wird ein negativer
Y-Wert nach oben von einem
positiven Y-Wert
nach unten
subtrahiert, um
den Wert von Y zu berechnen. Dies mag umgekehrt erscheinen, aber wenn man sich
die Eingabe-Mappings ansieht, wird die Aufwärtsrichtung als negative Seite
der Achse und
die Abwärtsrichtung als positive Seite aufgeführt negative Seite
der Achse und
die Abwärtsrichtung als positive Seite Außerdem schaut die Kamera in
die negative eingestellte Richtung. Sich aus der
Kameraperspektive vorwärts zu bewegen, bedeutet
eigentlich, sich rückwärts
durch den Drei-D-Raum Dies entspricht
zweidimensionalen Spielen da der Ursprung der Szene am oberen Bildschirmrand
liegt und positive Werte
sich nach unten bewegen, nicht nach oben Im Moment können wir einfach
den Wert unserer Variablen ausdrucken , um zu sehen, was er ist. Lassen Sie uns die aktuelle
Szene ausführen und testen. Die Ausgabekonsole gibt
ständig Null aus,
Null, weil keine Eingabe
erfolgt. Wenn wir eine der WASD-Tasten drücken oder den linken
Stick auf unserem Joypad neigen, ändert sich
der Wert, der
gedruckt wird Links bedeutet, dass der X-Wert negativ und
positiv ist. Nach unten wird der
Y-Wert positiv eingestellt, d. h. zur Kamera hin und negativ nach
oben, weg
von der Kamera. Wenn wir das Fenster schließen, wird eine Warnmeldung angezeigt. Der Wert von Delta wird von unserer
Prozessfunktion nicht verwendet. Wir können vor Delta einen Unterstrich hinzufügen, um
ihn zu kennzeichnen, damit die Engine weiß, dass er ignoriert
werden kann , da
wir ihn nicht benötigen Wir sind jetzt in der Lage, Bewegungseingaben von
Spielern
entweder über die Tastatur oder das JoyPad zu lesen Bewegungseingaben von
Spielern
entweder über die Tastatur oder das JoyPad In der nächsten Lektion verwenden wir die Eingaben
des Spielers, um
ein Objekt durch unsere Szene zu bewegen Wir sehen uns in der nächsten Lektion.
16. Bedienelemente: Hallo, Freunde. In
der vorherigen Lektion haben wir angefangen,
Eingaben vom Spieler zu erhalten. In dieser Lektion werden wir mithilfe dieser Eingabe
ein Drei-D-Objekt durch
unsere Szene bewegen . Beginnen wir damit,
alle Netze außer dem Boden aus unserer
Szene zu entfernen alle Netze außer dem Boden aus unserer
Szene Und wir fügen der Spielszene einen neuen Knoten
hinzu, einen Charakterkörper mit drei D-Knoten Dieser Knoten verfügt über einige eingebaute Funktionen
für die Physik der
Bewegung eines Charakters, stellt aber
eigentlich nichts dar, was
der Spieler sehen kann. Also sollten wir dem Hauptteil des Charakters einen untergeordneten
Knoten hinzufügen, eine Mesh-Instanz mit drei
D. Diese können wir mit einem
Kapselnetz
füllen, mit der Absicht,
dieses später durch einen echten
Charakter zu ersetzen dieses später durch einen echten
Charakter Der Körper der Figur D befindet sich am Ursprung
der Szene auf dem Boden, ebenso wie die Mesh-Instanz Wenn wir davon ausgehen, dass sich die
Position der Charaktere zwischen ihren Füßen befindet, sollte die Kapsel im Verhältnis zum Körper
der Figur nach
oben bewegt werden . Wenn die Mesh-Instanz
drei D-Knoten ausgewählt hat, die dem Körper der Figur untergeordnet sein sollen,
bewegen Sie die Kapsel entlang
der Y-Achse
nach oben , bis sie
sich auf dem Boden befindet, was eine Einheit sein sollte die drei D-Knoten des Charakters
auswählen, bewegt sich auch
die Mesh-Instanz
,
wenn wir diesen Knoten bewegen Untergeordnete Knoten folgen der Position, Rotation und Größe
ihrer Eltern. Okay. Auf der Registerkarte „Szene“ wird eine Warnung
angezeigt, die besagt, dass der Körper der Figur
eine Kollisionsform benötigt. Dies ist ein weiterer untergeordneter Knoten. Wir müssen dem Körper des
Charakters drei D-Knoten hinzufügen, eine Kollisionsform mit drei D-Knoten. Die Goto-Engine geht nicht davon aus
, dass Kollisionen auftreten,
wenn Netze Stattdessen können wir
eine zusätzliche Form hinzufügen,
in der Regel eine, mit der
Kollisionen viel
einfacher zu erkennen sind, um die Berechnungen effizienter zu gestalten . Ähnlich wie der
dritte D-Knoten der Mesh-Instanz eine Mesh-Ressource benötigt, der D-Knoten der Kollisionsform drei benötigt
der D-Knoten der Kollisionsform drei eine Shape-Ressource Wir verwenden dieselbe
Kapselform und verschieben sie eine Einheit nach
oben, sodass sie sich an
derselben Position wie das Netz befindet. Okay. Dies ist jetzt ein Zweig von Knoten
, die sich alle
speziell auf
unseren Charakter beziehen und
nichts mit der
gesamten Spielszene zu tun haben . der rechten Maustaste auf den dritten D-Knoten des
Charakters, wählen Sie Safe Branch als Szene und geben Sie dieser Szene einen Namen. Sie können dieser
Szene den Namen des Charakters geben oder
sie vorerst einfach als Charakter belassen. Die untergeordneten Knoten im
Szenenbaum sind jetzt ausgeblendet, und der Charakterknoten
hat ein Klapperbrettsymbol Wenn wir auf das
Klapperbrett klicken, wird
die Charakterszene zur
Bearbeitung geöffnet Okay. Im Editor
wird ein neuer Tab
für unsere neue Szene geöffnet, und wir können zwischen
der Spielszene oder der
Charakterszene wechseln , indem wir auf die Tabs
klicken. Der Charakter ist jetzt
eine separate Szene von der Spielszene, die wir isoliert bearbeiten
können. Alle Änderungen, die wir
an dieser Szene vornehmen, wirken
sich auf alle Instanzen dieser
Szene in anderen Szenen aus. So wie unser Spielerknoten ein Spielerskript
hat, benötigt auch
der Charakterknoten ein Charakterskript, das ihm
sagt, wie er sich verhalten soll. ein neues Skript an den
Stammknoten unseres Charakters anhängen, erbt
dieses neue Skript
von Charakterkörper
drei D. Wir können
die Basisvorlage
für diesen Knotentyp verwenden die Basisvorlage
für diesen Knotentyp und auf Erstellen klicken, um das Neue Skript zu
öffnen Es gibt ein paar Unterschiede
zu dieser Vorlage. Die Geschwindigkeit und die
Sprunggeschwindigkeit des Charakters sind als Konstanten gespeichert Konstanten ähneln Variablen
, sind jedoch effizienter für
Werte, die sich nie ändern Eine Gravitationskraft
wird aus den
Projekteinstellungen gelesen Okay. Statt der
Prozessfunktion gibt es eine physikalische
Prozessfunktion. Standardmäßig werden sowohl der
Prozess als auch der Physikprozess 60 Mal pro Sekunde
ausgeführt. In Spielen mit vielen
komplexen physikalischen Komponenten
kann die Bildrate
des physikalischen Prozesses jedoch reduziert werden, um die
Effizienz zu verbessern, ohne dass
grafische Aktualisierungen
oder Reaktionszeiten Alles, was mit Geschwindigkeits
- oder
Kraftberechnungen zu tun hat, wird in der physikalischen
Prozessfunktion ausgeführt, um sie voneinander zu trennen die Figur während der physikalischen
Prozessfunktion Befindet sich die Figur während der physikalischen
Prozessfunktion
nicht auf dem Boden,
wird die Schwerkraft mal
Delta von ihrer
Vertikalgeschwindigkeit abgezogen Wenn der Spieler auf „UI Accept Action“ drückt
, eine eingebaute Eingabeaktion, die der Leertaste
zugewiesen ist, springt der Charakter Diese Vorlage verwendet ebenfalls ähnlichen Code, um die
Bewegungseingabe über
die Pfeiltasten zu lesen . Die Eingabe wird dann in
einen Vektor Drei umgewandelt , indem eine Null für
den Y-Wert
hinzugefügt und die vertikale Y-Bewegung
für
die Zt-Achse verwendet wird,
wodurch die - und
Abwärtseingaben auf der Tastatur des Controllers in Vorwärts
- oder Rückwärtsbewegungen umgewandelt Dieser Wert wird dann mit der Knotenbasis
multipliziert. Dabei handelt es
sich um eine Struktur aus
drei Vektoren, handelt es
sich um eine Struktur aus die nach oben und nach
vorne zeigen Dies sind dieselben drei
farbigen Pfeile, die im Editor
angezeigt werden, wenn
wir drei beliebige D-Knoten auswählen Diese Pfeile
befinden sich jedoch im globalen Raum. Wenn wir den Charakterkörper drehen, bleiben
die Pfeile gleich. Die Basisvektoren der Knoten werden
angezeigt, wenn wir in den
lokalen Raum wechseln , indem wir auf diesen Schalter klicken oder
die Tastenkombination T drücken Wenn sich der Knoten dreht, seine Basisvektoren oder seine lokalen Interpretationen von auch
seine Basisvektoren oder
seine lokalen Interpretationen von
rechts nach oben und vorwärts Dies sind die
Richtungsvektoren, die verwendet werden, um die Richtung zu bestimmen, in
die
sich die Figur bewegt, wenn eine Eingabe erfolgt. Die Richtung wird
dann normalisiert. heißt, unabhängig
von jeder Drehung oder teilweisen Neigung
des linken Sticks wird
die Länge des
Richtungsvektors eins,
was dazu führt, dass sich die
Figur immer einer konstanten Geschwindigkeit
bewegt Dies ist eine Abkürzung für den Fall, dass
die Richtung nicht Null ist. Bewegen Sie den Charakter dann entlang der X- und Z-Achsen entsprechend der Richtung
multipliziert mit Wenn die Richtung Null ist, bewegen
Sie ihre Geschwindigkeit mit der Geschwindigkeit gegen
Null Schließlich
wird die
Move-in-Slide-Methode aufgerufen, um
ihre Geschwindigkeit und ihre
externen Kräfte für
die Dauer von
Delta anzuwenden externen Kräfte für
die Dauer von , um herauszufinden,
wo sich die Figur in diesem Frame befinden
sollte. Wenn wir versuchen, diese Szene abzuspielen, wird
nichts gezeichnet, da es sich um
die Charakterszene handelt , die weder Kamera noch Beleuchtung
hat. Wechsle also zur Spielszene und starte diesen Schwan
, um das Spiel zu testen Der Charakter
fällt sofort durch den Boden. Das liegt daran, dass der Boden
nicht kollidiert. Fügen wir der Szene einen statischen Körper mit
drei D-Knoten hinzu. Ein Körper ist ein allgemeiner Begriff für jedes Objekt, das
von Physik oder Kollisionen beeinflusst wird Statisch bedeutet, dass er sich
nicht verändert, oder in diesem Zusammenhang, dass er sich
weder aufgrund der Physik wie der
Schwerkraft noch aufgrund von Kollisionen
mit anderen Körpern
wie unserem Charakter bewegt Schwerkraft noch aufgrund von Kollisionen mit anderen Körpern
wie Die Floor-Mesh-Instanz
sollte ein untergeordnetes dieses statischen Körperknotens da sie dessen visuelle
Komponente darstellt Dann müssen wir eine
Kollisionsform mit drei D-Knoten hinzufügen , um
dem Boden eine Form zu geben , mit der er
mit anderen Körpern kollidiert Diese Form wird eine Kiste sein. die Ressource „
Kastenform“ erweitern, können
wir ihr eine Länge und
Breite zuweisen, die dem Boden entsprechen Länge und
Breite von
-5 Metern und eine Höhe von Null. Wir können die Knoten umbenennen, um diese neue Anordnung
widerzuspiegeln, sodass der statische Knoten mit drei
D dem Boden entspricht
und die Mesh-Instanz Three D ein
untergeordnetes Objekt ist, und die Mesh-Instanz Three D das
ihren Standardnamen verwendet. Wenn wir jetzt
die aktuelle Szene ausführen, kollidiert
die
Kollisionsform der Figur mit der Kollisionsform des Bodens, sodass
sie nicht herunterfällt Der Boden reagiert nicht auf die Kollision, da
er statisch ist Sie die
Pfeiltasten drücken, bewegt sich der Körper des Charakters um drei D-Knoten und wenn Sie die
Leertaste drücken, springt er. Zurück im Charakterskript sagen uns
die Kommentare, dass es sich als gute Praxis bewährt hat, die
integrierten Benutzeroberflächenaktionen
durch benutzerdefinierte Gameplay-Aktionen zu ersetzen ,
die wir bereits haben. Wir können
diese beiden Zeilen also kommentieren, indem wir
Strg oder Befehl K drücken. Aber die Richtungsvariable
wird
hier innerhalb der physikalischen
Prozessfunktion deklariert . Dies wird als
Gültigkeitsbereich der Variablen bezeichnet. Es wird innerhalb
dieser Funktion deklariert und existiert
daher nur
innerhalb dieser Funktion. Wie beim
Player-Skript können
wir diese
Richtungsvariable am
Anfang des Skripts
außerhalb des physikalischen Prozesses deklarieren Richtungsvariable am
Anfang des Skripts
außerhalb des , um ihren Geltungsbereich auf
das gesamte Skript
auszudehnen. Wir setzen es auf privat,
indem wir es mit
einem Unterstrich fortführen und seinen
Typ auf Vector Three setzen,
eine Struktur, die
drei Fließkommazahlen für XYZ enthält Und bearbeiten Sie auch den Namen der Variablen innerhalb des
Physikprozesses entsprechend Um das Zeichen zu verschieben, schreiben
wir in unser
Skript
eine neue Funktion namens move, die wir einen Parameter
namens direction
vom Typ vector three akzeptieren . Dieser Richtungsparameter
unterscheidet sich von unserer
Richtungsvariablen, da dieser
keinen Unterstrich hat
und sein Zweck darin besteht,
den Wert zu speichern, der an und sein Zweck darin besteht,
den Wert zu speichern diese Bewegungsfunktion übergeben
wurde, ihm mit dem
Zuweisungsoperator
zuzuweisen Der Name dieser Funktion move hat keinen Unterstrich, sie als
öffentlich
kennzeichnet, was bedeutet, dass sie für andere Skripten
zugänglich sein soll Okay. Unser
Spielerskript ruft diese Methode auf, um
den Charakter basierend auf der empfangenen Bewegungsrichtung
zu bewegen. Wir können zwischen den
Skripten wechseln, indem wir sie in der Skriptliste links in der Skriptansicht anklicken. zum Spielerskript wechseln, können
wir eine neue Variable hinzufügen, um den Charakter der Spieler zu speichern,
die die Steuerung übernehmen. Dabei handelt es sich um eine private Variable mit
Unterstrich vom Typ Zeichenkörper drei D. Wenn Sie at export an den Anfang der
Variablendeklaration
setzen, können andere Bereiche des GDA-Editors darauf zugreifen ,
nämlich über
den Inspektor-Tab Wenn wir in der Spielszene den Spielerknoten
auswählen, wird
die
Charaktervariable im
Inspektor aufgeführt und wir
können ihr einen Wert zuweisen Da wir den Typ
der Variablen als
Charakterkörper drei D angeben , nur Knoten dieses Typs oder Knoten können
nur Knoten dieses Typs oder Knoten,
die von diesem
Typ erben, zugewiesen werden Weisen Sie dem
Charakterknoten den Wert
der Charaktervariablen im
Player-Node-Skript zu, indem Sie
entweder auf ein
Zeichen klicken und es aus
der Liste auswählen oder indem Sie auf den
Knoten klicken und ihn in das Feld ziehen Anstatt den
Wert der Bewegungsrichtung auszugeben, wollen
wir den Charakter do
move aufrufen und die
Bewegungsrichtung als Argument übergeben Aber der Typ der
Bewegungsrichtung ist ein Vektor zwei, und der Typ des
Parameters, den das Zeichen, das
sich bewegt, erwartet , ist ein Vektor Drei. Selbst wenn es sich um
denselben Typ handeln würde, wäre
dies nicht die richtige Richtung
, um den Spieler zu bewegen. Denn die Richtung, in die sich der Charakter
unserer Meinung nach bewegen wird, hängt von
der Kameraperspektive ab. Fügen wir eine weitere exportierte
Variable für die Kamera hinzu. Weisen Sie dann ihren Wert zu. Wir benennen die Bewegungsrichtung in Eingaberichtung
um und erstellen eine weitere Variable für die
Bewegungsrichtung vom Typ Vektor 3. Wie konvertieren wir die zweidimensionale
Eingaberichtung in eine dreidimensionale
Bewegungsrichtung die auf der
Kameraperspektive
basiert? Wir multiplizieren die
Basis der Kamera mit der Eingaberichtung, ähnlich wie es im Vorlagencode
gemacht wurde, aber wir werden es ein
bisschen besser machen. Nehmen Sie zuerst die rechte
Richtung der Kamera, es ist der rote Pfeil, wir mit
dem Punkt X der
Kamerapunktbasis zugreifen
und ihn mit dem Punkt x für die
Eingaberichtung multiplizieren können .
Wenn der Spieler nach rechts drückt, bewegt er sich entlang der rechten
Kamerarichtung, und wenn er nach links drückt, ist die Eingaberichtung
x negativ und rechts multipliziert mit einer negativen
Zahl wird stattdessen nach links verschoben. Fügen Sie dann mit dem Operator „
Plus gleich Vorwärtsrichtung
der Kamera hinzu, es ist ein blauer Pfeil, Kamerapunktbasis
multipliziert mit dem Punkt Y für die Eingaberichtung, wodurch die vertikale
Eingabe in eine Bewegung
entlang der Vorwärts
- und Rückwärtsrichtung der Kamera
umgewandelt wird. Die Kamera ist derzeit jedoch gedreht, da sie nach unten schaut Wenn sich der Spieler also vorwärts bewegt, bewegt er
sich leicht
nach unten in den Boden, langsamer als nach links oder rechts,
und wenn
er sich rückwärts bewegt, versucht er tatsächlich, sich
in die Luft zu bewegen, um
näher an die Kamera heranzukommen den
Basisvektor mit dem Vektor 3101 multiplizieren, werden alle Y-Komponenten entfernt sie auf
die
x-Ebene abgeflacht Dann müssen wir
den abgeflachten Vektor drei normalisieren, sodass er immer eine Länge von
eins
hat und die Bewegungsgeschwindigkeit des Spielers nicht beeinflusst Dadurch wird jeglicher Effekt der X - oder Z-Drehung in
diesen Richtungen aufgehoben, aber die Y-Drehung der Kamera verändert
weiterhin die Steuerung des
Spielers Wenn wir jetzt
die aktuelle Szene ausführen, sucht das Spielerskript in jedem Frame
nach Eingaben. Wenn wir eine
Eingabe machen,
überprüft es die Rechts
- und Vorwärtsrichtung der Kamera, glättet sie auf die rote Ebene, normalisiert sie und teilt dem Charakter anhand
der Eingabe mit, in welche Richtung er sich bewegen
soll Der
physikalische Prozess der Figur
wird sie dann in
diese Richtung bewegen Das Bewegen der Figur mithilfe der abgeflachten
Basisvektoren der Kamera ermöglicht es dem Spieler, die Kontrolle über
den Charakter aus
jedem Kamerawinkel zu
behalten , und zwar auch dann, wenn sich die Kamera bewegt oder gleichzeitig vom Spieler
gesteuert wird, da
die Bewegungsrichtung bei gleichzeitig vom Spieler
gesteuert wird, da
die Bewegungsrichtung jedem Frame
dynamisch berechnet
wird Die Trennung der Spielereingaben
von der Figur ist auch eine flexiblere Struktur, da der Charakter, den der Spieler kontrolliert,
leicht geändert werden kann Das Skript, das dem Charakter mitteilt ,
wohin er sich bewegen soll, könnte leicht mit Spiellogik
statt mit Spielereingaben
gesteuert werden . Der Spieler kann jetzt eine Kapsel
durch unsere Szene
bewegen, und in der nächsten Lektion importieren wir ein Charaktermodell, das die Kapsel
ersetzt. Wir sehen uns in der nächsten Lektion.
17. Import: Hallo Freunde. In
der vorherigen Lektion haben wir
Ihre Eingabe vorgespielt, um
eine Kapsel durch
eine Drei-D-Szene zu bewegen . In dieser Lektion ersetzen wir die Kapsel durch ein
Charaktermodell. Laden wir zunächst
ein Asset-Paket von Soto herunter. Für diesen Kurs
verwende ich die kostenlose Version von Kits Character Pack Adventurers auf Jetzt herunterladen
klickst, wirst du zur Zahlung aufgefordert, aber du kannst auf Nein Danke klicken Bring mich einfach zu den Downloads. Wir entscheiden uns optional dafür, den Künstler zu
unterstützen, indem einen beliebigen Geldbetrag
geben, den
Sie für angemessen halten. Es gibt auch kostenpflichtige Versionen
dieser Asset-Packs, die mehr Inhalte
enthalten. Ich empfehle,
sie kostenlos auszuprobieren und für die zusätzlichen Versionen
zu bezahlen,
wenn Ihnen ihre Arbeit gefällt. Klicken Sie dann auf Herunterladen
, um die Assets herunterzuladen. Während wir darauf warten, dass der
Download abgeschlossen ist, kehren
wir zur
Asset-Seite zurück und schauen uns an, was
in diesem Asset-Paket enthalten ist. Es gibt vier
Charaktere, alle mit einer Vielzahl von Waffen
und Zubehör, und jeder Charakter
ist mit
einer Vielzahl von Animationen animiert einer Vielzahl von Animationen sodass wir sie in einem
einheitlichen Format verwenden können. Die Modelle eignen sich
effizient für den Einsatz in Handyspielen und sind
mit der Cada-Engine kompatibel Diese Ressourcen sind für den
persönlichen oder kommerziellen Gebrauch
im Rahmen der Creative
Common Zero-Lizenz kostenlos persönlichen oder kommerziellen Gebrauch im Rahmen der Creative
Common Zero-Lizenz Überprüfen Sie unbedingt die
Lizenzierung der heruntergeladenen Assets , bevor
Sie
sie in Ihren Projekten verwenden. In einigen Fällen
kann eine Quellenangabe erforderlich sein, oder die Verwendung in kommerziellen Projekten
kann vollständig verboten sein Wenn der Download abgeschlossen ist, entpacken Sie den Inhalt
des komprimierten Ordners irgendwo auf Ihrer Festplatte Öffnen Sie dann den Ordner
, um zu sehen, was sich darin befindet. Wir wollen die
Charaktere verwenden und die Modelle sind
in zwei verschiedenen Formaten erhältlich. Für diesen Kurs
werde ich die GLTF-Dateien verwenden. Das Importieren der Assets
in Coda ist so
einfach wie das Klicken und Ziehen in das Editorfenster . Unser Ressourcenordner
sieht langsam etwas unübersichtlich aus, also
lassen Sie uns ihn organisieren Klicken Sie mit der rechten Maustaste auf den
Root-Ressourcenordner und erstellen Sie einen neuen Ordner Nennen wir diesen Ordner
importierte Assets. Erstellen Sie dann
innerhalb dieses Ordners einen weiteren Ordner mit dem Namen Characters. Wählen Sie
die importierten
Charakterelemente in einer Gruppe aus und ziehen Sie sie in diesen neuen Ordner. Okay. Wir können auch einen neuen Ordner im
Root-Ressourcenordner zum Speichern von
Skripten und einen anderen für Szenen
erstellen Root-Ressourcenordner zum Speichern von
Skripten . Die Skripte haben ein Zahnradsymbol
und die Erweiterung GD. Szenen haben zwar das Brettsymbol und ihre Erweiterung ist TCN Sie können Ihre
Ressourcen organisieren, aber Sie
sinnvoll und passt sich am besten Ihrem
Arbeitsablauf an Bevor wir mit
den importierten Assets arbeiten können, müssen
wir einige
Importeinstellungen bearbeiten Wählen Sie auf der Registerkarte „Dateisystem“ eine
der
GLB-Zeichendateien Registerkarte „Dateisystem“ eine
der Wechseln Sie dann von dem Dokument
, in dem gerade
die
Registerkarte Szene angezeigt wird , zur Registerkarte Import Hier können wir bearbeiten,
wie der God-Editor die Dateien
interpretiert und die importierten Assets
generiert Die meisten dieser Einstellungen sind für unsere Zwecke
in Ordnung. Als Erstes fügen wir den Stammtyp des Hauptteils von Charakter drei
D hinzu. Standardmäßig wurde
der Charakter
als Knoten drei D importiert . Aber wir möchten Stammknoten
unseres Charakters ein Charakterkörper drei D ist, um
mit unserem Zeichenskript kompatibel zu sein. Wenn wir eine
der Einstellungen ändern, werden
sie nicht aktualisiert,
es sei denn, wir importieren das Asset erneut. Klicken Sie anschließend auf die Schaltfläche
Erweitert. Das Fenster mit den erweiterten
Importeinstellungen wird geöffnet, und wir können eine Vorschau sehen, wie das importierte Asset aussehen
wird. Sie können mit
dem Mausrad ein- und auszoomen oder klicken und ziehen, um das
Modell zu drehen und eine bessere Ansicht zu erhalten. der linken Seite befindet sich der Szenenbaum , der
von diesem Objekt generiert wird umfasst ein Skelett, Knochen ,
Netze und einen Animations-Player
mit allen Animationen Bevor wir mit
diesem Charaktermodell arbeiten können, müssen
wir zulassen, dass bestimmte
Animationen wiederholt werden. Fangen wir mit
der Animation im Leerlauf an. Wenn die inaktive
Animation ausgewählt ist, können
wir mit
der Play-Schaltfläche
unten im Fenster eine Vorschau anzeigen, wie sie aussehen
wird . Aber es wird nur
einmal abgespielt und dann gestoppt, was genau das Problem ist. Auf der rechten Seite können wir
die Importeinstellungen
für die Animation ändern und den Loop-Modus auf linear
umstellen. Wenn wir jetzt auf Play klicken und
die Animation beendet
ist, kehrt sie zum
Start zurück und wird erneut abgespielt. Ping Pong
spielt die Animation stattdessen rückwärts ab, um zum Start zurückzukehren, und danach wieder vorwärts Stellen wir es auf linear ein.
Wiederholen Sie den Vorgang dann für alle Animationen
in dieser Liste, die das Wort inaktiv,
blockierend oder laufend
enthalten. In diesem Kurs wird das nicht behandelt, aber vielleicht möchten
Sie auch
Looping beim Schießen,
Drehen, Blocken
und Zaubersprechen zulassen Drehen, Blocken
und Zaubersprechen Wenn Sie fertig sind, klicken Sie auf
die Schaltfläche „Erneut importieren“, um die Elemente mit den
aktualisierten Animationseinstellungen erneut zu
importieren Sie müssen
diesen Vorgang für
die anderen Charaktere wiederholen ,
bevor Sie sie verwenden können. Wechselt zur Charakterszene. Klicken Sie auf das
Charakterobjekt und ziehen Sie es auf den Stammknoten
der Charakterszene , um es dem Szenenbaum hinzuzufügen. Lassen Sie uns die Vorschaubeleuchtung einschalten damit wir unseren
importierten Charakter
besser sehen können , und den
Mesh-Instanzknoten löschen der das Kapselnetz
zeichnet. Der Barbarenknoten
ist nur ein Knoten, nicht der große Knotenbaum, den wir in den Importeinstellungen
gesehen haben, und er hat das
Klapperbrettsymbol,
was bedeutet, dass es sich um eine
Instanz einer anderen Szene handelt So wie wir die
Charakterszene aus der Spielszene erstellt haben. Wir können das auch umgekehrt machen. Klicken Sie mit der rechten Maustaste auf den Barbaren
und wählen Sie Lokal erstellen. Dadurch wird die
Verbindung zwischen diesem Knoten und
dem importierten Asset unterbrochen und es wird eine
einzigartige Version daraus , die nur in dieser
Szene existiert Und jetzt können wir alle
untergeordneten Knoten sehen. Die Animationen sind
im
Animation-Player-Knoten enthalten . Lassen Sie uns den Rig-Knoten
vorerst zusammenklappen, um das meiste davon zu verbergen. Als Nächstes wollen wir, dass der Barbar der
Wurzelknoten der Szene Wir können erneut mit der rechten Maustaste darauf klicken
und Make seen root auswählen , um den
Szenenbaum so zu organisieren, dass er der neue
Szenenwurzelknoten wird Als Nächstes klicken wir auf den
dritten D-Knoten der Kollisionsform und
ziehen ihn so, dass er dem Barbaren-Knoten zugewiesen Machen Sie dies zur
Kollisionsform für den Barbaren und löschen Sie den ursprünglichen Drei-D-Knoten des
Charakters,
da er jetzt überflüssig ist Wir benötigen jedoch immer noch ein Zeichenskript, das an den Wurzelknoten
angehängt ist Wir können es auch hinzufügen, indem es
anklicken und auf den Stammknoten ziehen Unser Szenenbaum sieht
immer noch genauso aus wie zuvor. Nur der Knoten
Mesh
Instance Three D wurde jetzt durch
den Character Rig ersetzt, und es gibt einen
Animations-Player-Knoten. Unser Charakter scheint viel zu viele Gegenstände
in den Händen zu halten. Erweitern Sie den Rig-Knoten
, um seine untergeordneten Elemente anzuzeigen. Wir können alle
Gegenstände verstecken, die sich in
den Händen des Charakters befinden, indem wir auf das Symbol neben ihnen klicken. Wir können auch den Hut und das
P des
Charakters für alle Charaktere
außer dem Schurken verstecken P des
Charakters für alle Charaktere
außer dem Schurken Der Schurke hat ein völlig
anderes Modell, wenn
die Kapuze geöffnet ist, da die
Haare auch Abhängig von der Version von Coda oder den von Ihnen verwendeten Assets kann ein rotes X-Symbol
angezeigt werden, das darauf hinweist , dass ein
Problem mit diesem Asset vorliegt es auswählen und
in den Importeinstellungen nachschauen, können
wir die
GLTF-Benennungsversion auf
4.1 oder früher ändern und
das Asset erneut importieren, um dieses Problem zu beheben Wenn Sie fertig sind, lassen Sie
das Bohrgerät erneut zusammenklappen. Wenn wir die
Charakterszene über
das Szenenmenü speichern oder Strg S oder Befehl
S drücken , wechseln wir dann
zur Spielszene. Wir können sehen, dass der Charakter
in unserer Spielszene aktualisiert
wurde , wenn wir diese Szene ausführen Wir können den Charakter
wie zuvor bewegen, aber er
bewegt sich unbeholfen in Wir haben jetzt das Charaktermodell in unser Projekt importiert In der nächsten Lektion
animieren wir unseren Charakter beim Gehen. Wir sehen uns in der nächsten Lektion.
18. KayKit Update: Hallo Freunde. Das in diesem Kurs
verwendete KayKit-Charakter-Asset-Paket wurde aktualisiert trennt nun die
Charaktermodelle von den Animationen ist für uns flexibler
und effizienter, erfordert
aber einige zusätzliche Schritte Zunächst können Sie
die Charaktermodelle auf die gleiche Weise in
die Engine importieren die Charaktermodelle auf die gleiche Weise in
die Engine Klicken Sie sie einfach an und ziehen Sie sie
in das Editorfenster. Die Animationen und die gespeicherten Elemente befinden sich jetzt in separaten Ordnern, sodass sie ebenfalls importiert werden müssen. Es ist eine gute Idee,
sie in separate Ordner zu importieren. Wählen Sie die importierten Animationen und wechseln Sie dann von der
Registerkarte Szene zur Registerkarte Import. Sie im Drop-down-Menü Importieren als Wechseln Sie im Drop-down-Menü Importieren als zur Szene in die
Animationsbibliothek klicken Sie
dann auf die Schaltfläche „
Erneut importieren“ Klicken Sie anschließend auf die Schaltfläche
Erweitert. Klicken Sie in diesem Fenster auf die Schaltfläche Aktionen und wählen Sie Speicherpfade für Animationen
festlegen. Sie können diesen Ordner auswählen oder für jede Bibliothek einen neuen
erstellen. Klicken Sie auf „Ordner auswählen“
und anschließend auf „Erneut
importieren“, um alle Animationen als einzelne Projektelemente Wir benötigen sowohl die einzelnen
Animationen, die
in die Engine importiert wurden , um sie
bearbeiten und
unsere eigenen Spuren hinzufügen zu können, als auch die Bibliotheken, um sie
unserem Animationsplayer hinzufügen zu
können Da die Animationen
als Projektressourcen gespeichert
sind, können wir auch ihren Loop-Modus
etwas einfacher einstellen. Jede Animation, die „Idle“
enthält oder deren Name im
Präsens Continuous Tense
steht, sollte in einer Endlosschleife wiedergegeben werden Für die Charaktermodelle müssen
wir nur
den Stammtyp auf
Körper drei
D ändern den Stammtyp auf
Körper drei . Es ist nicht erforderlich , die
erweiterten Importeinstellungen zu ändern Wir können
dieses Modell entweder in
eine Szene mit drei D ziehen und es lokal machen, wodurch die Verbindung
zum importierten Objekt unterbrochen Oder wir können
aus dem importierten
Charaktermodell eine
neue geerbte Szene erstellen aus dem importierten
Charaktermodell Wenn Sie eine geerbte Szene verwenden, Ihre Möglichkeiten, das
importierte Modell zu bearbeiten, eingeschränkt. In beiden Fällen können wir der Szene
einen
Animation-Player-Knoten hinzufügen . im Animationsfenster Klicken Sie im Animationsfenster auf die Animationsschaltfläche und wählen Sie
dann Animationen verwalten aus. Klicken Sie auf die Schaltfläche „
Bibliothek laden“ und wählen Sie
dann die
Animationsbibliotheken aus, die importiert wurden. Dadurch werden alle in dieser Bibliothek
enthaltenen Animationen hinzugefügt. All diese Animationen funktionieren jetzt mit dem
Charaktermodell. Wenn Ihre Animationen
das Charakterskelett nicht finden , um es
zu animieren,
stellen Sie sicher, dass die Struktur Ihrer Charakterszene mit dem Knotenpfad in den Animationsspuren
übereinstimmt , wobei
der Rig-Medium-Node ein direktes untergeordnetes Element des Stammknotens der
Figur ist im Animationsbaum Animationen, Wenn Sie im Animationsbaum Animationen,
die Teil
einer Animationsbibliothek sind, zu einer
Zustandsmaschinenressource hinzufügen , der Name der Animationsbibliothek wird
der Name der Animationsbibliothek
in den Namen des Knotens aufgenommen Aber wir können es leicht ändern
, damit es leichter lesbar ist. Die Kampfanimationen sind in
diesem Asset-Paket
nicht mehr enthalten, aber sie sind weiterhin kostenlos
erhältlich. Sie müssen nur das
Charakter-Animationspaket separat herunterladen . Folgen Sie dann den gleichen Schritten
, um diese Animationen
als Bibliotheken zu importieren und sie
dem Animation-Player-Knoten hinzuzufügen. Sie nun alle
Ihre Charaktere
und Animationen ordnungsgemäß
importiert haben , können
Sie
mit dem Rest
des Kurses fortfahren . Wir sehen uns
im nächsten Video.
19. Wandern: Hallo Freunde. In
der vorherigen Lektion haben wir
Charaktermodelle in Cada importiert In dieser Lektion animieren wir
die Figur so, dass sie sich in unserer Szene
bewegt Bewegen wir zunächst
die Kamera ein wenig nach hinten da die Figur
größer ist als die Kapsel Die Bewegungen der Charaktere
sind sehr starr. Der Charakter bewegt sich entweder mit voller
Geschwindigkeit oder gar nicht. Das fühlt sich nicht sehr gut an und so bewegt sich
auch nichts. Anhalten sollte bis zu Vor dem
Anhalten sollte bis zu
einer Höchstgeschwindigkeit beschleunigt und
gebremst werden das Skript öffnen, können
wir sehen, dass die Zeichengeschwindigkeit als konstant
deklariert ist Deklarieren wir stattdessen einige
exportierte private Variablen , um zu definieren, wie sich unser
Charakter bewegt. Beginnend mit ihrer
Gehgeschwindigkeit gemessen in Einheiten pro Sekunde, die sich am besten als Float
darstellen lässt. Wir können Variablen
einen Standardwert zuweisen, indem wir
den Zuweisungsoperator verwenden ,
der sich in derselben Zeile befindet, als sie
deklariert wurden. Ich setze es auf eins. Wir wollen auch Beschleunigungs
- und Verzögerungswerte in Einheiten
pro Quadratsekunde
messen Auch Float-Typen. Überlegen Sie, wie schnell
Sie vom
Stehen im Leerlauf zum
Gehen mit voller Geschwindigkeit wechseln würden . Ungefähr eine halbe Sekunde
klingt vernünftig, was einer Beschleunigung um das
Doppelte der Gehgeschwindigkeit entspricht. Und auch, wie schnell
Sie beim
Gehen
mit voller Geschwindigkeit komplett zum Stillstand kommen würden . Das ist normalerweise schneller als Beschleunigung, also mache
ich vier. den Wurzelknoten der
Barbaren auswählen, können
wir die
exportierten Variablen sehen im
Inspektor-Tab bearbeitet werden diese Zahlen bearbeiten
, werden
die im Skript angegebenen Standardwerte
überschrieben die im Skript angegebenen Standardwerte Durch Drücken der Reset-Taste
werden sie jedoch auf
ihre Standardwerte zurückgesetzt Dies ermöglicht es uns, einfach mit verschiedenen
Werten zu experimentieren, und
bietet auch die Möglichkeit verschiedene Charaktere
unterschiedliche Bewegungsgeschwindigkeiten haben. Um es einfacher zu machen, können wir Geschwindigkeit der
Charaktere auf
der X-Z-Ebene von der
Geschwindigkeit entlang der Y-Achse
trennen , sodass wir
Anpassungen der
Bewegungsgeschwindigkeit von Dingen
wie Springen und Schwerkraft isolieren können. Deklarieren wir eine weitere private
Variable, die X-Z-Geschwindigkeit vom Typ Vector Three. Zu Beginn des
physikalischen Prozesses können
wir den Wert der
X-Geschwindigkeit auf einen
neuen Vektor Drei setzen , Geschwindigkeit des Charakters auf der X- und Z-Achse
kopieren gleichzeitig den
Y-Wert auf Null setzen. Wir können hier dann unsere
Anpassungen an der
X-Z-Geschwindigkeit der Charaktere vornehmen , ohne Gedanken über die Auswirkung
ihrer Y-Geschwindigkeit machen zu müssen. Dann, am Ende des physikalischen Prozesses, vor dem Verschieben der Bewegung, können
wir die Geschwindigkeit
der
Charaktere so einstellen dass sie den angepassten
Werten für X und Z entspricht, aber den gleichen Wert
wie für Y. Diese Methode wird uns
später auch
zusätzliche Vorteile bieten . Okay. Als Nächstes
müssen wir diesen Codeblock bearbeiten ,
der
den Charakter bewegt. Die Erklärung teilt
dies in zwei Fälle auf. Ob der Spieler eine
Bewegungsrichtung angibt oder nicht. Anstatt die Geschwindigkeit in X- und Z-Komponenten zu
zerlegen , wir die
X-Z-Geschwindigkeit einfach hier direkt bearbeiten,
da
wir die Y-Geschwindigkeit entfernt können wir die
X-Z-Geschwindigkeit einfach hier direkt bearbeiten,
da
wir die Y-Geschwindigkeit entfernt haben. Wenn der Spieler
eine Bewegungsrichtung angibt, sollten
wir der Bewegung in Richtung
X eine
Z-Geschwindigkeit zuweisen multipliziert mit der
Gehgeschwindigkeit bei einer Geschwindigkeit von
Beschleunigung mal Delta Dabei wird ihre
aktuelle Geschwindigkeit entlang
der X-Z-Ebene in Richtung ihrer Gehgeschwindigkeit
in die Richtung bewegt , in die der Spieler mit
einer Beschleunigungsrate fahren möchte Denn Delta ist die
Zeit , die seit
dem letzten Frame vergangen ist, normalerweise eine 60stel-Sekunde Es passt die Beschleunigung
an die Bildrate an,
was dazu führt, dass der Charakter beschleunigt und sich mit den angegebenen
Geschwindigkeiten bewegt,
unabhängig davon, auf welche Bildrate im
Spiel eingestellt ist Ebenso sollte der Charakter, wenn keine
Bewegungseingabe
erfolgt, bei einer mit Delta multiplizierten
Verzögerungsrate auf eine Geschwindigkeit von Null abbremsen Wir können die ursprüngliche
Geschwindigkeitskonstante jetzt löschen , da sie nicht mehr verwendet wird Lass uns zur Spielszene wechseln und versuchen, den
Charakter jetzt zu bewegen. Jetzt
beschleunigt der Charakter auf Schrittgeschwindigkeit und
bremst auf natürlichere Weise ab. Zurück in der Charakterszene können
wir zur
Drei-D-Ansicht wechseln, damit wir den Charakter sehen können Wählen Sie den
Animations-Player-Knoten aus und der Animations-Tab wird unten im Fenster geöffnet. Die Animation, die
gerade angezeigt wird, ist ein einhändiger männlicher Angriff, und das Charaktermodell hat den ersten Frame
der Animation
angenommen. Wir können die
Play-Taste oben im Animations-Tab drücken , um
eine Vorschau der Animation anzuzeigen. den Animations-Tab erweitern und durch die
Animationsspuren blättern, können
wir sehen, dass jeder Bone mit einem
Keyframe versehen ist , um eine
resultierende Animation zu erzeugen Sie mit dem Zoom-Schieberegler Passen Sie mit dem Zoom-Schieberegler die
Zeitdauer an, die auf der Registerkarte „Animation“ angezeigt wird , sodass Sie jeden einzelnen
Keyframe sehen können jeden einzelnen
Keyframe sehen Mithilfe der Dropdownliste können
wir alle Animationen auswählen,
die importiert wurden, einschließlich der Animationen im Leerlauf Und bei der Vorschau dieser Animation, da wir
die Importeinstellungen konfiguriert haben, läuft
die Animation in einer Endlosschleife ab Der Animation-Player-Knoten
kann also jede
dieser Animationen abspielen Wir müssen nur kontrollieren,
welche Animation abgespielt wird. Sie können dies
über ein Skript tun, aber der Code wird
sehr lang sein und zu
viele Möglichkeiten
berücksichtigen müssen . Die beste Methode, um zu kontrollieren
, welche Animation abgespielt wird, ist die Verwendung eines
anderen Knotens, wir zu unserer
Charakterszene hinzufügen können, einen Animationsbaum. Dem Animationsbaum
muss mitgeteilt werden , welchen Animationsspieler
er steuert. also auf das zugewiesene
Feld neben dem Anim-Player klicken, können
wir den
Animations-Player-Knoten aus der Liste auswählen Als Nächstes müssen wir eine
Ressource für diesen Knoten bereitstellen, genau wie wir es mit
den Mesh-Instanzen und
den Kollisionsformen getan haben den Mesh-Instanzen und
den Kollisionsformen Diese Ressource wird
als Zustandsmaschine bezeichnet. Beim Erstellen der
Zustandsmaschine öffnen wir die Registerkarte
Animationsbaum am
unteren Rand des Editorfensters. Wir können den Viewport
dieses Fensters schwenken , indem wir ihn bei gedrücktem
Mausrad ziehen Die Zustandsmaschine verfolgt in
welchem Zustand sich der Charakter
befindet, und spielt die richtige Animation
für diesen Zustand ab oder mischt sogar mehrere
Animationen zusammen Wir müssen der
Zustandsmaschine lediglich mitteilen, um welche Zustände es sich handelt und wie und wann der Charakter zwischen den Zuständen
wechseln wird. Vorerst werden wir
nur einen Zustand haben, dem die Animationen „Leerlauf“
und „Gehen“ miteinander verschmelzen . Wenn der Charakter aus dem Leerlauf
zu laufen beginnt, sollte
er nicht
sofort
vom Leerlauf zum Gehen übergehen , und er sollte auch nicht sofort zurückkehren, wenn er aufhört. Ganz zu schweigen davon, dass der
Spieler
den linken Stick leicht neigen kann , um
sich langsamer zu bewegen, wenn er möchte. des
Charakters müssen die Animationen im Leerlauf und
beim Gehen
miteinander verschmelzen Je nach Bewegungsgeschwindigkeit des
Charakters müssen die Animationen im Leerlauf und
beim Gehen
miteinander verschmelzen. Das kann
mit einem Blend Space erreicht werden. rechten Maustaste auf einen leeren Raum, fügen Sie der Zustandsmaschine einen eindimensionalen
Verschmelzungsraum und nennen Sie ihn Locomotion Klicken Sie dann auf das Tool
Connect Nodes. Klicken und ziehen Sie vom
Start zur Fortbewegung. Dies wird zum
Standardstatus, in
dem der Charakter startet
, wenn wir das Spiel starten Wechsle zurück, um Knoten auszuwählen
und zu verschieben. Klicken Sie dann auf den Stift, um den Locomotion-Blend-Raum zu bearbeiten Ein eindimensionaler
Verschmelzungsraum hat eine Achse, die
horizontal angezeigt wird und von einem
negativen bis zu
einem positiven benannten Wert Wenn wir das als Geschwindigkeit des
Zeichens betrachten, können
wir ihn in Geschwindigkeit umbenennen und seinen Minimalwert
auf Null und seinen
Maximalwert auf Eins setzen . In diesem Fall
sollte von einer Geschwindigkeit von 100% ausgegangen
werden ,
nicht von einer Geschwindigkeit von einer
Einheit pro Sekunde. können wir
dem Mischbereich Animationen hinzufügen Werkzeug „Punkte erstellen“ können wir
dem Mischbereich Animationen hinzufügen. Bei Null drüber klicken. Wir können die Leerlaufanimation hinzufügen. Erstens die Animation beim Gehen. Klicken Sie auf Stellen Sie die
Überblendungsposition innerhalb des Raums ein. Klicken Sie dann auf eine beliebige Stelle auf der
Achse, um zu sehen, wie die Animation bei dieser Geschwindigkeit
aussieht Sie können auch klicken und
ziehen, um zu sehen, wie eine Änderung der Geschwindigkeit im Laufe der Zeit
die Animationen zusammenfügt. Okay. Jetzt brauchen wir nur noch das Zeichenskript, um
dem Animationsbaum die Geschwindigkeit
der Charaktere
mitzuteilen. Knoten können
einfach
miteinander kommunizieren , indem wir
sie Variablen zuweisen, und wir können das alles in
einer Zeile unseres Skripts tun at on ready zu
Beginn der Deklaration
verwenden Nennen wir diese Variable, unterstreichen wir eine Animation
vom Typ Animationsbaum und weisen ihr einen Wert zu Mithilfe des Dollarzeichens können
wir dann
einen Knotenpfad angeben, um auf jeden
Knoten im Szenenbaum zuzugreifen, ausgehend von diesem Knoten, an
den das Skript angehängt ist Wenn der Knoten, auf den wir
zugreifen möchten, ein untergeordneter Knoten dieses Knotens ist, geben
wir einfach
den Namen des Knotens an. können einer Reihenfolge von
Knoten folgen, indem die Knotennamen
durch einen Schrägstrich
trennen Wenn der Name des
Knotens Leerzeichen enthält, können
Sie den
Knotenpfad in Anführungszeichen setzen Wenn Sie sich
bezüglich des Knotenpfads nicht sicher sind, können
Sie auf einen beliebigen Knoten in
der Szenenstruktur klicken und Knotenpfad kopieren
auswählen. Fügen Sie ihn dann als Text ein. Unser Skript enthält jetzt einen Verweis auf den Animationsbaumknoten. Alles, was wir tun müssen, ist die Position
des Blend-Spaces nach
unseren X-Z-Geschwindigkeitsberechnungen festzulegen Position
des Blend-Spaces nach . Mithilfe der Variablen können
wir auf
die Set-Methode zugreifen , um
eine beliebige Eigenschaft festzulegen. Die Eigenschaft, die wir setzen möchten,
ist als Zeichenfolge definiert, die einen Pfad
zur Eigenschaft darstellt dasselbe Format
wie der Knotenpfad
verwendet. Wir können die Vorschläge verwenden
, um diesen Parameter automatisch zu füllen und dabei nach unserer Bewegungszustandsposition
zu suchen Wie beim Knotenpfad können
wir, wenn wir den
Animationsbaum im Szenenbaum auswählen, wenn wir den
Animationsbaum im Szenenbaum auswählen, Parameter und
Fortbewegung erweitern und
den Eigenschaftspfad kopieren Fügen Sie es dann als Text ein. Geben Sie dann den Wert an, auf den wir diese Eigenschaft setzen
möchten. Dabei handelt es
sich um einen Wert von
0-1,
der den Prozentsatz
der
maximalen Geschwindigkeit des Charakters darstellt der den Prozentsatz
der
maximalen Geschwindigkeit des Charakters , mit dem
er sich bewegt Da die D-Geschwindigkeit ein Vektor
ist, können
wir die
Längenmethode verwenden, um genau zu wissen wie schnell sich die Figur entlang der D-Ebene
bewegt Teilen Sie dies dann durch
ihre Gehgeschwindigkeit , um daraus eine Zahl von 0 bis 1 Mal sehen, wie das aussieht
, wenn wir die Spielszene ausführen. Jetzt wechselt die Figur in
Abhängigkeit von ihrer Geschwindigkeit auf der x-d-Ebene
zwischen der Animation im Leerlauf und der Laufanimation , aber sie drehen sich nicht entsprechend der Bewegungsrichtung
. Experimentieren Sie
mit verschiedenen Werten für
Gehgeschwindigkeit,
Beschleunigung und Verzögerung der Figur, um zu sehen, wie In der nächsten Lektion werden wir Rotationen und
Springen hinzufügen. Wir sehen uns in der nächsten Lektion. Okay.
20. Drehung: Hallo Freunde. In
der vorherigen Lektion haben wir die Fortbewegung unseres
Charakters animiert In dieser Lektion drehen wir
das Charaktermodell so, dass es in die Richtung
schaut, in die
sie sich bewegt. Ausgehend vom
Charakterskript können wir, wenn der Spieler die
Bewegungsrichtung eingibt
, wenn der Spieler die
Bewegungsrichtung eingibt
, diesem Knoten einfach
sagen, dass er sich seine aktuelle Position und die
Richtung
ansehen soll . Dadurch wird der
Körper des Charakters um drei D-Knoten gedreht , sodass vorderer Basisvektor direkt
auf
diese Koordinaten zeigt. Da wir die
Richtung auf
diese X-Ebene beschränkt haben, wird das dazu führen, dass der Charakter
immer nur um die Y-Achse gedreht wird, sodass er in die Richtung zeigt, in die sich der
Spieler bewegen möchte. Die Drehung erfolgt jedoch
sofort und zeigt den Charakter in
die entgegengesetzte Richtung. Da Gudo die Z-Achse umkehrt, können
wir das korrigieren,
indem wir einfach die Plus-Richtung in
die Minus-Richtung
ändern die Minus-Richtung Außerdem, wenn wir in
der
Spielszene irgendwelche Verbindungen haben, die dem Charakter in der Kindheit ähneln, wie
zum Beispiel die Kamera , dann wird sie auch bewegt und gedreht,
was wir nicht Die Lösung
wird nicht ausreichen. Okay. In der Charakterszene können
wir sehen, dass alle
visuellen Komponenten
des Charakters Kinder
eines Knoten-Dreie-Dreies namens Rig sind. im Szenenbaum ein Rig auswählen, können
wir seine Transformation bearbeiten, indem wir auf den Schieberegler
für
die Y-Drehung klicken und ihn ziehen , um das
Charaktermodell um die Y-Achse zu drehen Auf diese Weise kann das
Charaktermodell unabhängig vom Körper
der Figur um drei D
gedreht werden , sodass es keine Auswirkungen auf andere
Kinder in der Spielszene Im Charakterskript können
wir, ähnlich wie beim
Animationsbaum, at on ready verwenden, um
einen Verweis auf den Rig-Knoten
in einer privaten Variablen zu speichern . Wenn wir dann die
Bewegungsgeschwindigkeit der Figur erhöhen, können
wir dem Rig auch sagen, dass es
sich ansehen soll, wohin es sich bewegt. Der Charakter
zeigt jetzt in die Richtung er sich bewegt, ohne andere Knoten zu
beeinflussen. Aber die sofortige Rotation ist
vielleicht nicht das, wonach
wir suchen. Lassen Sie uns also dafür sorgen, dass sich der Charakter jedem Frame ein wenig
dreht. Wir können die
Rotationsgeschwindigkeit eines Charakters als
exportierte private Variable definieren und ihr einen Standardwert geben. Game-Engines berechnen
Rotationen normalerweise in Radiant,
nicht Falls Sie
mit Radiant nicht vertraut Ein vollständiger Kreis von 360
Grad ist Pi mal Es gibt auch eine weitere
mathematische Konstante namens T, die Pi mal zwei ist Wenn wir jedoch den
Anwendungsfall für diesen Wert betrachten, es
uns nur darum
, wie schnell das Zeichen um
bis zu 180 Grad drehen wird. Andernfalls würden sie
sich einfach in die
entgegengesetzte Richtung drehen. Wir können also den Wert der exportierten
Variablen
als Vielfaches von Pi definieren Wert der exportierten
Variablen
als Vielfaches von Pi oder wie viele halbe Umdrehungen der Charakter in 1 Sekunde
machen kann umgekehrte Wert gibt an
, wie lange sich
der Charakter
um die Hälfte dreht Alternativ kannst du die
Rotationsgeschwindigkeit
deines Charakters in
Grad definieren Rotationsgeschwindigkeit
deines Charakters in und sie mit der Funktion „Grad in
Strahlkraft“ umrechnen, wenn
das Spiel beginnt Ich verwende die
Pi-Methode und sage, dass mein Charakter in der Lage sein sollte, in einer halben Sekunde
umzudrehen, sodass die Rotationsgeschwindigkeit
Pi mal zwei ergibt. Okay. Im physikalischen Prozess müssen
wir, wenn der Charakter Bewegungseingaben
gibt, wenn der Charakter Bewegungseingaben
gibt, zuerst herausfinden, um welchen Winkel wir uns drehen. Wir nennen das
den Zielwinkel. Wir können unseren
Zielwinkel mit Hilfe der Trigonometrie ermitteln. Wenn der Zielwinkel Theta ist,
was in diesem Fall Y-Drehung
eines
in die Richtung gerichteten Objekts
darstellt , können
wir ihn mit der umgekehrten Tangensfunktion A bis zwei. Dazu werden
zwei Float-Argumente benötigt, bei denen es sich um Richtungspunkt-X-Werte
und Richtungspunkt-Z-Werte handelt. Jetzt
enthält der Zielwinkel den Wert, auf den
wir unsere Y-Drehung schrittweise
verschieben möchten. Als Nächstes benötigen wir die Differenz
zwischen diesen beiden Winkeln, ausgedrückt als Zahl zwischen negativem Pi und positivem Pi. Sie sagt uns, wie weit und in welche Richtung wir
drehen müssen . unsere aktuelle
Y-Drehung vom
Zielwinkel subtrahieren , erhalten Sie die Differenz zwischen
den beiden Um sicherzustellen, dass das
Zeichen
immer nur auf
dem kürzesten Weg rotiert, wickeln
wir dieses Ergebnis anschließend
mit der Funktion rap f ab. Dabei
stellen wir sicher, dass das
Ergebnis immer zwischen
dem Wert von negativem
Pi und positivem Pi liegt dem Wert von negativem
Pi und positivem Pi Wir haben jetzt alle
magischen Zahlen, wir müssen den Charakter drehen,
aber wie verwenden wir sie Wir können
die Richtung
der Drehung mit einer
Funktion namens Sinus bestimmen , wobei die
Winkeldifferenz als Argument übergeben wird. Dies gibt negativ eins zurück, wenn die Zahl negativ ist, Null, wenn sie Null ist, und positiv eins, wenn es sich um
eine positive Zahl handelt. Wenn wir das mit der
Rotationsgeschwindigkeit
und Delta multiplizieren, dann
wissen wir, um wie viel und in welche
Richtung sie sich in einem einzigen Bild
drehen können . das zu ihrer Y-Rotation hinzufügen, drehen
wir den Charakter, überschreiten
aber auch
den Zielwinkel also eine Klammerfunktion hinzufügen, können
wir den Wert
Drehzahl mal Delta , dass er nur zwischen Null und absoluten Wert
der Winkeldifferenz Beim Absolutwert wird
der Sinus entfernt, sodass eine negative Zahl positiv
wird Dann mit dem Sinus multipliziert, um
sicherzustellen, dass sich das Zeichen
in die richtige Richtung dreht Dadurch wird verhindert, dass die
Figur über die Drehung hinausschießt, und
stoppt im Zielwinkel Um dies effizienter zu gestalten, können wir, da wir den Zielwinkel bei der Berechnung
der Winkeldifferenz nur
einmal
verwenden , seine Berechnung kopieren und
in dieselbe Zeile einfügen, sodass
wir eine Variable weniger
haben Und da dieser Prozess 60 Mal pro Sekunde
läuft, sollte
er keine Variablen
deklarieren Also verschieben wir die
Variablendeklaration an den
Anfang des Skripts Schließlich müssen wir
die untenstehende Lookout-Zeile entfernen , da
sie nicht mehr relevant ist. Jetzt dreht sich der Charakter schrittweise, sodass er der Eingaberichtung des
Spielers zugewandt Und wir können im Inspektor ändern, wie schnell
sie sich drehen. Als Nächstes fügen wir eine
Run-Taste hinzu, die der Spieler
gedrückt halten kann, um schneller zu werden. Öffnen Sie die Projekteinstellungen und wechseln Sie zur Registerkarte Eingabekarte. Fügen Sie eine Ausführungsaktion hinzu. Ich verwende die Umschalttaste
oder die linke Taste. Im Player-Skript können wir
mit einer anderen Funktion, der
Unterstrich-Eingabe,
effizienter auf die einzelnen
Tastendrücke
reagieren nämlich der
Unterstrich-Eingabe,
effizienter auf die einzelnen
Tastendrücke
reagieren als bei den Bewegungseingaben nämlich der
Unterstrich-Eingabe,
effizienter auf die einzelnen
Tastendrücke
reagieren als bei den Bewegungseingaben Diese Funktion wird
nur während
Frames aufgerufen , wenn ein
Eingabeereignis stattfindet Anstelle von Delta ist der Eingabeparameter ein Eingabeereignis, d. h. eine Struktur, die
Informationen darüber enthält, um
welches
Ereignis es sich handelt . In dieser Funktion können
wir dann
diese Struktur überprüfen, um festzustellen, ob
die Run-Taste gedrückt wurde. Wenn ja, können wir
dem Charakter sagen, dass er rennen soll. Okay. Ebenso können wir auch überprüfen, ob die
Run-Taste losgelassen wurde. Und wenn ja, sag dem
Charakter, er soll gehen. Im
Zeichenskript können wir
eine Laufgeschwindigkeit hinzufügen , die zur
Gehgeschwindigkeit passt. Fügen Sie dann eine weitere nicht exportierte private Variable namens
Bewegungsgeschwindigkeit mit einem
Standardwert für die Gehgeschwindigkeit hinzu. In den Funktionen Gehen und
Laufen müssen wir lediglich den Wert
der Bewegungsgeschwindigkeit so einstellen , dass der entsprechenden Gehgeschwindigkeit oder
Laufgeschwindigkeit entspricht. Verwenden Sie dann die Bewegungsgeschwindigkeit
in unseren Geschwindigkeitsberechnungen. Bei
der Bestimmung der Überblendposition für die
Bewegungsanimationen des Charakters verwenden
wir jedoch die Laufgeschwindigkeit den
Animationsbaum der Figur auswählen, können
wir dann den
Bewegungsblendenbereich bearbeiten Wenn wir nun
einen Geschwindigkeitswert von
eins so betrachten , dass der Charakter mit voller Geschwindigkeit
läuft Wir können das Werkzeug „Punkte auswählen
und verschieben“ verwenden, um unsere Laufanimation
näher an die Mitte
der Achse zu
bewegen und
eine weitere Animation
ganz rechts
für unsere laufende Animation hinzufügen eine weitere Animation
ganz rechts , indem wir
entweder
zum Werkzeug „
Punkte erstellen“ wechseln oder mit der rechten Maustaste klicken. Bei jedem Geschwindigkeitswert werden im Verschmelzungsbereich
die
Animation, die sich am nächsten links
und rechts befindet,
miteinander
verschmolzen die sich am nächsten links
und rechts befindet,
miteinander . Dabei wird
die Animation entsprechend
ihrer Nähe gewichtet . Zurück in der Spielszene,
bevor wir einen Lauf testen, möchten
wir unserem
Charakter vielleicht etwas mehr Platz geben. also das Stockwerk auswählen, können
wir die Größe
des Stockwerks und all
seiner untergeordneten Stockwerke schnell ändern , indem wir den Maßstab
erhöhen. Wenn wir nun die Spielszene ausführen, kann
der Charakter nicht nur in der Szene
herumlaufen, sondern auch herumlaufen, indem er die Run-Taste gedrückt
hält. Abhängig von den Werten, die
für Beschleunigung und Verzögerung
verwendet werden , kann
es so aussehen, als ob der
Charakter
herumrutscht und versucht, seinen Schwung
umzuleiten Wenn wir uns
den physikalischen Prozess ansehen, schlüsselt
die Aussage ihn
danach auf ob der Spieler
Bewegungseingaben gibt oder Wir können das weiter aufschlüsseln
, um auch zu berücksichtigen, ob der Spieler in
dieselbe Richtung wie
der Charakter bewegen möchte oder nicht. Um zu überprüfen, ob
die Richtung, in die der Spieler gehen möchte , der Richtung
ähnelt, in die sich der Charakter bereits bewegt. Wir können etwas Vektormathematik verwenden. Ein Punktprodukt ist eine Methode zwei Vektoren
miteinander zu
multiplizieren, was zu einer Zahl
führt, die angibt wie ähnlich oder unterschiedlich
diese Vektoren sind Das Punktprodukt zweier Vektoren, die
beide in dieselbe
Richtung zeigen, ist eins und entgegengesetzte Richtungen
negativ Wenn die beiden Vektoren einen rechten Winkel
bilden, stehen
sie senkrecht, ihr
Punktprodukt ist Null. So können wir überprüfen,
ob das Ergebnis
des Punktprodukts
größer oder gleich Null ist , um festzustellen, ob das Zeichen in
die gewünschte Richtung beschleunigt werden
sollte Da sich der Spieler
mehr oder weniger in eine Richtung
bewegen
möchte , die sich der Charakter bereits bewegt,
ist das
Punktprodukt
andernfalls negativ,
was bedeutet, dass der
Spieler versucht,
sich mehr oder weniger in
die entgegengesetzte Richtung zu bewegen Wir sollten dem Charakter sagen, dass er
abbremsen soll , nicht Jetzt kann die
Verzögerung des Charakters
angewendet werden , wenn der Spieler
plötzlich die Richtung wechselt Wir lassen den
Charakter jetzt rotieren und in unserer Szene herumlaufen In der nächsten Lektion werden wir springende Animationen
hinzufügen. Wir sehen uns in der nächsten Lektion.
21. Springen: Hallo, Freunde. In
der vorherigen Lektion
haben wir den Charakter so gedreht, haben wir den Charakter so gedreht in die Richtung zeigt, in die
er sich bewegt. In dieser Lektion werden wir Sprunganimationen
hinzufügen. Lassen Sie uns damit beginnen, Schatten
aus dem Sonnenlicht unserer Szenen zu aktivieren. Wählen Sie den Drei-D-Knoten für direktionales
Licht aus, erweitern Sie den Schattenbereich
und aktivieren Sie die Option „Aktivieren“, falls er noch nicht aktiviert Das gibt uns einen
etwas besseren Überblick darüber wie hoch der
Charakter springt Wenn wir in der Charakterszene den
Animations-Player-Knoten
auswählen, sollte sich
der Animations-Tab unten
im Fenster
öffnen. Sie können es auch manuell öffnen indem Sie hier auf Animation klicken. Wenn wir uns die
Liste der Animationen ansehen, können
wir feststellen, dass es
verschiedene
Sprunganimationen gibt . Wenn wir eine dieser
Animationen auswählen, werden sie nicht abgespielt. Dies liegt daran, dass
der Animationsbaum derzeit die volle Kontrolle hat. Wählen Sie den
Animationsbaum aus und klicken Sie auf den aktiven Schalter, um
ihn zu deaktivieren, während wir
die Sprunganimationen erkunden Kehren Sie zum
Animations-Player zurück, öffnen Sie die komplette kurze oder
lange Sprunganimation und klicken Sie auf Abspielen Diese Animationen
sind nicht sehr flexibel. Wir wollen, dass unsere Sprünge
dynamischer sind. die
Jumpstart-Animation öffnen, können
wir sehen, dass diese
Animation das ist, was passieren
sollte, wenn der Spieler die Sprungtaste
drückt Zoomen Sie hinein, damit Sie
die Animations-Keyframes sehen können. Da es 30
Bilder pro Sekunde gibt, haben sie einen Abstand von 0,033
3 Sekunden. Wir können den Snap auf
diesen Wert setzen, damit wir mithilfe der
Timeline zu jedem einzelnen
Bild scrubben Wenn wir unsere Vorschau
auf die orthogonale Ansicht links oder
rechts umschalten und die Füße des Charakters vergrößern Beachten Sie, dass die
Füße der Figur
für ganze 0,3 Sekunden
der Animation auf dem Boden bleiben für ganze 0,3 Sekunden
der Animation auf dem Das ist wichtig, denn
wenn wir
der Figur zu Beginn
der Animation mehr Geschwindigkeit verleihen der Figur zu Beginn
der , sieht sie
falsch aus. Darauf folgt
die Jump-Idle-Animation, die solange wiederholt werden sollte, bis die
Figur den Boden berührt. Was dann zum Sprung und
zur Animation führen sollte. Wenn Sie diese Animationen
auf diese Weise aufteilen , kann
der Sprung beliebig lang sein und für
den Spieler trotzdem gut aussehen. Beachten Sie auch, dass der letzte
Frame der
Jump-Start-Animation mit
dem ersten Frame der
Jump-Idle-Animation identisch ist . Das gilt auch für
den letzten Frame
des Jump Idle und den
ersten Frame von Jump Land, aber weniger wichtig
ist der
Moment , in dem der Charakter landet, jederzeit
passieren kann. den
Animationsbaumknoten auswählen, können
wir ihn
im Inspektor wieder einschalten und uns
dann die Zustandsmaschine ansehen. Wir können die drei
Sprunganimationen zur Zustandsmaschine hinzufügen . Ich möchte sie über
dem Locomotion-Blend-Raum platzieren in derselben Reihenfolge von
links nach rechts
anordnen , in der
sie verwendet werden Fügt eine Verbindung von
Jump Start zu Jump Idle hinzu. Dann schauen Sie in das
Inspektor-Panel. Dies sind die Eigenschaften
des Übergangs zwischen Staaten. Wir möchten, dass diese beiden
Animationen in
direkter Reihenfolge abgespielt werden, da der letzte und der erste
Frame identisch sind. Wenn die
Jumpstart-Animation abgeschlossen ist, schalten
Sie einfach sofort auf Jump Idle um. den Schalterbereich erweitern, können
wir den
Schaltermodus auf Ende setzen. Das Pfeilsymbol in der
Zustandsmaschine ändert sich, um anzuzeigen, dass dieser
Übergang am Ende
der Animation
stattfinden wird . Der Übergang von
Jump Idle zu Jump Land wird hinzugefügt. Wir möchten, dass dieser
Übergang
sofort erfolgt , wenn der
Charakter den Boden berührt. Das heißt, wir werden nicht
genau wissen, in welchem Frame Jump Idle sich befindet
, wenn das passiert. Um unangenehme Zuckungen zu vermeiden, können
wir die beiden
Animationen für
ein kurzes Zeitfenster wie
eine Zehntelsekunde überblenden ,
gerade so lang, dass die
Änderung nicht sofort eintritt der Wechsel sofort erfolgt, Wir wollen, dass der Wechsel sofort erfolgt,
aber unter einer bestimmten Bedingung, aber unter einer bestimmten Bedingung, wenn der Charakter den Boden
berührt den Bereich für Fortgeschrittene erweitern, können
wir eine beliebige Bedingung oder
Kombination von
Bedingungen in
den Textbereich für den Ausdruck schreiben Kombination von
Bedingungen in den Textbereich für den Ausdruck , um zu steuern, wann dieser
Übergang stattfinden wird. Wie im Zeichenskript können
wir den
Körper der Figur verwenden, um zu überprüfen, ob die Figur
den Boden berührt. Drei D-Knoten sind eingebaut den Boden . Wenn dies der Fall ist, beginnt
der Übergang für
eine Zehntelsekunde mit der Überblendung von Jump Idle zu Jump Land spielt
dann den
Rest von Jump Land diese Funktion verwenden zu können, müssen
wir jedoch den
Animationsbaumknoten erneut auswählen und seine Eigenschaft für den
Basisknoten für erweiterte Ausdrücke
ändern Dies ist der Knoten, auf dem der erweiterte Ausdruck aufgerufen
wird, und wir möchten dafür den
Drei-D-Knoten
des Charakters verwenden , um zu überprüfen, ob
der Wert von is on floor ist Als nächstes beim Übergang vom
Sprungland zur Fortbewegung. Wir möchten, dass
diese Animation in
ihrer Gesamtheit abgespielt wird , bevor wir
wieder zur Fortbewegung übergehen Der Switch-Modus
sollte also beendet sein. Dabei ist der letzte Frame von Jump Land derselbe wie
der erste Frame von Idle. Wenn der Charakter landet,
während er sich bewegt, wollen wir nicht sofort vom Sprungland
zum Gehen oder Laufen
wechseln. Wir können
diesem Übergang also auch ein Kreuz hinzufügen , um ihn
reibungsloser zu gestalten. Das Hinzufügen eines Übergangs von
Fortbewegung zu Sprung
wird ausgelöst, indem der
Spieler eine Taste drückt Erweitern Sie den erweiterten
Bereich und ändern Sie den erweiterten Modus
von automatisch auf aktiviert Dadurch wird der grüne Pfeil in der Zustandsmaschine
grau, da der Übergang nicht
mehr automatisch erfolgt. Auf diese Weise können wir
diesen Übergang später manuell über unser
Zeichenskript auslösen . Da wir nicht wissen, was der
Locomotion-Blend-Space zu einem beliebigen Zeitpunkt
macht , wenn der Spieler die Sprungtaste drückt, hilft
das Hinzufügen einer kurzen Überblendung zu Hinzufügen einer kurzen Überblendung zu
dieser Animation auch dabei, den Übergang
reibungsloser zu gestalten Und schließlich könnten die Animationen Jump Idle und Jump
Land auch nützlich
sein, wenn
der Spieler von einem Felsvorsprung
heruntergeht ,
anstatt zu Hinzufügen eines Übergangs
direkt von der Fortbewegung zum Sprung im Leerlauf
wird diesem Fall Rechnung getragen Wir können den erweiterten
Ausdruck für
diesen Übergang so einstellen , dass der Charakter
nicht auf dem Boden liegt Und das Überblenden von Fortbewegung
zu Sprung im Leerlauf sorgt für einen reibungslosen Übergang Was aber, wenn die Bedingungen für Übergang von Fortbewegung zu Starthilfe oder Leerlauf
gleichzeitig zutreffen Der Charakter hat den Boden
verlassen und
der Spieler hat in diesem Frame die
Sprungtaste gedrückt Wenn du kontrollieren möchtest
, welcher Übergang in diesem Fall
Priorität hat, kannst
du jeden Übergang auswählen und seine Prioritätseinstellung festlegen. Der Tooltip sagt uns
, dass niedrigeren Zahlen Priorität
eingeräumt wird, wenn mehrere
Übergänge möglich sind. In
diesem Fall gebe ich der Starthilfe Priorität , indem ich die
Übergangspriorität auf Null setze. Wir können eine Vorschau davon anzeigen, wie diese
Animationen, Übergänge und Kreuzungen aussehen werden, indem auf die Play-Schaltfläche
klicken beliebigen Status auf die Play-Schaltfläche
klicken, um die
Zustandsmaschine in diesen Zustand zu zwingen Beachten Sie, dass dieser Charakter
im
leeren Raum schwebt und sich
daher nicht auf dem Boden befindet Unser Zeichenskript
verwendet immer noch den grundlegenden Vorlagencode, um den Charakter springen zu
lassen. Wir sollten
dies aktualisieren, um es an die Art und Weise anzupassen, wie wir mit Eingaben für
Gehen und Laufen umgehen. Öffnen Sie die Projekteinstellungen und wechseln Sie zur Registerkarte Eingabekarte. Dort können
wir eine Aktion für den Sprung hinzufügen. Ich verwende die Leertaste und untere Taste
auf meinem Controller als Events für die Sprungaktion Okay. die Projekteinstellungen schließen und das Player-Skript öffnen, können
wir
unserer Aussage eine weitere Bedingung hinzufügen , um zu überprüfen, ob
die Sprungtaste gedrückt wurde. Und wenn ja, sag dem
Charakter, er soll springen. Wenn wir zum
Zeichenskript wechseln, können
wir eine öffentliche
Sprungfunktion hinzufügen. Okay. Bevor wir
die Sprungfunktion schreiben können, benötigen
wir Zugriff auf
die Zustandsmaschine. eine weitere
Variablendeklaration hinzugefügt Unterhalb des Animationsbaums wird eine weitere
Variablendeklaration hinzugefügt. Beginnend mit Add On Ready erhalten
wir einen Verweis auf
die State-Machine-Wiedergabe. Typ ist Animation
State Machine Playback und wir können über
den Animationsbaum
mit eckigen Klammern darauf zugreifen . In den eckigen Klammern können
wir einen Pfad zu dem, auf den
wir zugreifen möchten, als Zeichenfolge angeben. Worauf wir zugreifen wollen,
ist die Wiedergabe von Parametern. Okay. Wie zuvor wenn wir den
Animationsbaumknoten auswählen, können wir,
wenn wir den
Animationsbaumknoten auswählen,
die
Wiedergabe-Ressource hier aufgelistet sehen. Maus über den Namen fahren,
erhalten wir den Eigenschaftspfad . Sie können aber auch mit der rechten Maustaste klicken, den Pfad
kopieren und ihn als Text einfügen Jetzt können wir auf
die Zustandsmaschine zugreifen , wenn der Charakter aufgefordert
wird, zu springen Wenn
sich der Charakter auf dem Boden befindet, können wir verlangen, dass
die Zustandsmaschine in
den Jumpstart-Status wechselt. Stellen Sie sicher, dass der Name
des Bundesstaates exakt übereinstimmt. Kopieren Sie dann auch die
Zeile von unten, die die Sprunggeschwindigkeit der
Zeichen anwendet, und entfernen Sie diese Linien vollständig aus dem physikalischen Prozess. Wenn wir das testen, springt der
Charakter, aber Animation und
Geschwindigkeit sind nicht synchron. eine weitere separate
private Funktion
namens „Sprunggeschwindigkeit anwenden“ hinzufügen , können
wir die Y-Geschwindigkeit der
Figur
auf die Sprunggeschwindigkeit setzen auf die Sprunggeschwindigkeit Körper der Figur nach oben
bewegen. Und stellen Sie sicher, dass das Skript
gespeichert ist, bevor Sie fortfahren. Deaktivieren Sie den
Animationsbaum für einen Moment. dann in der
Startanimation zum Bild, Scrollen Sie dann in der
Startanimation zum Bild, wenn die Füße der Figur den Boden
verlassen Klicken Sie auf Plus Titel hinzufügen. Wir können dieser Animation unsere eigenen Tracks
hinzufügen. Der Spurtyp, den wir
hinzufügen möchten, ist ein Track für die Aufrufmethode. Wählen Sie als Nächstes den Knoten aus, für den wir eine Methode aufrufen
möchten. Dabei handelt es
sich um den D-Node
Body Three. Scrollen Sie nach unten, um unseren neu hinzugefügten Track zu
finden, und klicken Sie mit der rechten Maustaste auf den Track, an dem die
Scrub-Linie ihn schneidet Wählen Sie dann „Schlüssel einfügen“. Wir können jede Methode aus
unserem Zeichenskript oder jede der geerbten Methoden aus
dem D-Knoten
des
dritten Zeichenkörpers selbst aufrufen unserem Zeichenskript oder jede der geerbten Methoden aus
dem . Die Methode, die wir aufrufen wollen, besteht darin, die Sprunggeschwindigkeit
auf unseren Charakter
anzuwenden. Denken Sie daran, den
Animationsbaum vor dem Testen erneut zu aktivieren. Wenn der Spieler nun die Sprungtaste
drückt, startet
der Charakter
die Sprunganimation
und wartet, bis seine Füße tatsächlich den Boden
verlassen bevor er sich nach oben bewegt. Okay. In manchen Spielen möchtest du vielleicht, dass der Charakter
verantwortungsbewusster springt In diesem Fall ist es wichtig, Animationen
zu verwenden, bei denen die Füße des Charakters
zu Beginn der Animation den Boden
verlassen zu Beginn der Animation den Wir haben jetzt animiert, dass die Figuren
springen und fallen. In der nächsten Lektion werden
wir verbessern, wie das Springen anfühlt und wie es vom Spieler gesteuert
wird. Wir sehen uns in der nächsten Lektion.
22. Schwerkraft: Hallo, Freunde. In
der vorherigen Lektion haben wir unserem Charakter Sprunganimationen
hinzugefügt. In dieser Lektion werden wir
die Sprung- und
Fallmechanik verbessern . Beim Testen des Sprungs
gibt es ein paar Probleme. Es ist langsam und schwebend. Der Spieler hat in der Luft
genauso viel Kontrolle über den Charakter
wie am Boden, und wir können die
Sprunghöhe in keiner Weise ändern. Wenn wir im
Charakterskript nachschauen, ist
die Sprunggeschwindigkeit als Konstante
definiert. Wir können auch sehen
, dass die Schwerkraft
aus den Projekteinstellungen abgerufen wird. Wenn wir die Projekteinstellungen öffnen, können
wir dieser
Zeichenfolge folgen, um
die Schwerkrafteinstellungen unter
Physik drei Grad Schwerkraft zu finden die Schwerkrafteinstellungen unter
Physik drei Grad Schwerkraft Die Richtung der Schwerkraft
ist hier ebenfalls editierbar. Erhöhen wir die Schwerkraft damit sich der Charakter schwerer anfühlt Ich multipliziere mit zwei. Beachten Sie, dass sich
diese Änderung
auf alles
im gesamten Projekt auswirkt , das der Schwerkraft
unterliegt. Wenn du nur die Schwerkraft
des Charakters beeinflussen möchtest, können
wir das stattdessen
im Charakterskript tun. Wechsle in der Spielszene
auf drei D V. Meiner Meinung nach macht
es nicht wirklich Sinn, eine Sprunggeschwindigkeit
zu definieren. Stattdessen denke ich gerne darüber nach, wie hoch ich möchte
, dass der Charakter springen kann. erstellen Mithilfe
eines Knotentyps namens CS G oder
konstruktiver Festkörpergeometrie können wir schnell und einfach
grundlegende Geometrie in
unserer Szene . Fügen wir eine CSG-Box hinzu. Schieben Sie es zur Seite und legen Sie
es sauber auf den Boden. Fügen Sie der Box eine Kollision hinzu,
indem Sie im Inspektor auf den
Kollisions-Schalter Wir können die Größe des Felds ändern,
indem wir Werte in
den Inspektor eingeben oder auf die roten
Punkte in der Vorschau klicken und sie ziehen Ändere die Größe des Felds,
bis es
der maximalen Höhe
entspricht , auf die
dein Charakter springen
kann Wir können im Inspektor genau sehen, wie hoch die Box mit ihrem
Y-Wert ist Achten Sie jedoch darauf, dass
der Boden der Box auf dem Boden liegt. Y-Wert der Transformationsposition sollte die Hälfte seiner Höhe betragen. Duplizieren Sie dieses Feld, indem Sie entweder rechten Maustaste darauf klicken und Duplizieren
auswählen oder die Tastenkombination
Strg D oder den Befehl
D
verwenden . Platzieren Sie das Duplikat
neben dem anderen Feld. Mache dieses Feld höher als
das vorherige und stelle eine Höhe
dar
, auf die
der Charakter nicht springen kann Im
Zeichenskript haben wir, wie wir eine Reihe von Variablen
definiert haben , um anzupassen, wie sich der
Charakter bewegt, dasselbe mit der Art und Weise tun,
wie der Charakter springt Lassen Sie uns eine private
Variable namens Jump Height als
Float exportieren und
ihr einen Standardwert geben irgendwo zwischen
den Höhen der beiden Boxen liegt,
die wir gerade erstellt Dadurch kann der
Charakter
auf das erste Feld springen ,
aber nicht auf das zweite. Fügen Sie dann eine private Variable hinzu, die
nicht exportiert wurde, um
die tatsächliche Sprunggeschwindigkeit zu speichern die tatsächliche Sprunggeschwindigkeit , die erforderlich ist, um diese Sprunghöhe zu
erreichen. Wir haben jetzt zwei völlig
separate Kategorien von Variablen in unserem Skript,
eine für die Steuerung, wie sich der Träger bewegt und eine andere für die Steuerung,
wie der Träger springt Wir können eine weitere Zeile
über diesen hinzufügen, um ihre Unterscheidung in der Port-Kategorie weiter zu
betonen Geben Sie dann einen
Zeichenkettennamen für die Kategorie ein. Ich nenne diese
Bewegungsvariablen und die folgenden
Sprungvariablen Das liefert uns nicht nur mehr Informationen
hier im Script, sondern trennt
sie auch im Inspektor Ich werde auch die Richtung in die Kategorie Fortbewegung und die
Schwerkraft in die Kategorie Springen Ich markiere es
mit einem Unterstrich als privat. Wenn du möchtest, dass dein
Charakter eine andere Schwerkraft
erfährt andere Objekte in deinem Spiel, kannst
du auch
eine andere Variable exportieren Nennen wir es Masse und geben ihr
den Standardwert eins. Dies wirkt wie ein Multiplikator für die Schwerkraft, die dem Charakter
hinzugefügt wird Bei 0,5 würde die Schwerkraft also um die Hälfte reduziert
werden, oder bei einer Masse von zwei würde sich die
Schwerkraft verdoppeln In der Ready-Funktion können wir die
Sprunggeschwindigkeit mit Hilfe der Physik
berechnen. Die Sprunggeschwindigkeit, die erforderlich ist, um die gewünschte Sprunghöhe zu erreichen, ist die Quadratwurzel der
Sprunghöhe multipliziert mit der Schwerkraft, ebenfalls
multipliziert mit der Masse, wenn Sie sie
verwenden, und multipliziert Okay. die Sprunggeschwindigkeit zur
Y-Geschwindigkeit des Charakters hinzugefügt
wird für diese neue Variable zur
Y-Geschwindigkeit des Charakters hinzugefügt
wird, können wir die Konstante jetzt
löschen da sie
nicht mehr verwendet wird. multiplizieren Im
physikalischen Prozess müssen wir auch
Graphik mit Masse Lass uns die Spielszene durchspielen und
versuchen, in unsere Boxen zu springen. Der Charakter kann hoch genug
springen, um die erste Box zu erreichen,
aber nicht die zweite. Experimentiere
mit verschiedenen Werten für Sprunghöhe, Schwerkraft oder Masse und finde heraus, wie sie das
Gefühl beeinflussen, wenn die
Charaktere springen Was ist, wenn der Spieler nicht in voller Höhe springen
möchte? meisten Spielen
macht
der Charakter einen kleineren Sprung, indem er
auf die Taste tippt, und einen höheren Sprung, indem er die Taste gedrückt
hält Die Charakter-Animation, die
eine Verzögerung hat, bevor sie tatsächlich springt, kann
für die Implementierung dieser Funktion sehr nützlich sein für die Implementierung dieser Funktion Beginnen wir damit, keine Sprunghöhe zu
definieren, sondern sowohl eine maximale Sprunghöhe als
auch eine minimale Sprunghöhe. Das heißt, wir benötigen auch eine minimale und maximale
Sprunggeschwindigkeit. Und berechne diese beiden
Werte in der Ready-Funktion. Okay. Dann
müssen wir die
Geschwindigkeit, die dem Charakter hinzugefügt wird,
anhand
der Zeit skalieren Charakter hinzugefügt wird,
anhand
der Zeit , in
der die Taste gedrückt gehalten
wurde. Um die Zeit zu messen, gibt es einen praktischen
Knotentyp, den wir
unserem Charakter hinzufügen können , einen Timer-Knoten. Nennen wir diesen Jumper. Und schnappen Sie sich während
der Bereitschaftsphase einen Verweis auf
den Timer-Knoten, genauso wie wir es
mit den anderen Knoten gemacht haben Da der Name des
Knotens Leerzeichen enthält, wird
der Pfad
in Anführungszeichen gesetzt. Wenn wir den Sprung in
zwei Serverfunktionen
aufteilen, nennen wir die
erste Start-Sprung Wenn die Sprungtaste gedrückt wird, können
wir den Timer starten. Wenn dann die
Sprungtaste losgelassen wird, können
wir ihre
Paused-Eigenschaft auf true setzen Das bedeutet, dass wir
beim Starten auch die Eigenschaft
pausiert auf False setzen müssen Wir müssen also
das Spielerskript so bearbeiten, Start Jump
aufruft,
wenn die Taste
gedrückt wird , und Jump beendet,
wenn die Taste losgelassen wird Im Inspektor können
wir sehen, dass der Timer so eingestellt ist, dass er ab einer Sekunde
herunterzählt, was länger als 0,3
Sekunden ist. Das ist also in Ordnung. Aber wir müssen
den One-Shot-Schalter überprüfen, damit der Timer
nur einmal herunterzählt
und sich nicht
jedes Mal, wenn er abgeschlossen ist, von selbst zurücksetzt Wenn die Sprunggeschwindigkeit Charakter tatsächlich
hinzugefügt
wird, können
wir den Timer pausieren, falls er
nicht schon angehalten wurde Falls der Spieler immer noch die
Sprungtaste gedrückt hält. Wir können damit beginnen, die
minimale Sprunggeschwindigkeit hinzuzufügen. Addieren Sie dann auch die
Differenz zwischen der maximalen und der
minimalen Geschwindigkeit. Multipliziert mit eins minus der verbleibenden
Zeit auf dem Timer, geteilt durch die maximal
mögliche Zeit, die wir anhand der
Animation bestimmt haben, 0,3 Sekunden beträgt Wir wollen nie, dass dieser Wert
über 0,3 Sekunden liegt, also
können wir die Min-Funktion anwenden
, um ihn auf 0,3 zu begrenzen Wenn der Spieler
die Taste innerhalb
eines einzigen Frames
drückt und wieder
loslässt, ist dieser Wert nahe Null und das Ergebnis ist eine
minimale Sprunggeschwindigkeit. Wenn der Spieler die Taste gedrückt hält 0,3 Sekunden gedrückt hält,
ist
das Nullpunkt 3/0 0,3, was eins ist, und das Ergebnis die maximale
Sprunggeschwindigkeit Eine Zeitspanne
dazwischen
skaliert linear zwischen
den beiden Ergebnissen Lass es uns ausprobieren, indem wir die Spielszene
ausführen. Durch Tippen auf die
Sprungtaste
springt der Charakter bis zu einer Höhe
von 1,5 Einheiten, und wenn er die Taste gedrückt hält, springt
er bis zu 2,5 Wenn Sie die Taste
unterschiedlich lange gedrückt halten, werden
Sprünge unterschiedlicher Höhe erzeugt Als Nächstes fügen wir unserer Kategorie Springen weitere
exportierte Variablen hinzu Luftregelung und Druckluftbremsen. Dabei handelt es sich um Multiplikatoren Beschleunigung bzw.
Verzögerung, die die Kontrolle
des Spielers über den Charakter in
der Luft verringern Kontrolle
des Spielers über den , ohne ihn vollständig zu
eliminieren 0,5 ist ein guter Ausgangspunkt
für ihren Standardwert. Du musst testen, wie der Charakter in deinem Spiel
fühlen soll. Während des physikalischen Prozesses
dreht
der erste Codeblock das Charaktersystem so, dass es in die
gewünschte Richtung zeigt In den meisten Spielen geschieht
dies unabhängig
davon, ob sich der Charakter
am Boden oder in der Luft befindet Als Nächstes wird die Schwerkraft hinzugefügt, die nur gilt, wenn sich
der Charakter
nicht auf dem Boden befindet. Dieser Block bewegt
den Charakter, aber er tut es auf eine
Weise, die nur Sinn
macht, wenn sich die
Figur auf dem Boden befindet. Aber es wird bei jedem Bild angewendet,
unabhängig davon, ob sie sich auf dem Boden oder in der Luft befinden. Dann wird die
Mischposition der Bewegungsanimation festgelegt, was wiederum nur gilt, wenn sich der Charakter
auf dem Boden befindet Anwendung der D-Geschwindigkeit und die Move-and-Slide-Methode
sind universell einsetzbar. So können wir die Teile
des physikalischen Prozesses
in allgemeine Physik,
Bodenphysik und Luftphysik unterteilen und eine neue Funktion für
Boden- und Luftphysik
schreiben, eine neue Funktion für
Boden- und Luftphysik
schreiben, sowohl privat ist als auch
einen Strömungsparameter für Delta akzeptiert Wir können dann die Schwerkraft ausschneiden und in
die Luftphysik-Funktion
einfügen die Luftphysik-Funktion und die Bewegungsberechnungen in die
Bodenphysik-Funktion einfügen. sich der Charakter dann im Physikprozess Wenn sich der Charakter dann im Physikprozess auf dem
Boden befindet, rufen Sie Bodenphysik auf. Rufen Sie andernfalls Air Physics auf. Delta als
Argument an beide weitergeben. Unser physikalischer Prozess ist jetzt viel kleiner und
leichter zu verstehen, während die Boden
- und die Luftphysik
voneinander getrennt sind und auch
einfacher zu handhaben sind. Wie wenden wir also
Luftregelung und Druckluftbremsen an? Kopieren Sie die
X-Geschwindigkeitsberechnungen
aus der Bodenphysik und fügen Sie
sie in die Luftphysik ein. Multipliziere dann jedes Mal, wenn
der Spieler versucht, den Charakter in
der Luft durch Luftkontrolle zu kontrollieren. Und immer dann,
wenn sie nicht versuchen, den Charakter in
der Luft durch Luftbremsen zu
kontrollieren. Dies ist in diesem Fall nicht dasselbe
wie Beschleunigen und Abbremsen, da der Spieler beim Versuch, sich in der Luft
umzudrehen, immer noch versucht, den Charakter
zu kontrollieren die Sprunggeschwindigkeit
0,3 Sekunden nach dem Start der
Sprunganimation anwenden , erzeugen
wir eine große Menge an Kojotenzeit Wenn Sie das nicht möchten, können
Sie festlegen, dass sich die
Figur immer noch auf Boden befindet, bevor Sie
die Sprunggeschwindigkeit
mit einer if-Anweisung hinzufügen die Sprunggeschwindigkeit
mit einer if-Anweisung Außerdem
sollte bei der Initialisierung der
Bewegungsgeschwindigkeit Add On Ready verwendet werden Derzeit wird damit die
Bewegungsgeschwindigkeit auf den
Standardwert der Gehgeschwindigkeit initialisiert Bewegungsgeschwindigkeit auf den
Standardwert der Gehgeschwindigkeit Wenn wir jedoch
den Standardwert
für die Gehgeschwindigkeit überschreiben würden , würde
er nicht der Bewegungsgeschwindigkeit
zugewiesen Benutze Geometrieblöcke, um
einen kleinen Hindernisparcours
für deinen Charakter zu bauen einen kleinen Hindernisparcours
für deinen Charakter zu Wie schwierig ist es, das Springen
der Charaktere zu kontrollieren? Experimentiere mit verschiedenen Werten bis du das Gefühl bekommst, das
du dir für dein Spiel wünschst. Die
Charaktere springen jetzt und folgen Mechaniken, sodass sie sich realistischer
anfühlen. Und in der nächsten Lektion werden wir Kamerasteuerungen
hinzufügen. Wir sehen uns in der nächsten Lektion.
23. Kamera: Okay. Hallo, Freunde.
In der vorherigen Lektion haben wir angepasst, wie Kräfte
unseren Charakter in der Luft beeinflussen In dieser Lektion fügen wir unserer Spielszene
Kamerasteuerungen hinzu Wie wir es in
früheren Lektionen getan haben, wäre
es einfach, die
Kamera einfach dem Spieler zuzuordnen. Die Kamera folgt
dem Spieler, aber dann
wäre es kompliziert, die Kamera
um den Spieler herum zu drehen . Aber wenn wir einfach eine weitere
Trennungsebene hinzufügen, ein „Kein Kind“ für den Spieler mit der Kamera und
dann ein Enkelkind, wird
das viel einfacher Die Kameraneigungen und
Drehungen, die wir Spielen
erwarten, die von einer dritten Person
gesteuert werden, können
erreicht werden , indem nur
die Drehungswerte
dieses Zwischenknotens verändert werden, entweder um die Wenn wir uns um die Y-Achse drehen, dreht
sich die Kamera
um den Charakter,
so wie wir es erwarten, wenn wir den rechten Stick horizontal neigen. Durch Drehen um die X-Achse wird die Kamera nach oben oder unten Was erwarten wir, wenn wir
den rechten Stick vertikal neigen? Da die Kamera
ein untergeordnetes Element dieses Knotens ist, passt
sie sich ihrer Drehung an und bleibt auch weiterhin auf den
Charakter fokussiert Wir können den Brennpunkt der
Kamera anpassen ihn von den Füßen der
Figur bis zum Kopf bewegen, indem wir den
Knoten entlang der Y-Achse nach oben bewegen. Von hier aus können wir auch die horizontale
Versatzeigenschaft
der Kamera anpassen , um die Kamera weiter entlang
der X-Achse zu verschieben und so einen
Schulterkameraeffekt zu erzeugen. Wir können sogar steuern, wie weit die Kamera
von der Figur
entfernt ist und dies dynamisch steuern,
indem wir den Knotentyp ändern. Klicken Sie mit der rechten Maustaste auf den Knoten wählen Sie Typ ändern und suchen Sie nach dem Knoten Spring
Arm Three D. Wir können auch den Namen
des Knotens bearbeiten , um
seinen neuen Typ widerzuspiegeln. Da die Kamera dem Federarm
untergeordnet ist, müssen
wir ihre Transformation zurücksetzen, sodass sie dieselbe Position
und Drehung wie der Federarm hat . Im Inspektor können wir sehen, die Länge der Feder auf 1 Meter eingestellt
ist. Die Kamera versucht immer, sich neu
zu positionieren entlang ihrer Z-Achse
1 Meter von diesem
Knoten entfernt Erhöhen wir diesen Abstand auf etwas Höheres,
etwa 5 Meter. Okay. Bei diesem
Federarmknoten ist es auch zu Kollisionen gekommen. Wenn sich zwischen dem
Ursprung des
Federarms und der Kamera ein
Kollisionsobjekt befindet,
gibt Ursprung des
Federarms und der Kamera ein
Kollisionsobjekt befindet, der Rand an, wie weit die
Kamera
von der Kollision entfernt positioniert wird. Die Kamera wird so
nah wie möglich an der Länge des
Federarms positioniert nah wie möglich an der Länge des
Federarms bevor
es zu einer Kollision kommt, wodurch die Feder zusammengedrückt wird. Wenn das Hindernis entfernt wird, wird
die Feder dekomprimiert und die gesamte Strecke
weggedrückt Dies geschieht mit einem Strahlwurf, bei dem ein einzelner Punkt entlang
der Achse der Federarme
geprüft wird Wenn wir aber auch eine
Form für den Federarm angeben, können
wir dem Kollisionsvolumen geben den Strahlwurf
durch einen Formguss
ersetzen Es muss mehr Leerraum vorhanden
sein bevor sich die Kamera wieder auf die volle Entfernung
bewegen Wenn wir die Form zu einem Quader machen, können
wir seine Abmessungen definieren. Nun
wird anhand des Quaders ermittelt, Nun
wird anhand des Quaders ermittelt wie weit die Kamera am
Federarm entlang fahren kann. Um die Kamera zu steuern, müssen
wir den Projekteinstellungen
weitere
Eingabezuordnungen hinzufügen Projekteinstellungen
weitere
Eingabezuordnungen Öffnen Sie die Projekteinstellungen und wechseln Sie zur Registerkarte Eingabekarte Fügen Sie Aktionen für links, rechts, oben und unten hinzu. Ich verwende die
Pfeiltasten und den Stick Tilt für die Ereignisse, die jede dieser Aktionen
auslösen werden . Im Player-Skript haben wir bereits einen Verweis
auf die Kamera, aber es ist nicht die Kamera, die wir
tatsächlich steuern werden. Wir benötigen einen Verweis
auf den Federarmknoten. Und stellen Sie es in den Inspektor ein. In der Prozessfunktion können wir eine Funktion
aufrufen, die wir
noch nicht geschrieben haben. In einem Skript haben wir noch
nicht
einmal den Federarm erstellt , um in eine Richtung zu
schauen. Die Blickrichtung können
wir anhand Eingabe ermitteln, wie wir es hier getan haben, Eingabevektor mit links
als negativem X, rechts als positivem X. Schauen Sie nach oben als negatives Y und nach unten als positives Y. Lassen Sie uns das
Spring-Arm-Skript erstellen. Es erbt von
Spring Arm Three D. Es gibt keine Vorlage für
Spring Arm Three D-Skripten, und die Standardeinstellung no
template ist nicht relevant Lassen Sie uns den Schalter für die
Vorlage deaktivieren, sodass wir mit einem leeren Skript beginnen Ich nenne diesen Spring Arm einfach und speichere ihn im
Scripts-Ordner Wir wissen bereits, dass wir eine öffentliche Funktion n
schreiben müssen , die einen
Richtungsparameter
vom Typ Vektor zwei aus
dem Player-Skript akzeptiert . Okay. Wir müssen diesen Federarm dann nur noch um die X-Achse nach Richtung und die
Y-Achse nach X-Richtung
drehen. Aber wie alles, was
während einer Prozessfunktion passiert, passiert
es 60
Bilder pro Sekunde,
und wir wollen, dass während einer Prozessfunktion passiert, passiert
es 60
Bilder pro Sekunde,
und wir wollen, er
unabhängig von der Bildrate funktioniert,
was bedeutet,
sie mit Delta zu multiplizieren Aber wir haben hier keinen
Zugriff auf Delta, da diese Funktion es nicht als Parameter
hat Wir können es der
Parameterliste hinzufügen und es
vom Player-Skript aus übergeben. Okay. Oder wir können einfach eine eingebaute Methode aufrufen und Delta
T verarbeiten lassen, um sie abzurufen. Jetzt dreht sich der Federarm,
der die Kamera hält ,
mit der Neigung des rechten Sticks. Diese Drehungen erfolgen mit
einer Geschwindigkeit von 1 Radiant/Sekunde Wir können die Geschwindigkeit der
Rotationen bearbeiten , indem wir eine private Variable exportieren Nennen wir es Rotationsgeschwindigkeit. Dann multipliziere das mit
Richtung und Delta. Wenn Sie möchten, dass diese Rotationen
unterschiedliche Geschwindigkeiten haben, können
Sie separate
Variablen für sie exportieren Okay. Während sich die Y-Drehung normalerweise
endlos drehen darf, hat
die X-Rotation
normalerweise Grenzen Die Steuerung geht kaputt, wenn
wir die Kamera so weit neigen
, dass sie direkt nach oben oder
direkt nach unten schaut Da die
Kameraachse auf
die X-Ebene abgeflacht ist, wird sie
zu Null oder umgekehrt Wir müssen also die Drehung der
Federarme dass sie zwischen einem
Minimal Wenn die Kamera flach zum Horizont ausgerichtet ist und eine
Drehung um 0 Radiant erfolgt, entspricht gerader
Blick nach oben oder
gerade nach unten einer Drehung von Pi über 2 Radiant entweder
in positiver
oder negativer Richtung Wir müssen nur sicherstellen,
dass der absolute Wert kleiner als Pi über zwei
ist Die x-Rotation zwischen
negativem und positivem Pi
über drei zu klatschen , ist eine schnelle
und einfache Lösung , die dennoch eine große Bandbreite bietet Wir können diese Werte auch exportieren und zulassen, dass diese
Grenzwerte angepasst werden Okay. Sie könnten
noch weiter gehen und
zwei Fünftel von Pi verwenden
oder sogar die
Funktion
Grad in Radianz verwenden, um 89
Grad in Radiant umzurechnen Solange die Kamera nicht
direkt über oder unter die Figur gehen kann ,
okay Im Spielerskript müssen
wir
einige Anpassungen an unserer
Charaktersteuerung vornehmen. Da die Kamera nun dem Federarm
untergeordnet ist, dreht sich
die Kamera
nicht mehr, zumindest nicht im lokalen Raum. Der Federarm dreht sich und die Kamera bleibt relativ zu ihm
stationär. Wir können die
globalen Basisvektoren der Kamera
ermitteln, die nicht
relativ zum übergeordneten Knoten, sondern relativ
zur gesamten Szene sein
werden. Alternativ können wir
die Basisvektoren
des Federarms selbst verwenden . Okay. Und in diesem Fall brauchen
wir überhaupt keinen Hinweis
auf die Kamera. Wir haben jetzt die Kamera, die vom Spieler leicht
gesteuert werden kann. In der nächsten Lektion werden
wir
Umweltmodelle importieren und in unser Spiel
implementieren. Wir sehen uns in der nächsten Lektion.
24. Dungeon: Hallo Freunde. In
der vorherigen Lektion haben wir unserem Spiel
Kamerasteuerungen hinzugefügt. In dieser Lektion bauen
wir einen Raum
, dem unser Charakter
herumrennen und springen kann. Ich habe das
K Hits Dungeon Remastered
Asset Pack von HDO heruntergeladen K Hits Dungeon Remastered
Asset Pack von Den Assets-Ordner öffnen. Wenn wir in den G LTF-Ordner schauen. Es gibt eine große Anzahl
von Modellen, die wir für unser Projekt
problemlos in
Ado importieren können für unser Projekt
problemlos in
Ado importieren In Go erstellen wir zunächst
einen neuen Ordner im
Ordner importierte Assets
mit dem Namen Dungeon Wenn dieser neue Ordner ausgewählt ist, werden die Assets
beim Importieren in diesem Ordner
platziert Genau wie bei den Charakteren müssen
wir
einige Anpassungen an den Importeinstellungen
dieser Assets vornehmen. Fangen wir mit
Floor Dirt Large an. Doppelklicken Sie auf das Asset
oder wählen Sie auf der Registerkarte mit
den Importeinstellungen die Option Erweitert aus , um das Fenster mit den erweiterten
Importeinstellungen zu öffnen. Wenn wir den D-Knoten der
Netzinstanz drei auswählen, können
wir Gott erlauben, automatisch
eine Kollisionsform für
dieses Objekt zu erzeugen , indem wir
den Physik-Schalter aktivieren der Vorschau
ist ein Drahtgeflecht mit der
Kollisionsform In der Vorschau
ist ein Drahtgeflecht mit der
Kollisionsform sichtbar, und ein neuer Physikbereich mit mehreren Optionen
wurde hinzugefügt Da der Boden Teil
der Umgebung ist, gehen
wir davon aus, dass er
zwar Kollisionen haben wird, sich aber aufgrund
dieser Kollisionen nicht bewegt oder
durch externe Kräfte wie die Schwerkraft beeinflusst wird durch externe Kräfte wie Sein Körpertyp ist statisch. Für die Erzeugung
dieser Kollisionsform
stehen verschiedene Optionen zur
Auswahl ,
und wir können sehen, dass
die aktuelle Form mit
zerlegtem, konvexem Material
erzeugt wurde mit
zerlegtem, konvexem Material
erzeugt Das ist für die meisten
Objekte in unserem Spiel in Ordnung, aber wenn wir die Vorschau neigen, können
wir sehen, dass sich die
Kollisionsform bestimmten Stellen deutlich weit über dem
Boden befindet Das würde dazu führen
, dass die
Füße des Charakters den Boden nicht berühren, was nicht besonders gut aussehen würde Wählen Sie „Einfach konvex“
aus der Drop-down-Liste aus. Diese Kollision hat
weniger Polygone als zuvor und
das Die Füße des Charakters würden den Boden an manchen Stellen nicht berühren Wenn Sie Tri Mesh auswählen, die Kollisionsform exakt
der Netzinstanz. Da es sich bei diesen Objekten um Low-Poly-Werte handelt, dies in Bezug auf die Leistung nicht wirklich
ein so großes Problem dar wie es wäre, wenn dieses Netz Tausenden
von Dreiecken bestehen Die Kollisionsform des Charakters wird jedoch mit
diesen Felsen kollidieren Je nachdem, wie dein
Spiel funktionieren soll, kann
das eine gute oder eine schlechte
Sache sein. Sei dir dessen einfach bewusst. Wenn Sie
die Felsen komplett ignorieren möchten und nur ein flaches
Feld für die Kollisionsform haben möchten, wählen Sie das Feld für
die Kollisionsform. Die Kollisionsform der Box
wird nicht automatisch so konfiguriert, dass sie der
Größe oder Form des Netzes entspricht. Aber wir können die
Abmessungen und die
Positionierung hier am
unteren Rand des Panels bearbeiten . Ich wähle Primzahlen
für diese Etage aus, um zu
zeigen, wie die
Kollisionsform des Charakters mit den Felsen interagiert Sobald Ihre Bodenplatte
die Kollisionsform hat, die
Sie bevorzugen, klicken Sie auf Importieren,
um das Objekt erneut zu importieren Schauen wir uns als Nächstes ein Objekt
an, das wir vielleicht dynamischer gestalten
möchten, wie das Boxarg-Asset Wie bei der Bodenkachel können
wir den Knoten Met Instance
Three D auswählen und Physik hinzufügen,
indem wir auf den Schalter klicken Da wir wollen, dass es nicht
nur zu Kollisionen kommt, sondern sich auch bewegt
und
von äußeren Kräften wie der Schwerkraft beeinflusst wird, sollte
sein Körperbau dynamisch sein Wählen Sie dann eine
Kollisionsform dafür aus. Ich werde das
auf einfach konvex umstellen. Bei manchen Objekten möchtest du dich
vielleicht gar nicht mit Kollisionen
oder Physik
beschäftigen,
wie zum Beispiel Banner oder ähnliche
Dekoartikel In diesen Fällen müssen Sie
sich nicht die
Mühe machen, die
Importeinstellungen zu bearbeiten Wiederholen Sie diesen Vorgang für alle Objekte, auf die
Sie die Physik anwenden möchten. Dieses Asset-Paket enthält eine Menge Ressourcen
. Es ist nicht nötig,
sie jetzt alle zu erledigen. Du kannst
ihre Importeinstellungen jederzeit bearbeiten und sie später zu deinem
Spiel hinzufügen, wenn du möchtest. Wir möchten
mit diesen Objekten einen Raum bauen Dazu
klicken wir auf ein
beliebiges Objekt und ziehen es in den
Szenenbaum, um es der Szene hinzuzufügen Aber
jedes einzelne
Asset manuell zu positionieren , ist mühsam Ganz zu schweigen davon, dass wir vielleicht möchten, dass unser Spiel
verschiedene Räume hat So wie wir den
Charakter
als eigene separate Szene definiert haben , möchten
wir, dass unsere Spiellevel auch ihre eigenen
separaten Szenen sind. Auf diese Weise kann die
Spielszene
unabhängig davon geladen werden , in welchem Level der Spieler gerade
spielt Lassen Sie uns die Boxen
Floor und CSG löschen. Wir können sie stattdessen durch
einen neuen Knoten mit drei D ersetzen , um ein Level unseres Spiels
darzustellen Nennen wir es Dungeon. Da die Spielszene für jedes Level
gedacht ist und die verschiedenen
Level wahrscheinlich
unterschiedlich beleuchtet werden ,
sollten wir das Sonnenlicht zu einem
Kind des Levelknotens machen der rechten Maustaste auf den Dungeon-Knoten klicken, können
wir ihn als eigene Szene speichern Named Dungeon wurde
im Szenenordner gespeichert. Alle visuellen Komponenten
der Spielszene sind also tatsächlich in anderen Szenen enthalten Die einzigen Dinge
in unserer Spielszene sollten der
Eingabe-Handler für den Spieler, ein Charakter, ein Federarm
und eine Kamera sein, ein Charakter, ein Federarm
und eine Kamera sein, die der Spieler kontrollieren
kann, sowie das Level. Klicke dann auf das Klapperbrett um die Dungeon-Szene zu öffnen Hier können wir unseren
Dungeon getrennt von
anderen Dingen in der Spielszene
wie der Kamera oder dem Charakter bearbeiten anderen Dingen in der Spielszene
wie der Kamera oder dem Charakter In der Dungeon-Szene
können wir einen neuen Knotentyp hinzufügen, einen Grid-Map-Knoten
, der es
uns ermöglicht , das Level
mit den importierten Assets schnell aufzubauen mit den importierten Assets die Grid-Map ist jedoch
eine Ressource erforderlich ,
die als Mesh-Bibliothek bezeichnet wird . Diese müssen wir zunächst
aus den importierten Modellen generieren Wählen Sie im Hauptmenü die Option Szene Neue Szene aus, um eine neue leere Szene zu erstellen, und wählen Sie auf der Registerkarte Szene
drei D-Szenen aus. Diese Szene wird eigentlich nichts im Spiel
darstellen, sondern als Sammlung von
drei D-Modellen dienen, die in der Grid-Map
verwendet werden können. erstellen
drei beliebige D-Modelle, die Sie
in Ihrer Grid-Map haben möchten, und ziehen sie auf
den Stammknoten der Szene. Dann fügen
wir sie der Sammlung hinzu Die Modelle werden sich alle
am Ursprung der Szene befinden denselben
Raum
einnehmen, was können wir unsere
Ressourcen filtern, um diesem Feld können wir unsere
Ressourcen filtern, um
den Auswahlprozess
zu vereinfachen Beim Filtern nach GLTF werden nur die GLTF-Dateien
angezeigt. Wenn eine Gruppe die Assets auswählt, könnten
sie viel schneller zur
Mesh-Bibliothek hinzugefügt werden Sobald sich alle Modelle, die Sie verwenden
möchten, in der Szene befinden, speichern Sie die Szene nicht
im Szenenordner, sondern im Ordner Dungeon für importierte
Objekte Und nennen Sie es Dungeon
Mesh Library mit der Erweiterung T SCN. Als Nächstes folgt eine Szene aus dem Hauptmenü, Als Mesh-Bibliothek
exportieren Speichern wir
das im selben Ordner, nennen wir es Dungeon Mesh Library Diesmal mit der Erweiterung Mb. Zurück in der Dungeon-Szene, wo wir den Knoten Grid Map auswählen, können
wir unsere neue
Mesh-Bibliothek im Inspektor zuweisen Wir können die Ressource aus dem Dateisystem ziehen, in
das Feld tippen oder auf
das
Drop-down-Menü klicken und Quick Load auswählen Daraufhin wird eine
Liste von Ressourcen innerhalb des Projekts eines kompatiblen Typs
angezeigt unsere neu
erstellte Mesh-Bibliothek auswählen, können
wir sehen, dass die
Meshes in
das
Auswahlraster übernommen wurden in
das
Auswahlraster Auswahl des Objekts für die Bodenfliese. können wir eine vierteilige Kachel an einer
beliebigen Stelle in der
Rasterkarte platzieren Durch Anklicken können wir eine vierteilige Kachel an einer
beliebigen Stelle in der
Rasterkarte platzieren. die Kacheln positionieren, werden
sie an Rasterkoordinaten
entlang der X-D-Ebene ausgerichtet. den Bereich auf
der Registerkarte „Inspektor“ erweitern, können
wir die Zellengrößen bearbeiten , auf die die Bodenfliesen ausgerichtet
werden Da wir wissen, dass diese
Kacheln 4 Meter breit sind, setzen
wir die
XD-Zellengröße auf vier Jetzt können wir ganz einfach
ein Raster von drei mal drei
Bodenfliesen platzieren , indem wir darauf klicken. Und lösche sie, indem du mit der
rechten Maustaste klickst. Alle diese vier
Kacheln stehen auf Null. Dies ist die
Zellkoordinate auf der Y-Achse. Wenn wir den Boden vergrößern, werden die Fliesen 2 Meter über dem Boden
platziert und ebenso auf dem negativen Boden
eins, 2 Meter darunter. Und wir können den Unterschied in der
Bodenhöhe
mit dem Y-Wert für die Zellengröße bearbeiten . Wenn wir der Netzbibliothek später Netze
hinzufügen möchten, können
wir zur Szene mit der
Netzbibliothek zurückkehren Dieses letzte Wandelement
muss mit einer früheren
G LTF-Benennungsversion erneut
importiert Wir können
dieser Szene weitere Meshes hinzufügen. Dann melde es Stellen Sie sicher, dass das Kontrollkästchen Mit
bestehenden Netzen zusammenführen aktiviert ist , um die
bestehende Netzbibliothek mit den neuen Netzen
zu aktualisieren den neuen Netzen
zu Zurück in der Dungeon-Szene und Auswahl der
Grid-Map
werden die neuen Meshes dem Auswahlraster hinzugefügt Nicht alle
Maschen sind 4 Meter lang. Viele sind 2 Meter oder
sogar 1 Meter oder kleiner. die
Rastermaße auf 1 Meter
ändere, kann ich die aktuellen Kacheln löschen da sie sich jetzt überlappen Wählen Sie stattdessen
Koordinaten aus, die
ein paar Zellen voneinander entfernt sind, um die vier
Kacheln neu zu zeichnen Aber jetzt
kann ein kleineres Netz an den Koordinaten
alle 1 Meter
statt alle 4 Meter platziert werden . Okay. Bei der Auswahl der Position , an der das Mesh
auf der Grid-Map platziert werden soll, können
die WASD-Tasten auch
verwendet werden, um das Mesh zu drehen Mit einer Drehung
um die X-Achse, S-Y-Achse und die D-Z-Achse Der Wk wird auf die Standardrotation
zurückgesetzt. Erstellen Sie eine einfache Dongon-Szene
aus den Assets und speichern Sie sie. Wenn es
Objekte gibt, die Sie nicht auf exakten
Rasterkoordinaten
platzieren möchten , können
sie trotzdem getrennt
von der Grid-Map
zur Szene hinzugefügt und manuell
positioniert werden von der Grid-Map
zur Szene hinzugefügt und manuell
positioniert Kehren Sie dann zur Spielszene zurück. In der Spielszene befindet sich der Boden des Dungeons
über dem Charakter Bewegen wir den Charakter
also über den Boden. Wenn wir die Spielszene ausführen, kann
der Charakter
mit dem Boden, den Wänden
und allen anderen Objekten
in der Szene kollidieren , deren Physik
durch die Importeinstellungen generiert wurde Mit diesen Tools kannst du
schnell und einfach
eine Vielzahl von Levels
für dein Spiel erstellen eine Vielzahl von Levels und Dinge nach Bedarf
hinzufügen, entfernen oder
ändern Wir haben jetzt einen voll funktionsfähigen Charakter-Controller für
Dritte, der
es dem Spieler ermöglicht, einen vollständig animierten
Charakter zu
steuern , der in einer Drei-D-Welt
herumläuft und springt . Okay.
25. Was kommt als Nächstes?: 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.