Transkripte
1. Einführungsvideo zum Kurs: Erinnerst du dich an die
klassischen 2D-Spiele wir als Kinder gespielt haben, wie Mario Contract, Donkey Kong, Mortal Combat usw. Sehr gute Nachricht ist,
dass
du jetzt auch
dein eigenes 2D-Handyspiel mit
diesem neuen aufregenden Kurs erstellen kannst dein eigenes 2D-Handyspiel mit
diesem neuen aufregenden Kurs ,
der dich mit Hilfe von
Florida und Flame Game Engine auf eine Reise der Spieleentwicklung von
Grund auf mitnimmt mit Hilfe von
Florida und Flame Game Engine auf eine Reise der Spieleentwicklung von
Grund Wir beginnen mit
den Grundlagen
wie um ein Projekt zu konfigurieren. Dann lerne, wie du Sprites erstellst
und hinzufügst. Implementieren Sie Benutzereingaben
wie Joystick-Steuerungen und richten Sie eine Spielschleife ein, damit
unser Spiel reibungslos läuft. Sie lernen auch, wie Sie Kollisionen zwischen
Objekten
erkennen und Soundeffekte hinzufügen , um das
Spielerlebnis zu verbessern. Egal, ob Sie ein Anfänger oder
ein erfahrener Programmierer sind. Dieser Kurs soll Ihnen helfen
,
die Fähigkeiten zu erlernen , die Sie benötigen, um Ihre eigenen 2D-Spiele zu
erstellen. Am Ende des Kurses hast du ein vollständiges Spiel , das du mit Freunden und
Familie teilen und sogar im App Store veröffentlichen
kannst . Also, ohne weitere
Zeit zu verschwenden, fangen wir an.
2. Video 1 Erstelle ein flutter: Hallo, willkommen zum
allerersten Video des Kurses, in dem wir lernen,
wie man ein Spiel
mit der Flutter and
Flame Game Engine erstellt . Ich hoffe, du
weißt schon, was Flamme ist. Flame ist ein 2D-Game-Framework,
das auf Florida
basiert und mit dem wir jede
Art von 2D-Spiel erstellen und es
auf allen von Florida
unterstützten Plattformen
wie Handy, Web und Desktop ausführen können auf allen von Florida
unterstützten Plattformen . Mit Flame können wir
eine Vielzahl von Spielen entwickeln ,
darunter Plattformspiele, Puzzlespiele und Less Runner, RPGs,
Abenteuerspiele und vieles mehr. Ich möchte also nicht so sehr auf
den Theorieteil eingehen. Aber zumindest sollten wir wissen,
was wir bauen werden. Am Ende des Kurses. Wir werden ein Spiel entwickeln, in
dem ein Mann Hanteln
sammeln muss ,
um fit zu bleiben, und
Viren ausweichen muss, damit er seine Muskelmasse
nicht verliert,
bevor die Zeit abläuft. Außerdem werden wir Impfstoffe
vorstellen, denen Sie ein Immunsystem für einige Sekunden
selbst abwehren können, sowie Proteinshakes, die
ihm zusätzliche Energie geben. Beginnen wir mit der Erstellung
eines neuen Florida-Projekts. Gehen Sie also in Ihr gewünschtes Verzeichnis und öffnen Sie Ihr Terminal und erstellen Sie ein neues
Florida-Projekt mit diesem Code Flutter. Erstellen. Ich werde das Game Fighter nennen. Drücken Sie die Eingabetaste. Okay. Wir haben es geschafft, wir haben Projekt k
erstellt. Außerdem werde ich nicht für
Windows, Linux und Mac OS abrechnen. Also werde ich
diese Datei einfach entfernen, um sie sauber zu machen und weniger Speicherplatz
zu beanspruchen. Fügen Sie nun den VSCode-Editor und fügen Sie einen neuen Spielordner an. Die Kurswoche für K. Okay. Als Erstes installiere
ich
die erforderlichen Pakete. Also geh zu Dev. Und suchen Sie zunächst
nach Schuldzuweisungen. Nur Flamme. Dieser ist erforderlich. Flame bietet eine Reihe von Tools
für die Erstellung der Spiele, darunter Widgets für die Eingabe von
Sprites und Emissionen sowie die Verwaltung der Spiellogik. Ich kopiere
es einfach und füge es in die
Pub-Spezifikations-Punkt-YAML-Datei unten hier im
Abhängigkeitsbereich ein. Speichern Sie es einfach. Und ein anderes Paket
, das benötigt wird, ist dieses, das Audio verantwortlich ist. Flame Audio ist ein
Paket, das
Tools für den Umgang mit
Audio und Spielen bereitstellt . Es enthält Hilfsprogramme zum Laden und Abspielen von
Soundeffekten und Musik, Verwalten von Audiokanälen und zum
Steuern der Audiowiedergabe. Kopiere einfach auch diesen. Und füge es hier ein. Speichern Sie es. Okay, ich denke, es
funktioniert gut. Wir haben die Pakete. Dann erstelle ich als Nächstes einen neuen Ordner, Assets im Stammverzeichnis unseres
Projekts, das sich hier befindet Ich werde einfach Assets erstellen. Hier benötigen wir zwei neue
Ordner, Audio und Bilder. Dies ist die vorgeschlagene
Ordnerstruktur oder das gefälschte Flame-Spiel, das ist die visuelle Struktur. Unser Ordner,
Asset-Ordner wie dieser
, also Audio, Bilder. Und ich habe die
notwendigen Assets in diesem Video
sowie im
letzten Video angehängt , in dem wir ,
Sie können den gesamten
Quellcode herunterladen . Ich habe diese Säuren. Ich kopiere es einfach und füge
es in unseren Projektordner ein. Wie Sie sehen können, haben wir den Hintergrund, das Logo des
Hantelspiels, verschiedene Arten von
Spielerkörpern, Proteinshake-Impfstoff
sowie das Virus. Und für Audio haben wir
Hantelsound, Proteinsound. Das heißt, wenn wir kollidieren und das Zeug sammeln, dann werden Geräusche abgespielt. Wenn Sie nach Ihren eigenen Bildern
suchen möchten, können
Sie direkt online
nach Mann, der Hanteln hebt, Zeichentrickimpfstoff, Ich kann PNG, Proteinshake, Ich kann PNG suchen. Und nach Audio können Sie einfach kostenlos
nach Game-Audio suchen. Jetzt haben wir den
Ordner, den Assets-Ordner, aber wir müssen
sicherstellen, dass wir
die neu erstellten
Ordnerspeicherorte
in der Pub-Spezifikationspunkt-YAML-Datei angeben die neu erstellten
Ordnerspeicherorte . Also hier können Sie unten sehen, Sie haben diese innere Zeile 64, Sie haben diese Vermögenswerte. Also einfach entfernen, zu dieser Zeile
gehen und einfach
entfernen, zweimal die Löschtaste drücken und dann nach unten gehen und zweimal
drücken. Ich hoffe, Sie wissen, dass diese
Studie sehr sensibel ist. Jedes zusätzliche Leerzeichen oder jede zusätzliche Tabulatortaste
löst einen Fehler aus. Hier werden einfach Assets,
Bilder
erwähnt , und das andere
ist Assets Audio. Und speichern Sie es. Das
war's für dieses Video. In der nächsten Sitzung werden
wir unsere Spielklasse erstellen. Danke.
3. Video 2 Einen Spielkurs erstellen: Hallo. Jetzt lernen wir das
Konzept der Flame-Spielklasse. Dies wird das Herzstück, oder Sie können sagen, der
Einstiegspunkt unseres Spiels sein. Wir werden
alle unsere anderen
Komponenten von hier aus erstellen und verwalten alle unsere anderen
Komponenten von hier aus Gehen Sie zur Hauptpunktdatei. Und lass uns entfernen, einfach alles
entfernen. Okay? Ich möchte hier
alles entfernen. Lassen Sie uns eine separate Klasse für unsere Spielklasse erstellen, die ein separater
Ordner in ihrem Leben ist. Erstelle einfach einen neuen
Ordner und nenne ihn Spiele. Und darin erstelle
eine neue Datei. Gewicht. Kämpferspiel. Auch kein Dart. Die Spielklasse implementiert ein
komponentenbasiertes Spiel. Es hat einen Baum von Komponenten und ruft die Update- und
Rendermethoden aller Komponenten auf, die dem Spiel hinzugefügt
wurden. Um also eine
Flammenklasse zu erstellen, musst
du einfach eine Klasse
erstellen, dieses F8-Kämpferspiel, und sie auf das
Flammenspiel wie dieses erweitern. So
erstellt man eine Spielklasse. Es hat also eine Onload-Methode, oder der Methodensatz ist es
auch, aber unload. Und hier werde ich es
einfach zur Zukunft machen. Und eine Spüle hier beziehe ich auf eine Spülenkomponente, die
jeder andere Bildhintergrund ist. Das sind alles Komponenten,
die mit
Hilfe dieses Unloads
direkt
zur Spielklasse hinzugefügt werden können . Und hier verwenden wir die Methode
add, um
diese Komponente für unsere Klasse hinzuzufügen . Und dieser Onload wird beim
Start unseres Spiels nur
einmal ausgeführt . Das ist also die Flame-Spielklasse. Lass uns über
das Spiel-Widget sprechen. Jedes Spiel, das du
mit Flame spielst, ist starr. In unserer Florida-Anwendung wie bei jedem Text oder jeder Schaltfläche ist
das Spiel-Widget
wie bei jedem Text oder jeder Schaltfläche ein
Flatter-Widget, mit dem
dieses Spiel in den
Florida-Widget-Baum eingefügt wird . Es ist also sehr einfach. Gehe einfach zur Hauptpunktpunktdatei
und entferne diesen Code, der meine Klasse
ist, und der andere
Unleash, der übrig bleibt, ist die Hauptklasse. Wir können das
Spiel-Widget hier in der Run-App direkt weitergeben. Und es erfordert eine Spielinstanz , die einfach das
Objekt unseres Spiels,
wie diesen Final
Fight, ihr Spiel nennt . Das Spiel hier. Übergeben Sie einfach die Variable. Und um sicherzustellen
, dass es fertig ist. Wir werden dieses Florida,
ein Widget Florida, verbindlich
und unverbindlich schreiben ein Widget Florida, verbindlich
und unverbindlich , nicht
sicherstellen, dass es initialisiert ist. Also wird alles durch das Flattern
initialisiert. Speichern Sie jetzt alles, öffnen Sie das VR-Gerät, das heißt, ich verwende einen Emulator, aber Sie können auch Ihr
eigenes Gerät verwenden. Jetzt warte, das. Fangen Sie einfach an zu debuggen. Es könnte einige Zeit dauern. Mal sehen, was der Fehler ist? Ich glaube nicht, dass hier ein Fehler
vorliegt, okay, ich habe vergessen, einen Schrägstrich zu geben. Das ist ein sehr dummer Fehler. Entwickeln Sie jetzt einfach
die Anwendung. Das sind sehr kleine und dumme
Fehler, die passieren. Wie Sie sehen können, gibt es eine, unsere App läuft, aber sie wird nichts tun. Wir sagen einfach schwarzer leerer
Bildschirm in unserem Gerät. Wie wir wissen, haben wir bereits die Assets Audio hinzugefügt und Bilder
im Asset-Ordner hinzugefügt. Aber anstatt diese
Dateien überall namentlich aufzurufen, erstellen
wir eine
separate Datei dafür. Lassen Sie uns also einen Ordner erstellen. Der Name besteht aus Konstanten, und
darin wird eine Datei erstellt. Globale Punkte, Punkt. Wir werden alle
Asset-Namen in statischen Variablen speichern. Dieser Ansatz vermeidet
Rechtschreibfehler und es ist praktisch, Vermögenswerte später zu
ändern. Lassen Sie uns eine globale Klasse erstellen. Als Erstes mache ich diesen Konstruktor
einfach privat, damit wir kein Objekt
oder eine Instanz dieser Klasse erstellen müssen. Wir werden
die Bilder direkt mit
dieser statischen statischen Zeichenfolge aufrufen . Tasche geschliffen. Sprite entspricht dem
Namen des Hintergrundsprites und ist Background Dot JPG. Dicht, so dick. Hat einen Blick geworfen. Bring helle Hanteln mit. Wird es
Dumbbell Dot PNG machen? Dann static, const,
string player. Dünn. Sprite ist unglaublich ähnlich zu Layer Skinny Dot PNG. Jetzt kopiere es einfach und
füge es so ein. Dann haben wir als nächstes Player Sprite. Es wird Player Fit Dot PNG sein. Dann haben wir den
muskulösen Spieler Sprite. Es ist Muscular Dot PNG. Du hast Fieber. Das heißt, wenn er angegriffen wurde, dann haben wir
Layer-Fieber, dieses PNG. Dann haben wir das
Sprite für Viren. Virus. Und der Sprayname ist Virus Dot PNG. Hab noch etwas Zeit eingefügt. Als nächstes werden wir impfen, dieses PNG
impfen. Und dann haben wir
Protein Sprite. Und der Name ist
Protein ik dot PNG. Das sind die Bilder. Jetzt ist es Zeit für das Audio. Fügen Sie es einfach ein und es
wird Number Sound sein. Der Soundname ist Nummer, der Ton ist MP3. Wenn Sie es kopieren, fügen Sie es viermal ein. Der nächste ist drahtloser Sound. Es wird weniger PNG sein. Nächstes Impfstoffgeräusch, Soundpunkt. Das ist Welle, das ist Welle. Und schließlich haben wir
den Protein-Sound. Hier ist Protein
Sound Dot, mp3. Ja. Unsere Konstanten sind also bereit. Es wird für uns sehr
praktisch sein,
jedes Asset später
in unserer Anwendung anzurufen . Und Q
4. Video 3 Hintergrund und Player hinzufügen: Hallo, willkommen zurück. In diesem Video werden wir unsere erste Komponente
erstellen. Komponenten sind die
Grundbausteine für ein Flame-Spiel. Jede Entität oder jedes Objekt innerhalb des Spiels kann
als Komponente dargestellt werden. Es ist
Widgets in Florida ziemlich ähnlich. Alles, was wir
oben auf dem Bildschirm sehen, das sind alle Komponenten, z. B. Hintergrundbild,
ältere Zeichen ,
Objekte auf dem
Bildschirm usw. Gehen wir also zum Ordner lib. Erstellen Sie einen neuen Ordner
namens Come ponens. Und darin, wenn eine
neue Datei erstellt und sie die Hintergrundkomponente k genannt wird, erstellen Netze
einfach eine Klasse. Aber Bodenkomponente. Dadurch wird die
Sprite-Komponente wie folgt erweitert. In dieser
Blame Game-Engine ist
eine Sprite-Komponente nun ist
eine Sprite-Komponente ein grafisches Objekt, das ein
2D-Bild oder eine Animation
darstellt. Es wird normalerweise verwendet, um Charaktere,
Gegenstände oder andere Objekte
in der Spielwelt
darzustellen . Sprite-Komponente kann
positioniert, gedreht und skaliert und kann für verschiedene
Frames einer Animation aktualisiert werden. Hier. Dies hat eine eigene
Onload-Methode. Jede Komponente hat also
entladen, entladen, aktualisieren. All diese Methoden sind vorkonfiguriert. Wir schreiben einfach Sprite, das ist der Wert dieser
Sprite-Komponente. Hier. Jetzt verstehe einfach, das
ist nur die Komponente und wir müssen diese Komponente
zu unserer Hauptspielklasse hinzufügen. Also
brauchen wir auf jeden Fall eine Referenz, die mit einem Mixin
namens Width erstellt
werden kann , das Spiel wie dieses
hat und den
Spielnamen Fistfight hat. Ihre Klasse. Dies ist
die Spielklasse, deren Spielreferenz
verwendet wird, um anzuzeigen , dass ein Objekt einen Verweis
auf die aktuelle Spielklasse hat. Das heißt, dies hat den Bezug zur
aktuellen Spielklasse. Dies ist nützlich, da
viele Spielobjekte auf globale Variablen zugreifen
müssen. Jede Variable, die sich
hier in dieser Klasse befindet, z. B. Partituren oder etwas anderes, die Eingabe, die
die Audiowiedergabe behandelt. Mit anderen Worten, wir können von dieser
Klasse aus auf die
Eigenschaften und Methoden zugreifen ,
die in dieser Spielklasse enthalten sind, so einfach ist das. Und wir können auf
unsere Sachen zum Senden oder Laden zugreifen , indem wir diesen Game-Ref
verwenden, den
Ref-Punkt für das Partyspiel, das hell geladen wird. Welches Sprite wollen wir dann? Globale Starthintergründe. Sprite, dieser. Und wie
groß sollte dieser Leuchter sein? Es sollte die
Größe dieses Spiels haben. Das ist der komplette Bildschirm. Okay, jetzt, wenn ich es speichere, wird
nichts passieren. Okay? Ich hoffe, Sie verstehen, dass dieser Onload den Lebenszyklus
dieser Komponente darstellt. Wir verwenden das
OnLoad-Event, um
dasselbe wie
diese Spielklasse zu erreichen . Dass es
sicherstellt, dass alles bereit
ist, wenn es
zum ersten Mal aufgerufen wird. Und die Punktgröße von Game Dev nimmt die gesamte Breite und
Höhe des Benutzergeräts an. Um nun diese Komponente
in ihnen, in diesem Spiel, zu zeigen, müssen
wir einfach diese Methode zum Hinzufügen
verwenden
, mit der der Spielwelt ein neues
Spielobjekt hinzugefügt wird. Die Hinzufügen-Methode ist also nützlich neue Spielobjekte
wie feindliche Spieler
hinzuzufügen oder wenn
ein neues Level geladen wird. Für all diese Dinge. Anzeige wird verwendet. Wir müssen nur eine solche
Hintergrundkomponente schreiben. Auch hier
handelt es sich um einen Vorgang,
der aufgerufen wird, wenn das Spiel zum ersten Mal geladen wird und
eine neue Instanz der
Hintergrundkomponente erstellt wird . Jetzt speichern wir es. Wir haben das Spiel starr
auf ihr Spiel abgestimmt Ist ihr Schema Referenz? Ja, ist alles, was ich einfach dominieren werde. Und fang wieder an. Ich denke, ich hätte das
Hinzufügen mehrmals aktualisieren sollen. Mal sehen, was passiert,
wenn Fred und nochmal
sehen, dass wir dieses
Hintergrundbild haben. Dieser Fehler war also dieser. Wir mussten
unsere Anwendung entfernen, neu starten oder manchmal
beenden und starten neu starten oder manchmal
beenden und starten, da wir den Hartree-Load
nicht verwendeten. Ähnlich wie bei diesem Hintergrund erstellen
wir auch eine Sprite-Komponente
für unseren Player. Gehen Sie einfach zum Komponentenordner und erstellen Sie eine neue Punktdatei. Layer-Komponente. Punkt, Punkt. Ja, ähnlich wie
Light Layer Component erweitert Bright Component und hat ein Mixin, das
hier als Referenz zum Spiel dient. Wie ihr Spiel, so. Höhle. Jetzt müssen
wir das Entladen benutzen. Mein Vater sagte, das Entladen sei in der Zukunft. Dann. In ähnlicher Weise verwenden wir die Sprite-Eigenschaft
dieser Spread-Komponente da das
Sprite geladen werden soll. Dieses Ladesprite und das ist der Bildname,
Global Start Player. Globales Los. Wir haben den
Spieler Skinny, diesen. Dann. Jetzt gibt es auch andere Eigenschaften einer Sprite-Komponente. Das sollte
die Position dieses,
richtig, dieses Bildes unter dem Spiel sein. Also sollten wir es platzieren, wir werden es einfach in die
Mitte des Bildschirms stellen. Das heißt, wir nehmen den kompletten
Bildschirm und teilen ihn durch zwei. Zeigen wir es in der Mitte
des Bildschirms, X-Achse und Y-Achse. Nun, was sollte die Höhe sein? Wir werden hier nur
die Höhe
in einer Variablen erwähnen , damit wir sie ändern können. Wann immer wir wollen. Sprite, die Größe
wird 100 sein. Schreiben Sie einfach, Höhe ist gleich
Gewicht ist gleich psi. Also der erhöhte, der
sollte derselbe Anker sein. Anker wo wo. Der Anker einer
Sprite-Komponente
bezieht sich also auf den Punkt darin. Das wird also ebenso verwendet wie der Ursprung oder der Mittelpunkt der
Sprites. Das heißt, es wird als
Referenz für die Partitionierung, Drehung und
Skalierung des Sprites verwendet. Standardmäßig
befindet sich der Ankerpunkt oben links, aber im Moment haben wir ihn in die Mitte
geändert. Jetzt. Jetzt lasst uns alles retten. Und in ähnlicher Weise müssen wir
dies auch in unserer
Hintergrundkomponente hinzufügen . Also werden wir eine solche
Ebenenkomponente hinzufügen. Und denken Sie auch daran, dass Komponenten in dieser Reihenfolge hinzugefügt
werden. Wir haben sie erwähnt, das heißt, wenn wir den Hintergrund
unter den Spieler schreiben, können wir
diese Player-Komponente nicht
auf dem Bildschirm sehen . Und außerdem werde ich das einfach global
ändern. Da der Dateiname global ist, ändere
ich ihn einfach in
global und nehme die Änderungen vor. Von. Jetzt. Wir starten
die App und sehen, Sie können die Player-Komponente
in der Mitte des Bildschirms sehen . Und wenn ich Größe oder Position sage, sind
es X-Achse und Y-Achse. Ich hoffe, Sie haben gelernt
, wie Sie Ihre ersten Komponenten erstellen. Im nächsten Video werden
wir daran arbeiten, unserem Spiel
einen Joystick hinzuzufügen. Danke.
5. Hinzufügen von Bewegung mit Joystick: Hallo, willkommen zurück. Jetzt ist es an der Zeit, dass wir unserer
Spielerkomponente
etwas Bewegung hinzufügen . Plane bietet uns verschiedene
Eingabeoptionen wie Tastatur, Gesten, Ziehen usw. Da wir jedoch beabsichtigen, ein Handyspiel zu
entwickeln die meisten Mobilgeräte keine haben
die meisten Mobilgeräte keine Tastatur oder
Hardwaretasten. Aus diesem Grund werden wir
einen virtuellen Joystick erstellen , welche Flamme? Dies kann mithilfe der
Joystick-Komponente erfolgen. Lassen Sie uns also einen neuen
Ordner in der Bibliothek erstellen, der als Eingaben bekannt ist. Erstellen Sie darin eine Datei. Joystick Punkt, Punkt. Erstellen Sie jetzt einfach eine Instanz der Joystick-Komponente. Joystick entspricht der
Joystick-Komponente von k. Joystick-Komponente
besteht aus drei Hauptelementen. Dieser Knopf, der Hintergrund
und der Rand. Also lass uns den Knopf jetzt
zu einer Kreiskomponente machen. Dann wartet EDS 30 Minuten. Lass es uns malen. Grundpalette, dieser rote Punkt mit Alpha
Zwei und roter Farbe. Dies ist der innere Kreis
, den der Benutzer ziehen wird. Dieser Knopf ist der. Dann haben wir den
Hintergrund. Hintergrund. Schon wieder. Ich habe eine Kreiskomponente. Der Radius wird größer als 80 sein. malen. Basic, Farbpunkt rot. Lass uns
eine Art von seiner Opazität ändern, eine Art Farbe. Okay, jetzt, dieser
ist der äußere Kreis. Sie werden es verstehen
, wenn es gerendert wird. Und dann endlich, lasst uns diesen Spielraum
haben. Konstante Kanteneinsätze. Randeinsätze, die
nur ich benötige. Hier. Links wird gekämpft werden. D-Modem wird für
T sein. Also das ist was, das ist die Position
des Joysticks. Position des Joysticks. Das ist also diese
Joystick-Komponente. Speichern wir unsere Datei. Lass uns diesen
Joystick zu unserem Spiel hinzufügen. Gehen Sie hier zur F8-Kämpferdatei. Klicken Sie genau rechts unten auf die
Player-Komponente. Joystick. Es wird
aus den Eingaben importiert. Und denk auch daran,
dass
wir das draggable Mixing
in der Hauptspieldatei verwenden müssen , in der
Hauptspielklasse, wenn wir irgendeine
Wahl haben, die Komponenten, also diese Breite hat das hineingezogen, denn
da du es auch verstehst, ziehen
wir den Regler hier. Lass uns nochmal auschecken. Okay. Entschuldigung nochmal, ich
muss auffrischen. siehe. Wir haben es jetzt. Mir hat die Farbe des
äußeren Kreises einfach nicht gefallen. Lass uns nochmal gehen. Der äußere Kreis
sollte handgeschrieben sein. Es sieht so nett aus. Fügen wir nun hinzu, dass dieser Zug
zu unserer Player-Komponente gegangen ist. Gehen Sie zur Layer-Komponentendatei. Zunächst werden wir eine
Joystick-Komponentenvariable haben. Das heißt, wir werden
diesen Joystick hier akzeptieren. In dieser Datei. Layer-Komponente erforderlich,
dieser Typ Punkt-Joystick. Okay? Also müssen wir
den Joystick hierher schicken. Ebenfalls. Lassen Sie uns die Geschwindigkeit erwähnen, mit der sich der Spieler bewegen wird. Es werden 500 sein. Jetzt
werden wir die Aktualisierungsmethode verwenden. Das Update ist jetzt eine
Art Game-Loop. Wir haben zwei Game-Loops, hauptsächlich Update und Render. Daher werden wir die meiste Zeit die
Aktualisierungsmethode verwenden. Die Flamme ruft die Aktualisierungsmethode einer
Komponente einmal in jedem angekreuzten Frame der Event-Schleife auf
, um jede geänderte Spielkomponente
neu zu zeichnen. Es ist ähnlich wie bei
Fluttern. Baue meinen Zug. Wir werden
hier in diesem Update Logik hinzufügen, meine Regieposition,
den Charakter oder die Bewegung
der Charaktere. Die Aktualisierungsmethode benötigt
einen einzelnen Parameter, nämlich die Delta-Zeit. Das heißt, dieser d t wird in Sekunden
gemessen. Diese Deltazeit wird verwendet, um sicherzustellen, dass sich
Spielobjekte auf
verschiedenen Geräten und Bildraten konsistent bewegen und
verhalten . Beispielsweise wenn sich ein Spieler mit einer Geschwindigkeit von hundert
Pixeln pro Sekunde
bewegen soll . Und die seit
dem letzten Bild verstrichene Zeit betrug 0,02 s, das Objekt sollte sich in diesem Frame um
zwei Pixel bewegen. Das sind 100 Pixel pro Sekunde
multipliziert mit 0,02 Sekunden. In diesem Spiel
können Entwickler Spiele erstellen, die sich
auf verschiedenen Geräten
flüssig und reaktionsschnell anfühlen . wir es jetzt hinzu. Das werde ich. Zuerst werde ich
einfach überprüfen, ob Joystick, dass Richtung
gleich Richtung ist,
Joystickrichtung, dass Leerlauf Das ist nichts los, dann kehre einfach von hier zurück. Wenn der Benutzer den Knopf nicht
zieht. Schwer woanders ist, einfach die Position zu
ändern, die
dieser, dieser variable Punkt hinzufügt. Wir werden dem Frühlingsfest den Joystick Relative
Delta hinzufügen. Ich werde dir zeigen,
was passiert, wenn ich das Delta nicht multipliziere. Also schicken wir einfach so
einen Stock. Schauen wir uns unsere Anwendung an. Jetzt. Wenn ich es nach oben ziehe, siehst du, es ging so schnell. Aber wenn ich zur
Spielerkomponente gehe, wenn ich auch d T multipliziere, dann wirst du sehen, dass
es sich so glatt anfühlt. Die Bewegung. Es fühlt sich so gut an. Unsere Bewegung
läuft also richtig ab. Das war's für dieses Video. Wir sehen uns in der nächsten Sitzung.
6. Video 5 Screen für den Spieler: Hallo. Wie Sie sehen, bewegt sich
unser Spieler gut, aber wenn er sich
der Grenze nähert, überschreitet er sie. Das heißt, er
überschreitet die Grenze. Wir müssen also einige Logiken erstellen
oder implementieren ,
damit dieser Benutzer
die Spieler-Grenze nicht verschieben kann. Das ist, denn hier muss er aufhören. Hier muss er so aufhören. Wir müssen also sicherstellen, dass sich der Player nur innerhalb
dieses Gerätebildschirms bewegen
kann. Go-to-Player-Komponente. Ja. Lassen Sie uns zunächst eine Grenzvariable
für alle vier Seiten erstellen. Spät, doppelt, rechtsgebunden, spät, linksgebunden, gebunden, runter, gebunden. Da es sich um späte Variablen handelt, müssen
wir sie natürlich im Onload
initialisieren. Rechtsbündig wird ein Spiel
dieser Größe sein, NICHT x -60. Also werde ich
Ihnen diesen Wert erklären. Das ist also die richtige Grenze. Okay? Also haben
wir zuerst das Spiel
rho f Punktgröße x gemacht, die X-Achse. Diese Seite. Wir haben
hier die gesamte vertikale
oder horizontale Größe genommen und dann -60, damit es
nicht auf diese Seite geht. Das heißt, ich möchte nicht, dass
es hier blaugrün ist. Wenn ich dem Spiel nur die
Ref-Punktgröße x gebe, wird
es Delia sein, also gebe ich -60, also wird es hier gestoppt. Wir subtrahieren 60. Also wird es hier aufhören. Das war also die
Logik für die
Rechtsgrenze oder die Linksgrenze. Es werden einfach 60 sein. Das heißt, wenn wir Null schreiben, dann wieder dasselbe Konzept. Es wird bis zum Ende dauern. Aber ich gebe nur eine
Art von, man kann sagen, Spielraum 60. Die Obergrenze wird dieselbe sein. 60. Da y beginnt,
beginnt y mit Null, wir addieren nur Null plus 60. Hier, da die X-Richtung mit Null
beginnt. Und hier subtrahieren wir nur. Ich hoffe, Sie verstehen
die vollständige Größe des Bildschirms -16. Und links fängt bei Null an
und dann haben wir das unten. Spiel mit einem roten Punkt in der Größe eines Punkts. Warum ging
das bis zur vertikalen Richtung, ging bis zum Boden und subtrahiere dann sechs. Höhle. Jetzt haben wir die Variablen. In der Aktualisierungsmethode. Wir überprüfen einfach, ob die X-Achse und Y-Achse des Sprite die Kaufgrenzen überschreiten, dann werden wir die X
- und Y-Achsenwerte konstant machen. Das heißt, ist der Wert,
der den Rand der Grenze darstellt. Ich werde es noch einmal umsetzen
und erklären. Also unten hier. Und wir
sagen einfach, wenn nicht ideal, dann überprüfe die Grenzen nicht. Prüfen Sie, ob
die X-Achse der Sprite-Komponente größer
als gleich der Markierungsgrenze ist , dann
die X-Achse zum rechten Bündel Diese fügen dieser Position keinen weiteren
Wert hinzu. Nochmals, ich möchte es erklären. Das heißt, hier ist der
Spielerzugriff auf die X-Achse Null. Dann fängt es an zuzunehmen,
zuzunehmen, zuzunehmen. Dann ist es in der richtigen
Richtung, das ist hier. Jetzt müssen wir nur noch sicherstellen, dass die
X-Achse nicht zunimmt. Wir weisen nur das XX zu, rechte Grenze
von angedeutet ist, dass ihm dieser Wert immer wieder zugewiesen wird . In ähnlicher Weise. Prüfen wir, ob die X-Achse kleiner als
gleich der linken Grenze ist, dann ist x gleich der linken Grenze. Wenn nun die Y-Achse größer
als gleich der oberen Grenze ist, dann ist y gleich der Bindung. Und wenn y
größer als gleich
Downwound ist , dann ist y gleich dem jetzt ungebundenen K. Wir
müssen hier nichts ändern, was neu gestartet wird. Wenn ich nun versuchen würde, in eine Richtung zu
gehen, achte
darauf, dass
die Grenzen perfekt funktionieren. Jetzt. Hier gilt, wie gesagt, wenn die X-Achse größer als die Rechtsbindung
ist, Sie einfach sicher, dass der
x-Wert die Rechtsgrenze ist. Okay? Jetzt
ändere ich einfach die Valenz. Zeig dir, was der Unterschied ist. Wenn ich das letzte Mal
das drücke, wenn ich nur zB wenn ich es schreibe, was passiert, wenn ich direkt
zu write exists c übergehe, okay? Es war zu viel wert, okay? Wenn ich nur gebunden schreibe, sollte es meiner Meinung nach nur plus sein, es sollten minus
-60 mehr sein. Lass uns sehen. Wenn ich C wähle werden
wir hier auf -60 geschoben. Das ist -60. Aber ich will,
ich will keine -60. Deshalb will ich nur die
X-Achse bis zum, bis zum Ende. Das ist dieser. Das war's. Das Gleiche gilt für jede
andere Richtung. Ich hoffe, Sie haben das Konzept
verstanden. Wenn Sie nur
eine oder zwei Apps erstellen, werden
Sie sich einfach
an diese Konzepte und all das gewöhnen. Ich danke dir. Wir sehen uns
im nächsten Video.
7. Video 6 Dumbbell hinzufügen: Hallo. Lassen Sie uns nun
eine neue Sprite-Komponente
für diese Hanteln erstellen . Erstellen Sie im Komponentenordner eine neue Datei. Ponens-Komponente, Punkt, Punkt. Okay, in ähnlicher Weise
werden wir den Nachnamen hinzufügen. Komme der Gegner erweitert die
Sprite-Komponente. Es wird das Spiel OF
Mixin für ihr Spiel fit machen. K. Zahlen, richtig? Größe wird gespielt. Die Höhe entspricht 60. Lass uns meinen Gesamtbetrag abladen. Nochmals, das ist Sprite. Der Wert wird abgewartet werden. Spiel Ref Dot Load Sprite, Globals Dot Dumbbell Sprite. Die Höhe entspricht dem Gewicht
, das 60 entspricht. Das ist die
Sprite-Höhenvariable. Partition wird Vektor Zwei ist nur die X-Achse
und die Y-Achse. Ich gebe einfach den
x-Wert bei 200, 200 an. Das werden wir später ändern. Und der Anker wird der Mittelpunkt des
Ankerpunktes sein. Speichern Sie es. Fügen wir nun diese
Hantelkomponente in unser Spiel ein. Gehe zum FIT-Flugtarif. Von. Dann unter der Layer-Komponente. Füge hier einfach diese
Hantelkomponente hinzu, k. Lass uns die
App neu starten und auschecken. Siehst du, wir haben die Hantel hier. Offensichtlich passiert nichts, wenn wir jetzt die Hantel berühren. Aber zumindest das, unsere Spiele-App sieht
irgendwie gut aus. Die Leute können es sehen und sagen, okay, das ist eine Art Spiel. Das war's für dieses Video. Im nächsten Video werden wir an dieser
Kollisionserkennung
arbeiten. Danke.
8. Video 7 HitBoxes zu Komponenten hinzufügen: Hallo. Jetzt ist es an der Zeit, an
der Logik zu arbeiten , dass jedes Mal, wenn sich
der Spieler
der Hantel nähert, etwas auf dem Bildschirm
passieren sollte,
ob wir in der Lage sein sollten, sie beide und alle
zu erwischen. Diese Funktionen können mithilfe
des Konzepts der Kollisionserkennung
durchgeführt werden . Kollisionserkennung ist in den meisten Spielen
erforderlich, um
zwei sich kreuzende
Komponenten zu erkennen und darauf einzuwirken erkennen und darauf einzuwirken, z. B.
ein Pfeil, der eine Münze trifft und ein anderer
Spieler, der eine Münze aufhebt. Um Kollisionen
an einer Komponente zu erkennen,
muss diese Komponente also von einem
genauen Begrenzungsrahmen umgeben sein. Und technisch gesehen sind sie als Hitboxen
bekannt. Lassen Sie uns es jetzt implementieren. Der erste Schritt besteht also darin, die
Kollisionserkennung in
unserer Hauptspielklasse zu aktivieren . Und in dieser Klasse können wir das
tun, indem wir einen Mixing-Call hinzufügen. Hat Kollisionserkennung, so
einfach ist das. Es wird also
sicherstellen, dass unser Spiel jetzt alle
Kollisionen zwischen Komponenten abhört. Um sicherzustellen, dass
unsere Komponenten miteinander
kollidieren können, müssen
wir nun unsere Komponenten miteinander
kollidieren können, das als Kollagen-Callbacks
bekannte Mixin hinzufügen. An diese Dinge
musst du dich nur erinnern, das ist alles. Wieder dasselbe in ihnen. Callbacks zur
Kollision von Layer-Komponenten. Jetzt müssen wir einer Komponente
Wärmekästen hinzufügen. Dieses
Kollisionserkennungssystem unterstützt drei verschiedene Arten von
Formen, die Sie erstellen können. Ich hasse Boxen von. Diese Formen, unser Polygon,
Rechteck und Kreis. Komponente können mehrere
Hate-Boxen hinzugefügt werden, um den Bereich zu finden, der zur Erkennung von Kollisionen
verwendet werden kann. Ohne die Headbox hinzuzufügen, ahnt
diese Komponente nicht, dass sie kollidieren kann. Unsere Interessen
überschneiden sich. Nun, da unsere Hantel
so ist, ist die Struktur unserer
Hantel irgendwie rechteckig. Also werden wir
das rechteckige Feld zu
unserer Hantelkomponente hinzufügen . Wir können es einfach so hinzufügen. Wenn die Onload-Funktion verwendet wird, ist
sie dem
Hinzufügen einer anderen Komponente sehr ähnlich. Gehe zur Player-Komponente
und mache dasselbe. Im OnLoad. Fügen Sie einfach
Tangle Head Box Lady hinzu. Okay, wenn ich jetzt speichere
und zu unserer App gehe, wirst
du keinen Unterschied sehen. Aber wir können, zumindest
in diesem Debug-Modus, eine
von der Lemma-Engine bereitgestellte Funktion
verwenden. Das heißt, wir können
den de Beauvoir auf true einschalten. Es ist ein Tool, mit dem
Entwickler Kollisionen zwischen
Objekten in der Spielwelt visualisieren und debuggen können. Wenn der Debug-Modus aktiviert ist, werden
Kollisionsobjekte hervorgehoben so angezeigt
, dass Entwickler sehen können wo sie sich befinden und wie sie miteinander interagieren
werden. Geh einfach zur Hantel. Und hier ist Just Write
Debug-Modus gleich wahr. Und das Gleiche gilt für den Spieler. Unten hier. Just write Der
Debug-Modus entspricht true. Speichern Sie jetzt und starten Sie neu. Jetzt können Sie
eine Art rechteckiges Feld sehen. Jetzt kannst du dir zumindest den Headbox
vorstellen. Das ist also die Kopfbox. Offensichtlich. Nochmals, im
Moment wird nichts passieren. Wir müssen
noch einige Funktionen hinzufügen , um sicherzustellen, dass die
Kollision stattfindet. Aber zumindest wissen wir , dass wir
den Headbox implementiert haben. Und sieh mal, wenn ich gehe, die X-Achse ist zwei Neuntel, eins, wenn ich hierher gehe, ist
die X-Achse offensichtlich Null, aber du kannst sie nicht sehen. Das Gleiche gilt für die Y-Achse. Schau hier. Ähnlich wie im Debug-Modus , in dem Hitboxen ein Feld
namens Kollisionstyp C haben, wie dieses, Kollisionstyp Punkt, haben
wir aktiv,
inaktiv und passiv. Passiv bezieht sich auf eine Art von Kollisionsobjekt, das
sich nicht bewegt oder auf Kollisionen reagiert. Beispiel. Nehmen wir an, wir entwickeln ein Spiel, bei
dem der Ball durch
den Raum springt. Die Wände des Raums werden passiv vom Kollisionstyp
sein. Dann haben wir den
aktiven Kollisionstyp, standardmäßig einen
Kollisionsobjekttyp
, der sich bewegen und
auf Kollisionen
mit anderen Objekten reagieren kann . Beispielsweise
gibt es in einem Spiel, in dem wir ein durch den Weltraum
fliegendes Raumschiff
steuern, ein durch den Weltraum
fliegendes Raumschiff
steuern, viele Kugeln , die nicht
miteinander kollidieren können. Linie zum Raumschiff. Raumschiff wird auf den
Kollisionstyp Punkt aktiv gesetzt, aber die Kugeln werden
auf den Kollisionstyp Punkt passiv gesetzt . Dann haben wir die Inaktiven. Inaktiv
bezieht sich dagegen auf einen Typ von
Kollisionsobjekt, derzeit
in der Spielwelt nicht aktiv
ist. Dies kann für die
Leistungsoptimierung nützlich sein, da inaktive Objekte erst dann auf Kollisionen überprüft
werden
müssen , wenn
sie aktiv werden. Passe ein YouTube an. Ich wollte euch nur
wissen lassen, dass dieses Konzept
verfügbar ist , sodass ihr
in zukünftigen Spielen, wenn ihr irgendeine Art von
Kollisionstyp,
passiv oder so seht , zumindest
wisst, dass das mit den
Kollisionen und Trefferfeldern zusammenhängt. Danke. Das ist
alles für dieses Video. Wir sehen uns in der nächsten Sitzung.
9. Video 8 Auf eine Kollision reagieren: Der nächste Schritt besteht nun
darin, sich im
Falle einer Kollision
zwischen zwei Komponenten benachrichtigen zu lassen. Flame überprüft das bei jeder Aktualisierungsschleife für
Sie. Sobald wir Kästchen treffen, interagieren oder uns überschneiden, wird die On-Kollisionsmethode aufgerufen
, die wir vermeiden müssen. Dieser Overhead ist aufgrund
dieser Kollision
möglich , die
als Rückmischung bezeichnet wird. Unten beim Laden, genau richtig
bei Kollision hier. So wie das. Wir erhalten also zwei Parameter für
die Kollisionsmethode. Eine ist eine Liste von Punkten, die sich zwischen den Trefferfeldern überschneiden, das sind Schnittpunkte. Und die andere ist die Komponente , mit der diese Komponente kollidiert ist. Das ist Hantel mit, kollidiere damit dieser Spieler. Jetzt
schreiben wir einfach die Logik. Wenn diese andere Komponente, ist
Andere eine klare Komponente. Dann entferne einfach
diese Komponente , bei der es sich um eine Hantelkomponente handelt, von der übergeordneten Komponente, die
aus dem Spiel stammt, lass sie
einfach verschwinden. Lass es uns versuchen. Ich gehe
zur Hantel und sehe. Sie ist verschwunden. Es gibt also ein Gefühl oder einen Effekt, dass der
Spieler
diese Hantel gepackt hat , diese Zahl
gesammelt hat. kannst du sagen. Unsere Kollisionserkennung funktioniert einwandfrei. Wir können diesen
Debug-Modus entfernen, da wir ihn nicht benötigen. Jetzt. Fang noch einmal an und schau, ob ich
darauf zugehe, es verschwindet. Das sieht also gut aus. Lassen Sie uns nun einen Sound abspielen , wenn die Player-Komponenten mit ihnen
kollidieren. Komponente für Kurzhanteln. Das Flame-Audiopaket, das wir bereits zu
unserer Projektabhängigkeit hinzugefügt haben, ist ein Tool, das die
Audioverwaltung viel
einfacher und effizienter machen soll . Auf diese Weise müssen
wir
alle unsere Audiodateien
in der Node-Methode
unserer Spielklasse vorladen alle unsere Audiodateien
in der Node-Methode
unserer , die zum Fighter-Spiel passt. Hier in der Spielklasse, in der Onload-Methode. Schreiben Sie einfach Flame-Audio, Audio, Bargeld, Dotload und die
gesamte Auflösung. Es bedeutet einfach, dass
wir alles
in den Speicher laden , den Cache-Speicher. Dies akzeptiert eine Liste oder ein Array, bei dem
Soundnamen globale Zahlen sind,
Punkt, Hantelsound. Globale. Wir haben das Virusgeräusch. Dann ist da noch das globale
Punktimpfgeräusch. Und schließlich haben wir Liebhaber
Dot Protein Sound. Okay? Dieses Laden wird empfohlen
, da wir
versuchen würden, Sounds direkt
im Spiel abzuspielen , die nicht zum Cache hinzugefügt
wurden. Da, dann, da, dann kann
es zu einer Verzögerung
beim Abspielen des Sounds kommen. Danach spiele den Sound ab. Das ist erledigt. Lassen Sie uns diesen Sound
nach einer Kollision
in der Hantelkomponente abspielen . Hier. Wir schreiben einfach,
bevor Sie sich bewegen,
rechte Flamme Audio, das abgespielt wird . Und der Name, den wir
spielen wollen, der Hantelsound. K. Lass es uns testen.
Wenn ich in die Nähe komme. Ja.
Funktioniert der Sound richtig? Ich hoffe, du konntest dir dieses Geräusch
anhören. Das wird auch gemacht. Danke, dass du dir das
Video angesehen hast. Ich wünsche dir viel Spaß
beim Entwickeln dieses Spiels. Wir sehen uns in der nächsten Sitzung.
10. Video 9 zufällige dumbbell: Hallo, willkommen zurück. Bisher war also die Position
der Hantelkomponente festgelegt. Und nachdem der Spieler damit kollidiert
, verschwindet es. Lassen Sie uns modifizieren und zulassen Hanteln
an zufälligen Positionen erscheinen. Wenn der Spieler das also zuerst
aufhebt, entfernen wir diese
Hantelkomponente und
erstellen eine neue Hantel und erstellen eine neue Hantel und platzieren sie nach dem Zufallsprinzip auf dem Bildschirm. Und das wird so weitergehen,
bis das Spiel vorbei ist. Oh, gehe zur Punktdatei für die
Hantelkomponente. Erstellen Sie zunächst eine Instanz der zufälligen Klasse. Dadurch erhalten wir
die Mathematikbibliothek, mit Zufallszahlen generiert werden
können. Einfach so zufällig. Und sieh, du hast diese
dunkle Matte importiert. Lassen Sie uns eine neue Funktion erstellen , die ein Objekt mit zwei
Vektoren
, also X- und Y-Werten, zurückgibt und sie zum Vorhören bringt. Nun erhalten wir zuerst
den x-Wert, das heißt,
x ist gleich einer zufälligen
Ganzzahl neben int. Okay? Nun, wenn ihr
die Beschreibung hier seht, versteht
sogar, dass wir zufällige nächste Intensivstation
haben. Der Wert ist also größer als gleich Null und kleiner
als gleich Zehn. So kommen wir da hin,
zufällige Ganzzahl, okay? Wir werden einfach diese
zufällige Ganzzahl von X als Ref-Punktgröße des
Spiels
Punkt x Punkt zu int bekommen Ref-Punktgröße des
Spiels
Punkt x Punkt zu int und sie verdoppeln. Okay? Das bedeutet also, dass die X-Achse von Null bis zum Ende
des Bildschirmwerts eine
beliebige Ganzzahl für das x sein
kann . Ähnlich haben
wir für das Y einen zufälligen Punkt. Als nächstes int, game Raf, raf dot, size dot, size dot y. Integral,
da es Integer ausnimmt, aber wir müssen
es wieder auf Double ändern. Und dann geben wir
ein Vektor-2-Objekt
mit X und Y zurück . Ich hoffe, Sie verstehen, dass
dies nur dazu dient,
einen zufälligen X- und Y-Wert zu erhalten . Das war's. Das nächste Ding, das T-Shirt, kannst du
mich auch hier verstehen. Was macht es? Jetzt müssen wir diese Funktion
innerhalb der Onload-Methode
der Dumbbell-Komponente hier aufrufen . Wenn wir nun den Wert,
diese Position, hier
zuweisen ,
schreiben
wir einfach get random position. Okay? Außerdem entfernen
wir nach der Kollision die aktuelle
Hantelkomponente und
fügen danach erneut eine zufällige
Hantelkomponente zu diesem Spiel hinzu, fügen danach erneut eine zufällige
Hantelkomponente zu diesem Spiel hinzu diese
Zahl standardmäßig an einer
zufälligen Position befindet, da wir
diese Logik hier in
der Onload-Methode bereits erwähnt haben . Lass uns jetzt alles speichern und gleich sehen, dass der
Regenschirm da ist. Und wenn ich es noch einmal mache, aktualisiere es erneut,
es wird dorthin gehen. Und wenn ich es nehme
, dann generiert es nur
zufällige Positionen. Nun, das macht Spaß, werde ich sagen. Und das tut es offensichtlich. Der Hantelsound wird abgespielt. Aber da ich den
Bildschirm aufnehme, können
Sie ihn vielleicht nicht hören, aber ich bin mir sicher, dass
Sie ihn
in Ihrem eigenen System hören können. Ich hoffe, Sie haben
das Konzept der
Kollisionserkennung verstanden . Das war's für dieses Video. Wir sehen uns in der nächsten Sitzung.
11. Video 10 virus hinzufügen: Hallo, willkommen zurück. Bis jetzt ist das
Spiel also sehr einfach. Der Spieler kann
die Hanteln leicht greifen , ohne
auf Hindernisse zu stoßen. Wir müssen unser Spiel um
eine Herausforderung erweitern. Wir werden
zwei Viren hinzufügen , denen der
Spieler ausweichen muss. Erstellen Sie jetzt im
Komponentenordner eine neue Datendatei. Viruskomponente, Punkt hier. Ähnlich wie zuvor hat die Komponente
Great Virus X Dense Sprite Component eine Spielreferenz. Fit Fighter-Spiel. Wir haben die Sprite-Höhe. Lassen Sie uns das
Sprite I-T zum Schluss erwähnen. Und wir werden die
Startposition als Argument nehmen. Es ist ein Vektor, um die Partition zu starten. Und wir nehmen es so
, wie es gebaut ist, es wird so benötigt. Jetzt ist der OnLoad mein dritter ja. Warte. Und ich denke, in
der Ebene ist da. Ja, und ich habe nur
die richtige Debatte vergessen. Ein Flug wird wildrot
sein, dunkle Ladungen hell. Blauer Punkt y. Diese Sprite-Position ist
die Startposition, die an diese Komponente gesendet
wird. Dann entspricht
das Gewicht der Höhe, wobei eine
Höhe von 200 angezeigt wird. Mal sehen, wie viel 200 ist. Und n entspricht der Mitte der
Ankerpunkte. Füge nun einfach diese neu
erstellte Viruskomponente zur Spielklasse hinzu. Fügen Sie einfach drahtlose Komponenten hinzu. Startposition
jetzt, ich kodiere
sie gerade fest. Zu schätzen. Wir müssen senden
und lesen und 150. Und füge in ähnlicher Weise hinzu,
warum das hier ist. X entspricht der Größe des Punktes x -50 und der Größe des Punktes y -200. Sie können einfach
mit diesen Werten herumspielen und verstehen, was sie bewirken. Das ganze K tut es, oder? Die Höhe ist viel zu hoch. Geben wir 100. Es ist auch sehr groß. Dann lassen Sie uns einen
Test machen. Wenn ich ihm 60 gebe, natürlich. Ja. Die 60er sehen anständig aus. Nr. 2 und es sah sehr schlecht aus. Ja. Wir haben den Virus auch auf
unserem Bildschirm. Im nächsten Video werden
wir an der Bewegung
dieser Viruskomponenten arbeiten. Danke.
12. Video 11 Dem Virus Bewegung hinzufügen: Hallo. Wir können unsere beiden Viren in
ihrer Ecke des Bildschirms sehen, aber sie
bewegen sich nirgendwohin. Jetzt werden wir daran arbeiten, ihnen
Bewegung zu verleihen, sodass der Spieler ihnen ausweichen
und sich die Hanteln schnappen muss. Beginnen wir damit, dass wir hier
zur
Punktdatei der Viruskomponente gehen . Und lassen Sie uns einige Variablen erstellen. Zuerst wird
auf Geschwindigkeit gesetzt. Das wird die
Geschwindigkeit und die Geschwindigkeit sein. Sie werden es bewegen, 300. Natürlich werden wir es
mit D,
D und L multiplizieren . Lassen Sie uns eine Funktion
erstellen. In welche Richtung sie
einen Vektor gedreht haben, um sich zu bewegen. Stimmt es? Jetzt generiert die
erste
Codezeile einen zufälligen Winkel im Bogenmaß von Null. Dann entspricht der Winkel dem zufälligen Klassenpunkt,
der
als nächstes in zwei Teile geteilt wird. In Dubai. Dann müssen wir Kool-Aid schreiben. Der Sinus und der
Cos-Sinus des Winkels. Der Sinuswinkel entspricht dem Vorzeichen. Und der letzte Cos-Winkel des Manga entspricht dem zufälligen Cos-Winkel. Nun entspricht der Endwert der Geschwindigkeit bei x dem
Cos-Winkel zur Geschwindigkeit. Von einem anderen. doppelte Geschwindigkeit bei y
entspricht dem Sinuswinkel
dieser Geschwindigkeit. Und schließlich werden wir darauf
zurückkommen,
naja, schauen wir uns d x, d x an, nun, schauen wir uns DY an. Speichern Sie es. Also, was ist diese Funktion? Um ein Sprite
in einem zufälligen Winkel zu bewegen, müssen
wir zuerst einen zufälligen Winkel
erzeugen. Der Winkel wird typischerweise im
Bogenmaß gemessen, einer
Maßeinheit, die in der
Geometrie zur Beschreibung von Winkeln verwendet wird . Ein Vollkreis
entspricht zwei Pi-Radianten, was ungefähr 6,28 rad entspricht. Um also den
zufälligen Winkel im Bogenmaß zu erzeugen, können
wir eine Zufallszahl verwenden, um eine Zahl
0-2 pi wie diese zu erzeugen. Zufälliger Punkt. Das nächste Double ist mein Tech
to College, und das heißt, es generiert einen zufälligen
Wert zwischen 0,0 und 1,0, indem das Ergebnis
von NextDouble mit zwei multipliziert wird und Pi, wir generieren effektiv eine zufällige
Winkelzutat von 0 bis 2 Pi. Sobald wir einen zufälligen Winkel haben, verwenden
wir die Trigonometrie, um die X
- und Y-Geschwindigkeit zu berechnen Die x-Geschwindigkeit wird als
Kosinus des Winkels
multipliziert mit der Geschwindigkeit berechnet . Und die Y-Geschwindigkeit
wird am Sinus
des Winkels
multipliziert mit der Geschwindigkeit berechnet . Also ich muss sagen, dass diese
eine Kette i2 Google hat und
StackOverflow durchsucht und so. Sie müssen sich also nur diese Codezeile
merken. Und wenn Sie möchten, können
Sie natürlich auch
danach recherchieren. Als Nächstes
müssen wir der
Onload-Methode
einfach die Schreibgeschwindigkeit verwenden, die der Geschwindigkeit von Move Sprite
entspricht. Wir erhalten also die Geschwindigkeit, in welchem Winkel es sich bewegen wird. Und jetzt müssen wir eine Aktualisierungsmethode
erstellen. Und in Schulden, wenn
wir dritter sind, ändern wir die
Position auf die
Geschwindigkeit, Geschwindigkeit multipliziert mit
d t. Also, wie Sie wissen, indem wir die
Geschwindigkeitsvariable mit d t multiplizieren, stellen
wir sicher, dass das Sprite
EdTech
unabhängig von der
Bildrate mit gleichbleibender Geschwindigkeit bewegt , dass das Sprite
EdTech
unabhängig von der
Bildrate mit gleichbleibender Geschwindigkeit , z. B. wenn die Bildrate auf 30 Bilder pro Sekunde fällt
, dass der T-Parameter
ein Byte-Paket der zweites Sprite, wir erhöhen die Geschwindigkeit in diesem Frame auf eins
von 30 Einheiten. Und wenn wir es auf 60
erhöhen, wird
es in, das ist Geschwindigkeit
multipliziert mit eins mal 60 Einheiten. Dadurch wird nur sichergestellt, dass sich das Spiel konsistent
verhält auf verschiedenen
Geräten und Bildschirmen konsistent
verhält. Jetzt
speichern wir alles und starten neu. Und wie Sie sehen können, bewegen sich
die Viren. Das ist es also. Für dieses Video. In den nächsten Videos werden
wir daran arbeiten
, der Viruskomponente
sowie Kollisionen Grenzen zu setzen . Danke.
13. Video 12 Grenzen der Viruskomponente: Hallo. Wie wir sehen können, überschreiten
Viren
die Grenzen. wir sicher, dass eine Kollisionserkennung zwischen ihnen erfolgt. Füge dazu zunächst die Heatbox zur drahtlosen Komponente
sowie zur Spielklasse hinzu. Gehen Sie also hier zur
Viruskomponente. Und hier unter Geschwindigkeit über fügen Sie
einfach ein Kreis-Hitfeld hinzu. In der Fit Fighter-Spieldatei. Hier. Ich werde eine Screenhitbox hinzufügen. Das heißt, dieser ist neu. Es ist jede Kollision an den
Grenzen des Viewports. Entzünden. Screen Hate Box
ist ein Objekt, das die Grenzen
dieses sichtbaren Bildschirmbereichs
darstellt. Es wird verwendet, um festzustellen, ob unsere andere
Spielkomponente
im sichtbaren Bildschirmbereich befindet und auf dem Bildschirm gerendert werden
sollte. Jetzt speichere es. Jetzt in der Viruskomponente. In den drahtlosen Komponenten. Zur Kollisionsmethode. Zunächst prüfen wir, ob sich bei dem kollidierten Objekt um eine
Bildschirmheizbox handelt oder nicht. Also gehen wir einfach nach unten. Bei vier, bei Kollision. Wir müssen Läsions-Callbacks hinzufügen. Und dann bei der Kollision. Jetzt werden wir prüfen
, ob das ein Screenhit-Feld ist. Hier. Wir werden die
Kreuzungspunkte bekommen. Wie du weißt, gibt es diesen. Damit überprüfen
wir bedingt, überprüfen
wir bedingt in welche Richtung auf
dem Bildschirm kollidiert ist, und ändern dann die
Geschwindigkeit entgegengesetzt dazu. Hier. Machen wir es wie mit einem anderen Vektor zum
Kollisionspunkt. Wird es
Kreuzungspunkte, Punktdateien machen? Das ist der erste
Schnittpunkt. Das heißt,
sobald es mit dem Bildschirm kollidiert ist. Wir prüfen, ob der Wert des
Kollisionspunkts Punkt
x, x gleich Null ist. Das heißt, ganz links. Dann ändere ich die
Geschwindigkeit der X-Achse auf die Minusgeschwindigkeits-X-Achse. Und Geschwindigkeitspunkt-Y-Achse. Derselbe, das
ist der Geschwindigkeitspunkt y. Also ändere ich einfach die
Richtung der X-Achse. Ähnlich verhält es sich, wenn Läsionspunkt.xx Größe des
Spiel-Ref-Punkts Punkt x entspricht
, dieser Punkt ganz rechts. Dann werde ich dasselbe tun. Geschwindigkeitspunkt x ist gleich dem Minusgeschwindigkeitspunkt x , ändern Sie einfach den
gleichen Geschwindigkeitswert. Geschwindigkeitspunkt y. Entspricht dem Geschwindigkeitspunkt y. Dann werde ich überprüfen, ob Koalitionspunkt Punkt
y gleich Null ist. Der Geschwindigkeitspunkt x wird derselbe sein. Aber der
Geschwindigkeitspunkt y wäre negativ. Geschwindigkeitspunkt y.
Und schließlich,
und denken Sie daran, dass sich dieser Punkt Und schließlich, ganz oben auf
dem Bildschirm befindet. Wenn der Kollisionspunkt Punkt y
gleich game of.size.y.xy und zwei Minusgeschwindigkeit Punkt y ist. Okay, speichern wir alles
und schauen uns unsere App an. Href ist gleich Null. Mal sehen, was hier
los ist . Das Top funktioniert also. Okay, dieser funktioniert nicht. Lass uns sehen. C hat gut gearbeitet. Links, das ist ganz
rechts, funktioniert nicht. Ist größer als gleich, mal sehen. Dann ziehe ich mich um. Jetzt Geschwindigkeit K. Nein, das wird es nicht sein. In diesem Abschnitt. Erster Punkt. Es sieht, dass es nicht die Schnittpunkte der
Läsionen sind
, die diesen zuerst betreffen. Okay. Also links und
Topmodel arbeiten auf der rechten Seite. Und der Standard ist, diese Berechnung ist hier
nicht korrekt. Set von Dulles. Wie ich unten schon sagte. Die Unterseite funktioniert auch K. Wie Sie sehen können. Unten sage ich,
sie arbeiten daran. Die rechte Seite funktioniert nicht. Es sollte nicht weniger sein, denn
natürlich, lassen Sie uns sehen. Siehe Spielreferenz, Punktgröße k. Irgendein kleiner Fehler. Es sollte mehr
als gleich diesem Wert sein. Mal sehen, -60 cc. Im Moment funktioniert es
, weil -60 der Vorteil ist. Da wir den
Sprite-Kopf bei 60 haben. Das ist der Grund.
Diese Berechnungen sind also etwas komplex. Ich werde nicht viel sagen, aber ja. Wie Sie sehen können, funktioniert
es perfekt. Unsere Viren kollidieren und
bewegen sich überall auf dem Bildschirm. Ich danke dir.
14. Video 13 Kollision zwischen Virus und Player: Hallo. Jetzt ist es an der Zeit, dass wir an
der Funktionalität arbeiten. Grippe ist die Bewegung
des Spielers. Da er Fieber bekam, nachdem er mit einer der
beiden Viruskomponenten
kollidiert war . Wir haben bereits die Sound-Assets „Fever Sprite “
und „Virus“. Lassen Sie uns nun einige Variablen
in dieser Player-Komponente erstellen . Hier. Lassen Sie uns zunächst sehen. Sie legten ein glänzendes Bauteil. Spieler, mager, glückselig. Irgendwelche Notizen? Lass uns zuerst Player
Skinny It schreiben. Es ist hell. Schichtfieber. Ich schreibe den Spieler Skinny and Fever hier, weil
wir es
entsprechend den
Kollisionen ändern werden , wir haben den
Sprite hier
einfach direkt ausgegeben. Nun zur Onload-Methode werde
ich schreiben, dass Player Skinny dieser
entspricht. Genau hier. Spielerfieber ist
dasselbe, aber nur das
Sprite, das wir ändern werden. Das heißt, Schichtfieber ist hell. Und jetzt im Haupt-Sprite wird
es gleich zu
Beginn des Spiels dünn sein. Okay? Jetzt ist es an der Zeit, eine Logik zu
schreiben, nach der sich der
Spieler 3 s lang nicht
bewegen kann , nachdem er mit dem Virus
kollidiert ist. Wir werden auch dieses
Sprite-Image ändern. Lassen Sie uns neue
Zustandsvariablen sowie Funktionen
zum Ein - und Ausfrieren
der Bewegung des Spielers erstellen. Also hier werde ich eine
FASTA-Datei hinzufügen, wenn boolesche Virusangriff gleich falsch
ist. Und ich werde es benutzen. Dimer. Dimer
entspricht 3 s, es ist entspricht 3 s, also wie eingefroren für 3 s. Wir starten diesen Timer wenn der Virus und
der Spieler kollidieren. Lassen Sie uns nun eine Funktion erstellen:
void, freeze player
plus the fall. Wir werden prüfen
, ob , das stimmt. Und wir werden schreiben, nein, ich werde den Alpha-Level-Check posten. Wenn das angegriffene Virus falsch ist, dann friere
es nur ein, denn wenn es wahr
ist, ist es
schon eingefroren. Zunächst spielen wir den Sound Global
Start Virus Sound ab. Spielen Sie den Ton bei der Läsion ab. Dann schreiben wir, dass
Virenangriff gleich wahr ist. Dann machen wir Gene
richtig, um Fieber zu übertragen. Ändere das Sprite-Bild. Und schließlich
starten wir den Timer C. Okay? Außerdem werden wir eine Funktion
zum Auftauen der Ebene
erstellen . Wir werden einfach ändern, dass der
Virusangriff gleich falsch ist. Und ändere das wieder auf
Player Skinny. Ich hoffe, Sie haben
diese beiden Funktionen verstanden. Diese sind sehr einfach
und unkompliziert. In der Update-Methode überprüfen
wir nun unter bestimmten Bedingungen, ob Spieler
von einem Virus angegriffen wird oder nicht. Das heißt, wenn der boolesche
Wert falsch ist, lassen
Sie die
Joystick-Bewegungen zu. Und wenn der Wert drei ist, das heißt, wenn der Wert wahr ist, aktualisieren
Sie diesen Timer und rufen Sie die Funktion Unfreeze Player auf,
nachdem 3 s vergangen sind. Also werden
wir hier zunächst überprüfen, ob der Virusangriff falsch ist. Wenn es falsch ist, lassen
Sie nur diese Codes zu. Das ist all dieser Code. Einfach ausschneiden und hier einfügen. Denn wenn es so ist,
wenn es nicht von einem Virus
befallen wird, dann sind nur die Bewegungen erlaubt. Und da wir diesen Dimer
aktualisieren
, überprüfen wir das in Sekunden. Und wenn der Dimer fertig ist
, also 3 s vergangen sind, dann funktionieren nur noch kälter und
gefriert. Das ist jetzt auch erledigt. Schreiben Sie das schließlich
auf die Kollisionsmethode für diese Player-Komponente. Wir haben bereits den
Kollisionsrückruf. Also einfach hier der
Schlitten bei Kollision. Und wir werden einfach schreiben, ob deswegen diese Komponente dann einfach eine
Freeze-Player-Funktion genannt hat. Okay. Starte jetzt die App neu und
sieh dir den Sound an. Ist da. Spielerbild, Sprite friert ein
und wir können uns 3 s lang nicht bewegen. Und wenn es die
Hantel braucht, funktioniert es. Und wieder, wenn es zuschlägt, sind
seine Bewegungen eingeschränkt. Es sieht sehr gut aus. Ich hoffe, Sie haben die Funktionsweise
der Anwendung
verstanden und Spaß gemacht, sie bis jetzt zu erstellen. Danke.
15. Video 14 Textkomponente für die Partitur: Hallo. Jetzt funktionieren unsere Spielfunktionen
einwandfrei, aber wir müssen dem Benutzer mitteilen wie viele Hanteln er in Form von Punktestand erfasst hat
und wie viel Zeit er noch
hat, um das Spiel zu beenden. Wir wollen nicht, dass das
Spiel ewig läuft. Gehen wir dafür zum Hauptkampf, zu diesem großen Kampf, zu ihrer
Hauptspielklasse. Wir müssen
zwei neue Variablen erstellen. Der erste Wert ist die Punktzahl, die bei Null beginnt, dann spätes Dimer, dann Nt. Verbleibend. Die Zeit ist gleich 30. Das heißt, wir wollen, dass das Spiel 30 Sekunden aus ist. Jetzt verwenden wir die Steuerkomponente von Flame nur um dem Benutzer den Spielstand
und die Zeit auszugeben. Die nächste Komponente, Dime Text. Nun, im Onload, werden
wir zuerst
diesen Timer-Modus erwähnen. Lass es sich ein bisschen wiederholen. Damit,
bei jeder Wiederholung. Bei jeder Wiederholung wird es überprüft. Wenn die verbleibende Zeit gleich Null
ist. Wenn es wahr ist, dann pausiere
die angehaltene Engine, die Game-Engine,
alles wird hängen bleiben. Andernfalls werden
wir die verbleibende
Zeit, die sie am 28., 27.
abgelenkt haben, abziehen oder verringern , so wie hier. Und wenn das Spiel beginnt, starten
wir
auch diesen Timer automatisch mit
der Onload-Methode in NCL. Also beim Entladen, nachdem
alles bearbeitet wurde, diese Viruskomponente, wird
der gesamte Timer gestartet. Lassen Sie uns nun
eine Textkomponente
für die Anzeige der Punktzahl erstellen und sie oben links
positionieren. Diese Textkomponente, dieser Text wird also die
Partitur Audition sein , wobei sie an der obersten X-Achse für D und an der
Y-Achse für T fällig sind . Anchor wird ein verankerter Punkt sein. Links. Decks rendern, texten, malen. Dies sind die Eigenschaften der Textkomponente, an
die Sie sich
nur erinnern müssen oder den Auflistungsstil, den Dez-Stil. Wir werden diese Farbe ändern. Grundwahlzettel, schwarze
Punktfarbe 25. Danach fügen wir Bildschirm
die Partiturtextkomponente
hinzu. Lass uns, es ist gestartet. Und wie Sie sehen können, haben
wir die
Score-Komponente auf dem Bildschirm. Offensichtlich ist es Null und es
wird sich jetzt nicht erhöhen. Wir müssen etwas mehr
Logik in die Update-Funktionen schreiben, was wir
im nächsten Video tun werden. Danke.
16. Video 15 Score und Zeit aktualisieren: Hallo, Lass uns weitermachen und
eine weitere Textkomponente
für die verbleibende Zeit hier erstellen . Ähnlich, oder? Der Zeittext ist eine Textkomponente. X2 wird im Sterben bleiben. Zweite Läsion. Dort auch. Wir sagten nur Schreibtischtage
minus vier d. Und für DDT
ist es ganz rechts. Der Anker wird oben rechts
verankert. Und dann gibt es Text, Farbe und
dann Frisur. Stilfarbe, ähnlich
einfacher Stimmzettel. Jetzt schwarze Farbe. Die Schriftgröße wird quantifizierend lauten. danach
einfach diese Fügen Sie danach
einfach diese Komponente
zum Bildschirmnamentext hinzu. Siehst du, die Zeit ist auch da, und ich werde hier einfach ausmalen. 30 Sekunden. Wir können das Ergebnis und die
verbleibende Zeit auf dem Bildschirm sehen , aber die Werte werden nicht aktualisiert. Lass uns daran arbeiten. Im Fleet Fighter-Spiel. Erstellen Sie die Aktualisierungsfunktion. Nach dem OnLoad. Erstellen Sie die Aktualisierungsfunktion. Offensichtlich funktioniert es ähnlich wie jede
andere Komponente. Als erstes müssen wir dieses Timer-Objekt
aktualisieren. Dann aktualisieren wir die Punktzahl, diese Punktzahl x Punkt x ist gleich, wir sagen einfach Punktzahl. Und da der Punktewert hier
automatisch aktualisiert wird
, also in dieser Zeit oder nicht in dieser Zeit, wo wir das
natürlich tun werden, müssen
wir etwas in
dieser Hantelkomponente tun ,
um ihn zu aktualisieren? Decks to Time, also Zeit. Das kann. Und hier ist es
Echtzeittext, der Text. Okay? Bei der Kurzhantelkomponente
haben wir sie einfach entfernt, wenn die Hantel mit dem Spieler
kollidiert wenn die Hantel mit dem Spieler
kollidiert. Aber stellen Sie jetzt sicher
, dass wir den Punktewert erhöhen, sodass Ref-Punktwert für
dieses Spiel plus eins ergibt. Und die Punktevariable
befindet sich in der Hauptspielklasse, auf die wir mit dem Spiel
zugreifen, wie gewohnt. Jetzt starten wir neu und sehen uns
den zweiten Satz an, 26, 25. Und wenn ich mir die Zahlen ansehe, steigen
sie. Wenn du dieses Geräusch nicht
hören kannst, ist das in Ordnung, weil ich nur
eine Behinderung habe. Aber in Ihrem System bin
ich mir hundertprozentig sicher , dass Sie Ihren Ton hören können
. Das war's also für dieses Modul. Wir sehen uns im nächsten Video. Danke.
17. Video 16 Game: Hallo, willkommen zurück. In diesem Video arbeiten
wir an Overlays
und Overlays und ermöglichen es, jedes
Florida-Widget auf einer Spielinstanz anzuzeigen. Das macht es sehr einfach, Dinge wie Pausen,
Heads-up-Displays oder
einen Inventarbildschirm zu
erstellen . Diese Verwaltung erfolgt also über die Methoden Game Dot Overloads that ad und game dot overlies
dot remove. Lassen Sie uns also einen neuen Ordner, Bildschirme in lib und eine neue Datendatei
erstellen. Game Over Menüpunkt. Dieser Bildschirm fungiert als
Overlay-Bildschirm. Importieren. Mein TTL-Glass-Spiel über mein neues
Extend Stateless Widget. Wir haben eine doppelte Methode. Hier. Als erstes
erstelle ich eine ID, die const ist. String ID ist, dass sie das
Game Over Menu machen werden. Diese Overlay-ID ist eine eindeutige Kennung,
die an jedes Overlay auf diesem Bildschirm angehängt ist. Es wird verwendet, um ein bestimmtes Overlay zu identifizieren und zu
bearbeiten, z. B. um es
zum Bildschirm oder zum Spiel hinzuzufügen oder zu entfernen . Die Overlay-Idee wird
normalerweise zugewiesen, wenn die Overlays erstellt wurden und ein
Canvas-String- oder Integer-Wert angegeben wird. Dann nehmen wir das Spiel
Reference Fit Fighter Game, game href, als Parameter für
den Konstruktor. Du sagst einfach Const. Gameover-Menü. Super Dot T benötigte
diese Dartspiel-Ref. Jetzt, in meinem zweiten Drittel,
lass uns das Gerüst zurückgeben. Das sind alles Florida-Widgets. Ich hoffe, du kennst die Leiche. Wir werden einen Container haben. Dann wird die Deklaration
ein Deklarationsbild haben. Wird ein Deklarationsbild haben. Dann akzeptiert es ein Bild. Dies wird eine Schachteldekoration sein, also haben sie die Gleichung gesteckt und hier wird es ein
Deklarationsbild sein. Bild. Wir haben das Hintergrundbild,
Assets, Schrägstriche, Bilder mit Schrägstrich ,
blaue Kugeln, Globals, Hintergründe, Sprite. Und passend ist Box
Fit, Punktcover. Dies wird die Erklärung sein. Und dann wird das Kind den
Behälter in der Mitte haben. Kind. Dann Spaltenmatrix Spaltenmatrix ist Ausrichtung, die Ausrichtung der Punktmitte. Dann werde ich bei diesen Kindern als Erstes
ein Text-Widget haben. Und denken Sie daran, dass dies
keine Komponente ist, die Flutter-Widgets verdient. Gameover
Stil, Stil, Schriftgröße 50. Andere Texte sind Spielstand
, also
Spiel, Ref Dot Score. Und hier wird der Stil konstant sein, in textiler Größe. Sie sind weg. Also geben wir eine
Raumgröße an, verpackt, Höhe 200. Dann haben wir zwei
Schaltflächen, eine zum Abspielen,
eine, mit der der
Benutzer erneut spielen kann oder um zum Hauptmenü zurückzukehren. Wie gesagt, ist die Box. Wir wickeln das Feld mit der Tastengröße nur für die Breite und Höhe ein. Breite 200, Höhe 50. Kind. Erhöhter Knopf. Und drücken. Es wird vorerst nichts bewirken. Und wir gehen wieder zur
Const-Textebene. Stil, Textstil,
Schriftgröße, Vereinheitlichung. Dann nimm eine Größe, nur
um etwas Abstand zu geben, hier nochmal, Größe Boxhöhe während
D und darunter diese Größe. Wir laden Vox in dieser Größe. Lassen Sie uns ein anderes Größenfeld
für den Button haben. Höhe. 50. Hochgezogener Knopf für Kinder. In der Presse. Und wieder Child Const Text. Hauptmenü, Decks. Es gibt keine Einheitsgröße 25. Das war's also für
das Game-Over-Menü. Wir werden diese Ausgabe,
dieses Menü, später anzeigen . Im nächsten Video werden
wir auf dem
Hauptmenübildschirm arbeiten. Danke.
18. Video 17 Main: Hallo, willkommen zurück. Deshalb haben wir
das Game-Over-Menü erstellt. Lassen Sie uns nun einen weiteren
Bildschirm erstellen und ihn Hauptmenü nennen. Das Hauptmenü, Punkt, Punkt. Beginnen wir mit dem
Import von Material. Es wird staatenlos und starr sein. Nennen Sie es Hauptmenü. Und Rückkehr ist ein Gerüst. In diesem Körper. Lass uns einen Container
haben. Geben wir ihm eine Schachteldekoration. In ähnlicher Weise geben wir
ihm ein Hintergrundbild. Dieses Bilddekorationsbild. Einfach ein festgelegtes Bild. Assets haben
Schrägstriche für Bilder und globale Zahlen. Das Hintergrund-Sprite. Und B-Box mit Punktabdeckung, Mosfet-Punkt über k. Nun, das Kind des Containers, lassen Sie uns eine Mitte haben. Dann. Gib ihm das Hauptmikrofon der
Spalte. X ist die Elementmatrix
ist der Mittelpunkt des M-Punktes. Diese Kinder, die
es haben , haben einen Text , der den Namen des
Spiels und auch die Schaltfläche zum Spielen enthält. Und denken Sie daran, dass dies
kein Overlay ist, sondern direkt ein Bildschirm. Das heißt, dies
ist der erste Bildschirm, auf dem der Benutzer die App öffnet und sieht, dass sich die App ständig weiterentwickelt. Das ist nur das Styling. Du kannst machen, was du willst. Es liegt alles an dir. Kanteneinsätze, symmetrisch,
vertikal 50. Dann Kind mit dem Stil Textil. Einheitsgröße 50. Okay? Und nach diesem
Padding-Widget haben
wir ein Größenfeld. Sie geben einen gewissen Abstand. Da ich schon
weiß, dass du es bist. Deshalb
kann ich
diese Polsterung direkt schreiben und alles erhöht. Wenn Sie versuchen, etwas von Grund auf neu
zu erstellen, müssen
Sie natürlich etwas von Grund auf neu
zu erstellen, versuchen, die
Alda-UI-Widgets und alles andere zu testen. Ich mache hundert. Das wird also sein, das ist nur ein Knopf. Ich bevorzuge den
erhöhten Kinderknopf. In der Presse. Lass uns jetzt nichts tun. Und bei diesem Kind haben
wir eine Konstante. Text bis X ist einfach
play and style, decstyle auf Größe 25. Das war's auch für das
Hauptmenü. Im nächsten Video werden
wir den
Gameplay-Bildschirm erstellen und alle
Bildschirme miteinander verbinden. Danke.
19. Video 18 Spielbildschirm: Hallo, willkommen zurück. Anstatt also
das Spiel-Widget direkt
in dieser Hauptpunktdatei aufzurufen , erstellen
wir eine neue Datei in den
Bildschirmen und geben ihr einen Namen. Gameplay-Punkt, Punkt oder Material. Dann ist es weniger starr. Passform einschränken. Ihr Spiel. Jetzt werden wir
es nicht als durchfalltauglich bezeichnen. Wir nennen es einfach Game Play. Okay, wir werden es Gameplay nennen. Dann wird ein Spiel-Widget wie dieses Spiel-Widget. Und natürlich müssen wir eine Instanz eines Spiels
senden. Wir werden das
Street Fighter-Spiel hier initialisieren. Ich kämpfe nie gegen tödliches Wild. Für das Spiel wie dieses. Und wir werden es hierher schicken. Wir initialisieren das hier nicht
direkt, denn wenn
wir speichern oder etwas
passiert oder wenn diese wir speichern oder etwas Rechnungsmethode aufgerufen
wird, verlieren wir alle
Daten, weil dadurch
wieder eine neue Instanz
des Fruit Fighter-Spiels erstellt wird . Okay? Und jetzt werden wir arbeiten oder die
Eigenschaften des Spiels nutzen. Das haben wir gemacht, diese
Overlay-Gebäudekarte. Hier müssen wir nur Overlay, ID,
Screen, Bill, Contexts,
context, game, game rref
zuweisen Screen, Bill, Contexts,
context, . Und das ist das Game-Over-Menü. In unserer Anwendung ist
der einzige
Overlay-Bildschirm der Bildschirm, also weisen wir nur
die ID zu. Sie ist grün. Das müssen wir zeigen
, wenn diese
Idee genannt wird. Jetzt haben wir das gemacht. Gehen wir zur Hauptpunktdatei. Und hier in der App. Zunächst werde ich
diese
Initialisierungsmaterial-App entfernen diese
Initialisierungsmaterial-App . Sie bewegen das Banner und die Startseite ist der erste
Bildschirm, der das Hauptmenü ist. Und jetzt gehe zum Hauptmenü. Hier. Wenn der Benutzer
auf die Play-Schaltfläche klickt, sollte er zum
Gameplay-Bildschirm navigieren. Es ist ein Navigator des Kontextes. Der Push-Ersatz. Lass uns das Spiel spielen lassen. Wie du weißt, Gameplay. Mal sehen, spiel das, dieses Spiel. Das Spiel wird beginnen. Starten wir jetzt unsere App neu. Wie Sie sehen können, ist
das Grün der Intro-Bildschirm des
Spiels, das ist der Name. Dieses Logo ist schon da, schon da im Hintergrund. Und wir haben den Play-Button. Wenn wir auf Play
C klicken, können wir jetzt spielen. Okay. Ich
pausiere einfach die Game-Engine. Jetzt müssen wir das Overlay-Schema verwenden
, das heißt Game Over Screen. Wir müssen es nach
diesem Timer aufrufen oder das Spiel endet. Also geh hier zum Weight
Fighter-Spiel. Und hier. Wenn wir sind, wenn wir
die Pause-Engine unterbrechen überlagert
sie einfach mit dem Hinzufügen von Punkten. Und wir müssen dem ID Game
Over Menu eine Punkt-ID wie diese geben . Und das wird
ihm Game Over Menu zeigen. Lassen Sie uns außerdem ganz
unten
eine Funktion erstellen , um das Spiel zurückzusetzen. Das heißt, wenn der Benutzer es erneut spielen
möchte, fangen wir einfach an. Wir weisen
diese Punktzahl einfach
Null zu und die verbleibende
Zeit beträgt 30 s. Gehen Sie
abschließend zum GameOver-Menü
und erlauben Sie dem Benutzer, erneut zu spielen , und gehen Sie
zum Hauptmenübildschirm. Hier. Wenn der Benutzer erneut auf Play
klickt. Im ersten Stopp
verschieben wir das Overlay. Es ist Spiel, unser Menü, das ist. Dann rufen wir
die Reset-Funktion auf, die wir gerade
erwähnt haben. Und danach werden wir den Motor
wieder aufnehmen. Das war's. Dies sind die drei Schritte. Und was ist, wenn der Benutzer zum Hauptmenü zurückkehren möchte
? Wir werden zunächst erneut die
Overlay-GameOver-ID wie folgt
entfernen. Dann müssen wir das Set anrufen. Dann setzen wir das Spiel fort. Aber danach verwenden
wir einfach den
Pus-Push-Ersatz und senden ein Benutzer-Hauptmenü. So wie das. Ich hoffe, du kannst den Code sehen. Das ist der Code. Wenn der Benutzer zum Hauptmenü
gehen möchte. Lassen Sie uns neu starten und
alle Funktionen überprüfen. Wenn ich auf Play klicke. Und lass uns nach 30
s sehen. Also, was passiert? Dieses Finale, werde ich sagen. Siehst du, wir haben
das Game-Over-Menü. Wir können das Ergebnis sehen. Und wenn wir einfach erneut auf Play
klicken, ist die Punktzahl Null. Und wir haben diesen Dimer. Das fängt wieder von Tatu an. Und jetzt nochmal, was passiert,
wenn Sie auf Hauptmenü klicken, dann werden wir zurück
zum Hauptmenübildschirm geschickt. Das war's. Das war's für das Spiel. Überlagerungen. Wir sehen uns im nächsten Video.
20. Video 19 Player Sprite bedingt ändern: Bis jetzt erhöhen
wir diese Punktzahl, wenn der
Spieler es sich schnappt . Aber warum nicht interessant machen? Lassen Sie uns auch das
Sprite-Bild ändern. Je mehr er punktet, desto muskulöser wird er. Da kennt jeder
Gewichtheben Gürtel, Muskeln. Versuchen wir also, das umzusetzen. Gehe zur Player-Komponentendatei. Lassen Sie uns zwei neue
Zustandsvariablen für andere Sprites erstellen. Von Schicht. Gewicht. Late Sprite, Blair, Muscular, K. Laden
wir das
Sprite-Bild in diese Variablen. Den Onload gibt es hier. Einfach zweimal kopieren und einfügen. Gewicht wird Player fit
hell und klar sein, muskulöser Live Player muskulöser Sprite k. Jetzt, anstatt Sprites
hier direkt zu nennen , das hier. Und auch in der Freeze-Funktion. Hier ändern wir
das Sprite-Image. Lassen Sie uns die Funktion erstellen , die Sprite bedingt
gerendert hat. Was ich meine ist bei k, lasst uns hier
Wide Player Sprite erstellen. Wir werden zuerst prüfen, ob
ein Virus befallen ist. Dann wird Sprite Spielerfieber
sein. Dann werden wir überprüfen, ob die
Punktpunktzahl des Spiels größer als fünf und
weniger als zehn ist, es 5-10 ist. Der Tanz wurde dafür zum Spieler. Okay? Ähnlich verhält es sich mit Jack, falls Schiedsrichter im
Spiel
mehr als zehn Punkte erzielt, dann ändere den Sprite
in den muskulösen Spieler. Oder signieren Sie endlich
das Start-Sprite, das Display-Skinning
macht Sprite. Nachdem wir
diese Funktion erwähnt haben, rufen
wir diese Funktion auf um die
Sprites überall zu rendern. Gehen Sie zunächst zur Onload-Methode. Hier. Anstatt
Sprayed so aufzurufen, rufen Sie
einfach die Funktion auf. Dann gehe zum Update. Wir stellen nur sicher, dass wir die Funktion hier
aufrufen. Das heißt, wenn es nicht von einem Virus
angegriffen
wird, überprüft es diese Punktzahl und diese Funktion wird immer wieder aufgerufen. Dann geh hier auftauen. Nennen wir diese Funktion. Nachdem der
Virusangriff also
erneut falsch ist , ändert sich das Sprite. Gehen Sie in ähnlicher Weise zum Einfrieren. Hier. Wir werden das
Sprite-Bild so ändern. Und warum nicht
diese Punktzahl verringern, wenn er von dem Virus
angegriffen wird,
was bedeutet, dass er
seine Muskeln verliert , wenn er sich durch das Virus einen
Biber oder eine Erkältung zugezogen hat. Da der Punktestand sinkt, wird auch der Sprite zu dünn. Am Ende. Wen wir werden einfach überprüfen,
ob das Spiel einen Punktestand hat. Wenn es größer als Null ist, wird es nur dekrementiert,
es wird negativ. So wie das. So einfach ist das. Okay, lass uns auffrischen. Oder Sie können einen Start festlegen. Und lassen Sie uns überprüfen, was passiert. Okay, sieh mal, die Punktzahl ist gesunken. Aber jetzt bin ich sechs und mein
Sprite-Image passt sich an. Und offensichtlich verstehe ich, wie Sie sehen können, wurde
das Sprite-Image geändert und es wurde auch
wieder geändert. Und schließlich ist das Spiel vorbei. Aber jetzt wirst du sehen, was
passiert, wenn ich wieder spiele. Die meiste Zeit. Ich werde dir zeigen, was ich meine. Gewicht. Geh zu FIT und
kämpfe noch einmal dagegen an. Ich werde den
oder die Viren entfernen . Lass uns sehen. Ich werde dir zeigen , dass
sie gerade diesen muskulösen
Sprite haben. Wow, wenn es keine Adresse gibt, dann können wir so viel punkten. Aber was passiert nun, wenn
ich erneut auf Löschen klicke,
sehe, ob wir das Spiel wiederholen oder
zum Hauptmenü gehe, dann wird das Sprite-Bild
nicht auf die Standardeinstellung geändert. Es ist der Skinny. Ganz am Anfang. Wie beim Spielen funktionierte die
letzte Update-Funktion von Genie nicht mehr für
alle Komponenten. Um dieses Problem zu beheben, erstellen
wir eine Zustandsvariable
für die Player-Komponente. Noten. Gehe zu unserem Code. Geh zu Fit by Delta. Hier. Lass uns Grid-Layer-Komponente,
Player-Komponente, okay? Dann aufladen. Wir
initialisieren zunächst die Player-Komponente
wie folgt und fügen
sie dann hinzu, sodass wir diese Layer-Komponente direkt
ändern können , da es sich um eine Zustandsvariable handelt, die
nicht in der Funktion enthalten ist. Okay. Lassen Sie uns
das Sprite-Bild in der
Reset-Funktion
auf die Standardeinstellung ändern. Hier. Lassen Sie uns die
Spielerkomponente zurücksetzen. Punkte Sprite entspricht
Await Loads Bright. Machen wir ein Waschbecken daraus. Globale. Mageres Sprite. Die Hauptserie wurde gestartet. Und schauen wir uns das Spiel noch einmal an. Sagen wir 4/32. Hab einfach Geduld mit mir. Ich werde so einen
Highscore erzielen. Okay,
warten wir jetzt, bis der Timer abgelaufen ist. Wenn ich dieses Mal erneut auf Play
klicke,
sehe ich, dass das Bild wieder auf Skinning
zurückgesetzt wird. Ich hoffe, Sie haben die Konzepte
verstanden, warum ich das mache,
warum ich das mache. Und wieder werde ich die Viruskomponente
auskommentieren. Das war's also für dieses Video. Wir sehen uns in der nächsten Sitzung.
21. Video 20 Erstellen einer Impfstoffkomponente: Hallo, lasst uns das
Spiel interessanter machen. Wir werden in
zufälligen Abständen eine
Impfstoffkomponente hinzufügen und der Benutzer
des Anbieters schnappt sie sich. Er wird für ein paar Sekunden gegen
Viren immun sein. Das klingt so
interessant, oder? Lassen Sie es uns implementieren.
Innere Komponenten. Erstellen Sie eine neue Datei. Impfstoffkomponente, Punkt, Punkt, kopieren Sie den vollständigen Code
aus der Viruskomponente und fügen Sie ihn ein. Also lass uns alles kopieren. Füge es hier ein. Lass uns sehen. Ändern wir es zur
Impfstoffkomponente. Sin-Komponente. Wir haben die Vektorgeschwindigkeit
bei der OnLoad-Änderung, also ein gutes Beispiel für Impfstoff-Sprite. Position, Startposition. Gewicht entspricht Größe, okay? Und das ist alles, um das Zentrum zu
verankern. Okay? Alles ist gut. Dieser Code ist der grundlegenden
Aufteilung dieser Komponente sehr ähnlich Wir werden nur
das Sprite-Bild ändern und
die Bewertung der
Teile zur Kollisionserkennung ist dieselbe. Okay, wir haben das Move-Spray, das ist auch dasselbe. Gehen wir zur Kollision. Hier. Unter dem grünen Hut
wird einfach geprüft ob eine Ebenenkomponente vorhanden ist. Dann entferne das
vom Elternteil, es wird einfach diese
Impfstoffkomponente entfernt. Okay, speichern Sie es. Lassen Sie uns nun an
der Kollision zwischen dem
Spieler und einem Impfstoff arbeiten . Go-to-Player-Komponente. Wir müssen
auch hier Änderungen vornehmen , damit der Impfstoff wirkt. Lassen Sie uns zunächst eine Zustandsvariable
erstellen. Dieser boolesche Wert ist geimpft entspricht falsch. Also hier werden wir einfach überprüfen,
ob der Spieler geimpft ist,
was bedeutet, dass er immun ist, warum das so ist. Wir haben keine, wir haben keine über Kollision und das Ja. Wenn es ein Virus gibt, sagen
wir einfach, ob
er nicht geimpft ist, dann wird er nur freigelassen. Erwachsene frieren den
Spieler nicht ein, weil er es ist, er hat sich den Impfstoff bereits geholt. Und wir werden auch schreiben, wenn es eine Impfstoffkomponente gibt, dann werden wir eine
Funktion erstellen, Wachs injizieren. Lassen Sie uns Funktionen
für Impfstoffe erstellen. Ganz unten
werde ich breit schreiben und
diesen Injektionsimpfstoff herstellen. Plus die vier Stufen. Prüfen. Das heißt,
schreiben Sie einfach zuerst den Kommentar. Nicht ausführen, wenn y, dies ist, wenn das Blade vom Virus ausgelöst wird, wenn
es nicht angegriffen wird. Nicht warum dieser Angriff, dann ist James geimpft, Drew
gleichkommt. Und spiele das Audio ab. Globales Impfstoffgeräusch 0, K. Und eine weitere
Funktion entfernt x in. Wir ändern uns einfach,
ist geimpft hier gleich falsch. Nicht viel. Also, ja, wir haben
viele Änderungen vorgenommen. Das war's also für dieses Video. Lassen Sie uns
im nächsten Video
weitere notwendige Änderungen vornehmen . Danke.
22. Video 21 Impfstoff in zufälligen Abständen hinzufügen: Lassen Sie uns weitermachen und die notwendigen Änderungen in der Spielklasse vornehmen, damit die
Impfstoffkomponente funktioniert. Lass uns zum Fit Fighter-Spiel gehen. Wir müssen
neue Zustandsvariablen erstellen. Zunächst werde ich
die Impfstoffkomponente initialisieren. Es ist in Ordnung. Impfstoffkomponente, Z-Komponente. Wir haben gerade
die Startposition erwähnt. Ich werde einfach den zweiten Vektor, die
X-Achse, schreiben , um die Y-Achse 200 anzureichern. Dann schreibe ich in Impfimmunität, dy ist gleich vier. Das bedeutet, dass der Impfstoff Immunität
verleiht, oder Sie können sagen,
dass wir an dem Spieler, der Urlaub hat, für 4 s arbeiten . Danach wird
er vom Virus befallen bis er spät geimpft ist. Das ist also das
Timer-Objekt für den Impfstoff. Wir werden überprüfen, ob die
Sekunde vorbei ist oder nicht. Und dann
haben wir Impfzeit. Die Eltern werden es
interessanter machen ,
weil wir FPS nach dem
Zufallsprinzip Zeit für den
Impfstoff geben werden . Selbst wir wissen also nicht, wann der Impfstoff im Spiel
erscheinen wird. Und jedes Mal wird es zu einer anderen,
anderen Zeit
erscheinen , kann man sagen, weil der Spieler Sekunden außerhalb der Party
ist. Jetzt. Lass uns zum Onload gehen. Hier. Im Onload werden wir
einfach Impfstoff schreiben. Die Zeitdarstellung entspricht
einem zufälligen Punkt neben dem Ganzzahlwert. Und wir schreiben die verbleibende
Zeit -20 plus 20. Auf diese Weise erscheint die Zeit für den
ersten Impfstoff. Sehen Sie hier, wie Sie sehen können, gibt
random next
eine zufällige Ganzzahl. Wenn wir hier direkt den
Wert zehn schreiben, dann ergibt das einen Wert
, der größer,
gleich Null und kleiner als zehn ist . Aber da das Spiel 30 Sekunden dauert, möchte
ich, dass das erste Spiel irgendwann zwischen
20/32
erscheint , damit wir
noch Zeit haben , bis
ein weiterer Impfstoff erscheint. Nehmen wir an,
der Impfstoff wurde zufällig für 5 Sekunden ausgewählt, dann erscheint im gesamten Spiel nur ein Impfstoff. Das ist meine eigene Entscheidung.
Es liegt an dir. Und hier sehen Sie, was passiert. Wenn ich etwas wie „Nächstes“
in Hundert plus 50 mache, ist der Wert größer als 50, da ich auch 20 hinzugefügt habe. Der Wert wird also
größer als 20 sein, und hier wird er kleiner als 150
sein, wobei beide addiert werden. Nehmen wir also an, hier ist die
verbleibende Zeit mit minus 2010 plus 2030 gekennzeichnet . Also ich einfach, diese Berechnung bedeutet, dass es größer als 20
und weniger als 30
sein sollte . Danach müssen wir Änderungen an dem
vorherigen Timer-Objekt
vornehmen. Hier, dieses Timer-Objekt. Und überprüfe, ob die
verbleibende Spielzeit dem zufälligen Erscheinungsbild des
Impfstoffs
entspricht. Wenn ja, fügen Sie die
Impfstoffkomponente hinzu. Also werde ich zuerst überprüfen, ob die verbleibende
Zeit gleich Null ist. Mach eine Pause in Qian, okay? Nun, ich werde es einfach löschen. Hier werde ich sonst überprüfen, ob die verbleibende Zeit
den Impfstoffdimer-Eltern entspricht. Dann fügen Sie die Impfstoffkomponente hinzu. Und wir haben die
Impfstoffkomponente und das Oberteil so. Okay? Nehmen wir an, die Manie
, diese Zeit gegen den Virus-Impfstoff, das ist diese,
die Indy Five annehmen sollte. Wenn der Timer also
302-920-8206 ankreuzt,
dann, wenn er auf 25 geht, fügen
wir dem Spiel die
Impfstoffkomponente hinzu. Lassen Sie uns außerdem ein neues
Timer-Objekt für den Impfstoff erstellen. Hier. Unter diesem Timer. Schreiben wir, dass der
Impfstoff-Timer gleich eins ist. Wiederholen Sie den Vorgang am ****. Sollte wahr sein. Bei jeder Zecke wird überprüft ob die
Impfimmunzeit gleich Null ist. Das heißt, der Impfstoff ist vorbei. Wenn nicht, dann verringere die
Impfzeit um eins, den Geschmack für die zweite um
drei, die zweite um zwei, zweite um 1 s. Und wenn sie vorbei
ist, schreibe
ich zuerst die Spielerkomponente, schreibe
ich zuerst die Spielerkomponente die die Impffunktion aufhebt. Das heißt, ich hoffe, du erinnerst dich daran. C, Wir werden jeden Impfstoff ändern
, der gleich falsch ist. Okay? Danach werde ich wieder schreiben, dass die
Impfimmunität wieder vier
beträgt. Dann füge ich den Impfstoff hinzu. Aussehen, Bindung des
Tests, Impfzeit und Eltern sind gleich Null. Dies erfolgt für die
bedingte Prüfung. Wir werden es später noch
einmal tun, um den Impfstoff zu zeigen. Hier. Erneut Immunität gesagt, Zeit für die Entfernung. Impfstofffunktion in
der Spielerklasse. Okay. Dann will ich nur, dass dieser Timer, Impftimer, aufhört. Das heißt, ich möchte nicht, dass es immer
wieder für immer so weitergeht. Okay. nun endlich in
der Update-Methode, Überprüfen Sie nun endlich in
der Update-Methode, ob der Spieler geimpft
ist und ob VS ist, und lassen Sie dann
das Timer-Objekt weiter laufen. Und wenn der Wert
eines Elternteils gleich Null ist, bedeutet
das, dass die
Immunitätswirkung vorbei ist. Das wiederum führt zu
einer zufälligen Zeit für den Impfstoff für ein
Paar in diesem Spiel. Du wirst verstehen, warte, lass uns zur Update-Funktion gehen. Wird prüfen, ob Komponente geimpft ist. Dann aktualisieren wir einfach
den Impftimer. Diese Woche. Wir gehen davon aus, dass es Enda-Funktionen
haben wird. Und andernfalls, wenn die
Impfstoffzahl gleich Null ist. Dann
überprüfen wir einfach , ob
die verbleibende Spielzeit mindestens 3 s beträgt. Dann wieder ADA. Dann
füge den Impfstoff dem zufälligen
Spiel hinzu. Punkt neben Int. Verbleibende Zeit -3 s plus drei. Dieser neue Impfstoff. Eltern. Miete Zeit. Okay? Also hier
lesen wir einfach, wie
lange das Spiel
mindestens 3 s lang
sein sollte . Hier hoffe ich, dass
du das nochmal verstehst. Also länger als 3 s und was auch immer die verbleibende Zeit
in dieser Sekunde sein
soll oder was auch immer. Es wird wieder
eine Zufallszahl erhalten. Und aus diesem Grund haben
wir immer noch diesen Timer
, der überprüft, ob verbleibende Zeit der Impfzeit
entspricht, und wird erneut an der
Impfstoffkomponente arbeiten. Die Schleife wird also immer weiter gehen, bis das Spiel vorbei ist. Und bei dieser Reset-Methode geben
wir die Score-Ebene. Wir haben die restliche Zeit. Schreiben wir Req Seen. Die Immunitätszeit beträgt vier. Und wir werden die
Impfstoffkomponente von hier entfernen. Ich kenne viel Code, aber du musst das Konzept
verstehen. Endlich ein wichtiger Bestandteil des
Injektionsimpfstoffs. Werde nachschauen, ob
es nicht so okay ist. Nach dem Spielen schreibe ich
einfach die Spielnummer, den
Punkt, den Impftimer und den Punkt Start. Ich hoffe, du hast das gesehen. Hier. Wir schreiben den Impftimer, aber wir nennen ihn hier nicht. Das heißt, wir
starten den Impfstofftimer nicht. Wir werden nur beginnen, wenn Komponente der
obersten Schicht mit der
Impfstoffkomponente
kollidiert. Sagen wir, nun, okay, lassen Sie uns das noch einmal ausführen. Mal sehen, wir bekommen irgendeinen Editor oder das
Spiel funktioniert. Drücken wir die Daumen. Lass uns spielen. Siehst du, wir haben diese
Impfstoffkomponente, aber seit ich von
dem Virus angegriffen wurde, hat es nicht funktioniert. Aber lass uns warten. Ich denke, es wird ein anderes Mal die Impfstoffkomponente
erscheint. Damit sind sie wieder gepaart. Lass uns nochmal spielen. Siehst du. Jetzt habe ich die
Impfstoffkomponente und mir passiert
nichts. Aber nach 4 s werde
ich wieder angegriffen. Das bedeutet also, dass wir
zumindest die Impfstoffkomponente sind. Es funktioniert perfekt. Lass uns sehen. Ist der Impfstoff wieder
erschienen oder nicht? Es ist nicht unbedingt
okay, so schien es. Sehen Sie endlich,
diese Funktionalität funktioniert einwandfrei. Ich hoffe, Ihnen hat dieses Konzept
gefallen und es auch
verstanden. Wenn nicht, versuchen Sie bitte diese Codes
zu überprüfen, erneut, diese Codes
zu überprüfen, bevor Sie
zu einem anderen Abschnitt wechseln. Ich danke dir.
23. Video 22 Arbeit an der Proteinkomponente: Hallo, willkommen zurück. Die letzte Wendung, die wir dem Spiel
hinzufügen werden, ist also eine
Proteinkomponente. Denn Muskelaufbau und
Proteinaufnahme gehen Hand in Hand. Grundsätzlich wird hier ein
Proteinpräparat zu zufälliger Zeit
nur einmal pro Spiel
erscheinen. Und wenn der Spieler
es grafisch darstellt, bevor es
verschwindet, erhält er eine zufällige
Bonuscode-Inkrementierung , die einen beliebigen Wert von 0 bis 8 haben kann. Das wird Neugier wecken. Also lass es uns machen. Lassen Sie uns eine neue Datei
innerhalb der Komponenten erstellen, nämlich der Proteinkomponente dot care. Kopieren Sie den vollständigen
Code aus dem Impfstoff und fügen Sie ihn ein. Hier. Kopiere einfach alles
und füge es ein. Lassen Sie uns es natürlich auf Protein
ändern. Komm für ein n, k. Und im OnLoad werden
wir
hier dub-Proteine hell haben und am Ende bei Kollision enden. Wir werden einfach schreiben ob das andere eine
Player-Komponente ist, nehmen wir an. Dann werden wir natürlich
diese Komponente oder dieses
Objekt vom Bildschirm entfernen , aber wir werden auch
die Punktzahl erhöhen. Um die zufällige Punktzahl zu erhalten, haben
wir
dies bereits so oft implementiert. Und mein Bonuspunkt
ist, dass wir einen zufälligen
Klassenpunkt als nächsten Punkt neun machen. Also hier, 0-8. Da Neun ausgeschlossen ist, 0-8, kann ein
beliebiger Bonus generiert werden. Und wir erhöhen
einfach die Werte Game Ref,
Dot Score, Plastic
Coil, Random Bonus. Stellen Sie sich also vor, der
Benutzer
wüsste nicht , dass er möglicherweise
unglückliche Nullkerne bekommen könnte, abhängig von seinem Glück. Jetzt müssen wir wieder
notwendige Änderungen in
der Spielklasse vornehmen. Gehen wir also zum Fit Fighter-Spiel. Hier. Lassen Sie uns neue
Zustandsvariablen für Proteine erstellen. Also hier einfach was
die Proteinkomponente ist. Lassen Sie uns es
zunächst initialisieren. Proteinkomponente ist
gleich und geben wir
die Startposition an. Ähnlich wie 200.400 K. Und wenn Sie möchten, können
Sie auch
zufällige Startpositionen generieren, aber Sie wissen, wie Sie das umsetzen,
es liegt an Ihnen. Schreiben wir Protein. Eiweiss. Zeit. Links ist gleich vier, was bedeutet, dass Protein nach 4 s
automatisch automatisch verschwindet. Hier
muss der Benutzer es
also innerhalb von 4 s
aufnehmen. Wir haben auch ein Proteindimer
. Heute. Dekan. Dimer. Dann lass uns einen Tag verbringen. Meine Eltern, das wird eine zufällige Zeit für
das Protein sein. Okay. Und zum Schluss sagen wir einfach
Proteinbonus. Lass uns sehen. Was ist der Proteinbonus
, damit wir diesen Überblick
behalten können, jeden Bonus verfolgen können,
damit wir
ihn dem Benutzer später anzeigen können. Also, wie hoch ist der
genaue Bonusbetrag, den er bekommen hat? Also hier unter der
Impfzeit, meine Eltern, schreiben
wir, Proteindimer-Eltern entspricht zufälligen Punkt neben dem Komma, verbleibende Zeit minus
fünf plus fünf. Was einfach bedeutet, dass die Zeit länger als 5
s und
weniger als 30 s sein
sollte s und . Okay? In ähnlicher Weise passiert das. Lass es uns gut machen. Routinezeit meiner Eltern hier. Ähnlich wie zuvor werden
wir Änderungen an
diesem Game-Timer vornehmen. Zu prüfendes Objekt. Wenn die verbleibende Zeit
des Spiels der zufälligen Auftrittszeit des
Proteins entspricht. Wenn VS, dann füge die
Proteinkomponente auf dem Bildschirm hinzu. Also lass uns hierher gehen. Zuerst. Wir prüfen, ob die verbleibende
Zeit der Impfung entspricht. Und auch hier überprüfen
wir, ob verbleibende Zeit dem
routinemäßigen Zeitaufwand entspricht. Dann füge die Proteinkomponente hinzu
und wir werden auch
das Proteindimer starten . Okay? Lassen Sie uns nun
den Protein-Timer erstellen. All dies funktioniert genauso, wie wir
das Impfstoffdimer zuvor entwickelt haben. Eine Wiederholung
entspricht wahr. Ein Häkchen. Wir überprüfen, ob der
verbleibende Proteinbetrag gleich Null ist, diese Zeit vorbei ist, entfernen
dann einfach die
Proteinkomponente. Aber
im nächsten Spiel heißt es gerade , dass die verbleibende Zeit gleich falsch ist, r gleich vier ist. Wir sollten es nicht endgültig machen. Und wir werden
den Protein-Timer stoppen. Wenn es Null ist. Ansonsten, wenn ich das einfach
dekrementiere, habe ich mir vorgestellt, dass diese 4321, wie dies**** links
minus gleich 10 k sind. Also haben wir implementiert, um diese Proteinkomponente
hinzuzufügen. Starten Sie den Timer,
wenn der Dimer beginnt. Lassen Sie uns diesen Dimer aktualisieren, wenn dem Spiel eine
Proteinkomponente
hinzugefügt wird. Hier. Wir schreiben einfach, ob die
Proteinkomponente geladen ist, das heißt, sie ist im Spiel. Dann Protein Timer
Dot Update DT. Okay, und dann
müssen wir einige Änderungen vornehmen. Jetzt ist es fertig. Weil wir wirklich gesagt haben, dass noch
Proteinzeit übrig ist, entferne die Komponente
und weise auch eine zufällige Zeit für
das nächste Spiel zu. Wenn der Spieler gespielt hat, nochmal. VS-Code entspricht einfach dieser offenen Komponente, der
Impfstoffkomponente. Das ist hier wie bei Dean, noch
Zeit für die Proteinkomponente vom Elternteil. Routine. Diamond Princess
ist unglaublich ähnlich zu random. Als Nächstes, verbleibende Zeit
minus fünf plus fünf. Ich hoffe, Sie haben Verständnis dafür, dass
wir
die Zeit erneut zurücksetzen , denn wenn der
Benutzer sie erneut spielt, wird die Onload-Methode nicht aufgerufen. Das ist der Grund. Nun, danach, sagen wir,
wenn wir zur Proteinkomponente gehen, müssen
wir den Namen
Protein-Timer nennen. Wenn Protein mit
der Spielerkomponente kollidiert, spielen Sie den Sound ab und aktualisieren Sie
auch Bonuswert in dieser
Protein-Bonusvariablen. Hier. Wenn ja, dann spielen wir Audio ab, spielen globale Zahlen ab, die
Proteine klingen. Dann werden wir einfach
den Protein-Timer herunterfahren. Und da wir das sind, da das
Protein nur einmal vorkommt
, gibt es kein Problem Stopp- und Starttimer
immer wieder. Und wir werden einfach sagen
, dass das Spiel MIT
diesem Proteinbonus einen zufälligen Bonus-Score erzielt. Und wir werden
diesen Bonuswert in
diesem Game-Over-Menü anzeigen . Gehen wir also zum
Spiel über meinen neuen unter dieser Punktzahl. Unter dieser Punktzahl. Sagen wir Text. In den Decks. Bei der Biosynthese
emulieren Sie den Proteinbonus. Dann das Spiel OF Protein Bonus. Gib eine Form, sagt const. Textil in Größe 20. Mach es klein. Lass uns alles speichern und sehen, ob das Protein da
ist oder nicht. Und der Einfachheit halber werde
ich die Virusimpfstoffe
oder ein Virus entfernen , damit es
einfacher zu testen ist. Das Spiel. Wir haben hier ist hier. Es ist ausgecheckt. Ich werde spielen, sagen
wir, natürlich King. Aber ich habe Delta x in C
genommen. Die Proteinkomponente ist da. Und wenn ich es nehme, habe ich wohl ein sehr gutes
Ergebnis erzielt. Und das können wir überprüfen. Im Spiel über C erhalte ich
die Proteinboni acht. Wenn ich wieder spiele. Lass uns das sehen. Offensichtlich sehen wir auch nichts, wenn ich den
Impfstoff nehme. Ich schätze, der Proteinbonus
war gleich Null, glaube ich. Also ich muss sagen, es macht sehr viel Spaß. Siehst du, der Proteinbonus
war diesmal Null. Es hängt also alles von seinem Glück ab. Ich werde wieder spielen. Und dieses Mal, wenn ich den Impfstoff
nicht nehme,
schauen wir mal, was passiert. Wir warten einfach, bis
der Impfstoff erscheint. Okay, aus Versehen habe ich den Impfstoff
genommen. Impfstoff, tut mir leid, Protein. Also Protein war für ich
glaube das ist genug. Alles
funktioniert sehr gut. Ich bin mit dem Spiel zufrieden. Das ist also alles über dieses Spiel. Im nächsten Video werden
wir einfach
am Splashscreen arbeiten ,
damit er schön aussieht. Danke.
24. Video 23 Einen Splash hinzufügen: Hallo, willkommen zurück. Unser Spiel ist abgeschlossen. Lassen Sie uns ein paar zusätzliche Dinge hinzufügen, wie einen Splashscreen. Das Spiel wird mit
diesen kleinen Add-Ons wunderschön und
professionell
aussehen . Gehe zu Bob Dot Dev und
gib den animierten Splashscreen ein. Hier haben wir diesen. Ja. Kopieren Sie die Abhängigkeit und fügen Sie sie der
Pub-Spezifikationspunkt-YAML-Datei hinzu. Und wie dem auch sei, dieser
Splashscreen-Paket-Inverter ist eine vorgefertigte Lösung
, die
einen anpassbaren animierten
Splashscreen für unseren Bildschirm bietet . Soweit also die
Grünen einfach
eine neue Datei erstellen und
sie Spiel nennen. Glas. grünem
Punkt Importmaterial mit grünem
Punkt. Erstellen Sie dann ein staatenloses,
starres Benennungsspiel. Splashscreen. Hier geben wir den
animierten Splashscreen zurück. Also einige der häufigsten
Eigenschaften und Argumente, auf die wir
bei der Arbeit mit
animierten Startbildschirmen stoßen könnten , unsere Dauer, ein Wert für die Dauer. Iterationswert gibt an, wie lange der
Splashscreen angezeigt wird. Schreiben wir also die
Dauer auf 2 s.
Dann. Das nächste ist ein Schrägstrich, beliebiges Widget,
das das Bild, Logo oder den Text angibt, der
auf dem Startbildschirm angezeigt werden soll. Also platsch, wir
schreiben einfach Bild, Punktsatz, dann Assets, Bilder,
Spiel, Logo, Punkt-PNG. Dann haben wir den nächsten Bildschirm. Das bedeutet, wo man navigieren muss. Danach ist die Dauer
der Splashs nach 2
s vorbei . Bei manchen geht man ins
Const-Hauptmenü. Dadurch wird
die Symbolgröße 25250) geändert und
die Hintergrundfarbe in dunkelschwarze Farben geändert. Und lasst uns auch
Splash Transition schreiben. Das ist der Effekt oder der
weniger angenehme Übergang. Beginnen wir mit dem
Skalenübergang. Okay? Lassen Sie uns dieses
Menü der Startseite zuweisen. Einfach Spiel schreiben,
Splashscreen. Lass uns alles speichern und überprüfen. Siehst du,
gibt es dort Splashscreens und nach 2 s ist
unser Gameplay-Menü da. Also werde ich nochmal neu starten und sehen, dass das die Effektrituale waren und es sehr gut aussieht. Ich sage, wenn du willst, kannst
du verschiedene
Übergänge ausprobieren. Es liegt an dir. Und Sie können auch
das App-Logo oder einen beliebigen
Hintergrund oder diese Farbe ändern . Offensichtlich ist es deine
eigene Kreativität. Das war's für dieses Video. Im nächsten Video werden
wir das
Launcher-Symbol, die Enqueue, ändern.
25. Video 24 Ändern des launcher: Hallo, willkommen zum letzten
Video dieses Kurses. Wir werden daran arbeiten,
den App-Namen
sowie das Launcher-Symbol zu ändern . Wenn du also zur
App gehst und rausgehst, dann kannst du hier sehen das der App-Name und das
ist das Launcher-Symbol. Um den Namen
unserer App in Android zu ändern. Gehe zum Verzeichnis Android-App,
dann Quelle, dann Mittelwert. Dann Android-Manifestdatei. Und hier finden Sie dieses
Anwendungslabel hier. Ändere es einfach in
Weight Fighter. Das heißt, es hat sowohl Leerzeichen
als auch Hauptstädte. Das war also für den Namen der App. Um nun das
Standard-Platter-App-Symbol zu ändern, verwenden
wir den Paketnamen
Plotter Launcher Icons. Also lass uns hierher gehen. Stimmt es? Trägerrakete. Jetzt bin ich mir sicher, dass ich es kann. Es ist ein empfohlener
Ansatz, der die
gesamte
Arbeit für
die Aktualisierung der App Launcher-Symbole
für verschiedene Plattformen erledigt. Also lass uns einfach die Abhängigkeit in deinen
Puffs zurück in die YAML-Datei
kopieren. Einfach, fügen Sie es einfach ein. Aber denken Sie daran, wir müssen
dies in die Dev-Abhängigkeiten einfügen dies in die Dev-Abhängigkeiten und nicht unter Abhängigkeiten. Also hier unter dem
Lotterielinsen, einfach einfügen und speichern. Jetzt. Okay, warte, es wird
immer noch okay, sofort. Damit es funktioniert, müssen
wir nun einige
Florida-Konfigurationen in
dieser Pub-Spezifikations-Punkt-YAML-Datei hinzufügen einige
Florida-Konfigurationen in . Also unten, hier, müssen wir genau
unter diese Dev-Abhängigkeiten gehen. Denken Sie daran und schreiben Sie
Buchstabensymbole. Und ich sage Ihnen
immer wieder,
diese Pub-Spezifikation, dass die
YAML-Datei sehr sensibel ist. Wenn du etwas mehr
Platz und so hinzufügst, kriegst du uns vielleicht. Klicken Sie jetzt auf ein Leerzeichen. Unsere Rechnung würden wir geben,
okay. Geben Sie Tabulator ein. Und schreibe Android
für iOS. Durch das Bild. Teil dieses Teils des Symbols. Ich entscheide mich für Assets, Bilder, das Spielelogo ,
Punkt-PNG und dann mindestens K and Ride. Und wir werden 21 verwenden. Und ich erhalte diese Codes
im Bereich Read Me. C. Du kannst verstehen,
wie es gemacht wird, wie es in den
Dev-Abhängigkeiten, dieser Flut, Florida-Symbolen und allen 0, k steht. Wir haben alles gespeichert. Nach dem Einrichten
der Konfiguration bleibt
nur noch, das Paket mit Hilfe
eines an den Befehl angehängten
Terminals auszuführen und einfach zu schreiben, offensichtlich haben wir diese
Platte immer wieder bekommen. Und danach
einfach einen Brief schreiben. Bob. Run, Flutter, Launcher, Icons und Presenter. Oh, hey, lass uns sehen. Ich glaube, es ist erledigt. Ich bin mir nicht sicher, ob Wesley erfolgreich
Launcher-Symbole generiert hat. Wir müssen diesen
Debug-Modus beenden und dann erneut ausführen. Lass uns sehen. Daikon
ist aktualisiert oder nicht. Wenn ich nachsehe, haben wir
den Fruit Bite, ihren App-Namen und das Symbol tack und es
sieht wirklich wunderschön aus. Ich sage, wenn ich gehe, können wir das Spiel
natürlich spielen. Offensichtlich habe ich einen Schritt vor
, das werde ich noch einmal sagen. Die Viruskomponenten, das ist das Spiel, das wir spielen können. Wir haben eine Lesung. Das ist es also. Für diesen Kurs. Ich hoffe, Sie haben viel Spaß gehabt
und viel gelernt. Übe weiter. Und ich werde dafür sorgen, dass mehr Kurse
zur lahmen Game-Engine programmiert und wunderschöne
Spiele entwickelt werden. Oder Sie können sagen, dass in Zukunft mehr interaktive
Spiele stattfinden werden. In der Zwischenzeit. Sie können
sich auch meine anderen Kurse
ansehen . Ich danke dir. Hab einen schönen Tag.
26. Teste das komplette Spiel: Beeindruckend.