Transkripte
1. Spieleentwicklung von Unity: Kurs für Anfänger bis Profi: Meine Freunde, mein Name
ist Roan Masud. Willkommen zur Tutorialserie Gaming
with Unity. Lassen Sie mich Ihnen erklären, welche
Themen wir in dieser speziellen
Tutorialserie behandeln werden. Wir beginnen also mit Installation
und Einrichtung von
Unity hier. Darüber hinaus werden wir
mit der Erstellung des
ersten Projekts und der Konfiguration von
Visual Studio mit Unity fortfahren . Dies behandelt das Erstellen eines
C-Sharp-Skripts in Unity, das
Verstehen
der Struktur eines C-Skripts und schließlich das Drucken von Hello
World in der Unity-Konsole. Darüber hinaus werden wir
mit Datentypen,
Variablen und
Operatoren in C Sharp fortfahren ,
wobei wir einen Operator, einen
relationalen Operator, einen
logischen Operator
und einen bedingten Operator behandeln werden relationalen Operator, einen
logischen Operator
und einen bedingten Operator und einen bedingten Operator Wir werden uns auch mit
Kontrollflussanweisungen in CR befassen, die sich mit Anweisungen
zur Entscheidungsfindung,
Switch-Anweisungen und
Loop-Anweisungen befassen werden. Wir werden uns auch mit einem
sehr wichtigen Thema in R befassen, nämlich mit Sammlungen in CR, die eine Liste, sortierte
Liste
, ein
Wörterbuch-Array, eine Liste mit einer Tabelle und
einen Stapel beinhalten werden Wörterbuch-Array, eine Liste mit einer Tabelle und
einen Stapel Später werden wir uns mit der
Benutzeroberfläche in Unity befassen Dazu gehören Canvas, Text,
Bildschaltflächen, Scroll-Ansicht, Eingabefeld, Slider
und Anchor in Unity Im weiteren Verlauf werden wir uns auch mit Unity-Events
befassen, die
sowohl Event-Funktionen als auch Ihre benutzerdefinierten
Funktionen beinhalten werden sowohl Event-Funktionen als auch Ihre benutzerdefinierten
Funktionen beinhalten Dann werden wir Delegierte in
Unity haben , die sich auch mit Einzelfahrzeugen,
Delegierten, Multicasts, Delegierten - und
Delegiertenveranstaltungen
befassen Delegierten, Multicasts, Delegierten - und
Delegiertenveranstaltungen Darüber hinaus werden wir Unity-Eingabesystem
verstehen,
das über Tastatureingaben, Mauseingaben und Zugangseingaben verfügen wird Mauseingaben und Zugangseingaben Dann werden wir etwas
über starre Körper lernen und Kollisionen werden bei starren Körpern
eingeführt Wir werden ein Beispiel
für einen starren Körper haben. Erstelle in einem Spiel einen Boden
und bewege eine Kugel mithilfe eines starren Körpers oder eines starren
Körpers, der an einer Kugel befestigt ist. Auch hier werden Kollisionen Collidern
und Kollisionen
vertraut Wir werden Beispiel 1.2 verwenden, Kollisionen
zu verstehen. Außerdem werden wir eine Einführung
in die Animation geben. Dann werden wir
ein Sprite animieren, Teil eins, Teil zwei, Teil drei
und Teil Später werden wir einen Drei-D-Charakter verstehen oder lernen , ihn zu animieren Wir werden Teil eins, Teil zwei und Teil drei für dasselbe Zum Abschluss der Serie werden
wir schließlich ein Spiel
namens Knock the Cans in Unity entwickeln , bei dem wir die Dosen mit einem Speer oder
einem Ballspielobjekt
niederschlagen werden mit einem Speer oder
einem Ballspielobjekt
niederschlagen In Ordnung Leute, das war ein
kurzer Überblick über die Serie. Lassen Sie uns in der nächsten Sitzung mit
der Installation von Unity beginnen . Vielen Dank, Leute. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
2. Einführung in Unity und Einführung: Guten Abend Leute. Mein Name
ist Rohan S. Dies ist die
zweite Sitzung, in der ich
Ihnen etwas über die Unity Game Engine
und die Installation von Unity erzählen werde Ihnen etwas über die Unity Game Engine und die Installation von Unity Was ist also Unity? Bevor wir beginnen,
lassen Sie uns wissen, dass Unity eine plattformübergreifende
Spiele-Engine
ist, mit der
2D-VR- und AR-Spiele erstellt werden Okay, es ist also eine
plattformübergreifende Game-Engine. Es unterstützt mehrere
Plattformen wie Windows, Mac-Betriebssystem,
Android und IOS. Warum Unity? Okay, jetzt
gibt es auch andere Plattformen. Es gibt auch andere IDs,
an denen wir arbeiten können. Aber warum Unity? Warum
wird Unity so sehr bevorzugt? Warum viele Entwickler Unity Statistics
verwenden,
sagen wir, dass im Jahr 2020 von Unity erstellte
Anwendungen
hauptsächlich von 2 Milliarden aktiven Benutzern
pro Monat verwendet wurden , davon 1,5 Millionen Entwickler
pro Monat. Okay, also 2 Milliarden Spieler haben das mit Unity
entwickelte Spiel
tatsächlich gespielt. Außerdem gab es monatlich 1,5
Millionen Entwickler. Von all den Entwicklern, die auf verschiedenen
Plattformen an der Entwicklung von Spielen
arbeiteten, nutzten
1,5 Millionen Entwickler pro Monat Unity als ihre ID, okay, als ihre Game-Engine, um jede Art von Spiel zu entwickeln. Ob es ein
zweitägiges Spiel sein könnte, es könnte ein Drei-D-Spiel sein, es könnte ein VR-Spiel sein, es könnte ein AR-Spiel sein. Außerdem bietet Unity Engine
eine Kombination aus
mehreren Ressourcen. Jetzt gibt es einige
eingebaute Ressourcen. Sie können auch
Assets aus dem Asset Store herunterladen. Wie installiere ich Unity? Woher bekomme ich diese Unity? Ist es frei verfügbar? Oder was sollte ich tun, wenn ich mit Unity beginnen
möchte? Okay, um mit Unity zu
beginnen, müssen
Sie einfach
zur Unity-Download-Seite gehen. Es gibt also einen Link
,
den ich in
dieser Präsentation, in dieser Sitzung
einfügen werde den ich in
dieser Präsentation, in dieser , okay? Und Sie können auf diesen Link gehen
und dem Verfahren folgen, im Grunde ist das der
Link dafür, okay? Es ist also der Slash-Download von ttpsstoverdtunity.com
. Es gibt also eine Schaltfläche, über
die Unity Hub heruntergeladen werden soll . Bevor Sie die Unity Engine herunterladen, müssen
Sie Unity Hub herunterladen. Klicken Sie auf die Schaltfläche
Unity Hub herunterladen. Was ist der nächste Prozess? Okay? Sie öffnen Unity
Hub und finden dann im
Unity-Hub
eine Registerkarte namens Tab installieren. Sie klicken auf „Installieren“ und
wählen „Installiert“. Sobald Sie
auf die Registerkarte Installieren klicken, finden
Sie im
Installationsbereich
des Unity-Hubs eine Anzeigenschaltfläche . Okay? Klicken Sie auf die Anzeigenschaltfläche und Sie werden so
etwas sehen. Okay, in diesem Fall wählen Sie
Installationen in Unity Hub. Okay, hier habe ich auf Installationen
geklickt. Und dann können Sie ganz rechts eine
Schaltfläche sehen , bei
der es sich um eine Werbeschaltfläche handelt Du musst nur darauf klicken. Und sobald Sie
auf die Anzeigenschaltfläche klicken, wird
dies geöffnet. Okay? Sie müssen nur die Version
auswählen, welche Version von Unity
Sie herunterladen möchten. Und dann müssen Sie
den Schritten folgen, um
Unity Editor oder Unity Engine
auf Ihrem Laptop oder Ihrem Dextop zu installieren Unity Editor oder Unity Engine auf Ihrem Laptop oder Ihrem Dextop Das war's, Leute. Vielen Dank für die Sitzung.
Ich danke dir vielmals.
3. Erstelle mein erstes 3D-Projekt in Unity: Guten Abend Leute. Mein
Name ist Rohan Vsdev, und in dieser Sitzung
werde ich Ihnen beibringen, wie
man ein
Drei-D-Projekt in Unity erstellt Okay, ich habe meinen Unity
Hub bereits geöffnet. Meine Version für Unity
Hub ist 2.4 0.5 Okay, es ist
also eine neue Version
verfügbar, nämlich 3.2 0.0, aber ich werde zu
Demonstrationszwecken Version 2.4
0.5 verwenden Demonstrationszwecken Version 2.4 . Also, wie erstellt man
ein Projekt in Unity. In der letzten
Sitzung haben wir nun gesehen, wie man Unity Engine
und auch Unity Hub
installiert. Ich habe also bereits meinen
Unity-Hub geöffnet, um ein Projekt zu erstellen. Ich muss nur hierher gehen, um ein neues Projekt zu
erstellen. Okay, ich muss nur hier klicken. Ich muss meine Version auswählen. Für
die Demonstration werde
ich Unity
Version 2.019.3 verwenden. Okay, ich muss nur darauf klicken Im Moment möchte ich ein
Drei-D-Projekt erstellen. Okay, hier muss ich
den Namen für das Projekt angeben. Okay, ich
ändere hier einfach den Namen. Zuerst die Unity-Demo. Das ist der Name meines Projekts. Der Ort, an dem mein Projekt
gespeichert wird, ist D Drive. Sie können den Speicherort ändern wenn Sie das Projekt
in Google Drive oder an einem anderen
Ort speichern möchten, an dem Sie Ihr Projekt
speichern möchten. Ich muss nur
auf die Schaltfläche Erstellen klicken. Okay, jetzt
öffnet das deine Unity Engine. Dies ist die
Beispielszene, die
erstellt wurde, als Sie
ein Unity-Projekt erstellen. Wenn Sie den Namen des
Seniors
umbenennen, den Namen des
Seniors
umbenennen wird der
Name der Szene geändert. Im Grunde, wie man das macht. Okay, ich muss nur
hier mit der rechten Maustaste auf die Beispielszene klicken. Wählen Sie von hier aus Szene speichern unter. Okay, speichern Sie diese Szene
im Szenenordner. Okay, also meine erste Szene, speichern
wir sie einfach. Ihr alle könnt hier sehen der Name der Szene jetzt geändert
wurde. Es ist gerade meine erste Szene. Gehen wir zu den Szenen. Und hier ist unsere Szene,
meine erste Szene. Okay, das war's Leute. Vielen Dank
für die Sitzung. Wir sehen uns in der nächsten Sitzung.
4. Konfiguriere Visual Studio in Unity und mache dich bereit für das Scripting: Guten Abend Freunde. Mein
Name ist Rohan Asda und werde Ihnen erklären, wie Sie Visual
Studio mit
Unity konfigurieren Also, was ist Visual Studio? Es handelt sich um eine integrierte
Entwicklungsumgebung
, bei der es sich um IDE handelt ,
die von Microsoft entwickelt wurde zur Entwicklung von Benutzeroberflächen,
Webanwendungen,
mobilen Anwendungen
und Cloud-basierten Anwendungen
verwendet wird Webanwendungen,
mobilen Anwendungen . Der Code kann auch in C, Sharp,
C plus plus, Visual, Basic,
Python und vielen
anderen Sprachen
geschrieben C plus plus, Visual, Basic, werden. Insgesamt
unterstützt Visual Studio 32 Sprachen. Visual Studio ist
auch für Windows
- und
Mac-Betriebssysteme verfügbar . Es gibt also drei Ergänzungen
für Microsoft Visual Studio, und sie lauten wie folgt,
wie wir hier sehen können. erste ist die
Community Edition
, eine kostenlose Version. Jeder einzelne
Entwickler kann damit grundsätzlich kostenlose oder kostenpflichtige
Anwendungen
entwickeln. Die Funktionen sind dem
Professional Addition mehr oder weniger ähnlich. Professional Addition ist eine
kostenpflichtige und kommerzielle Version. Sie müssen bezahlen, wenn Sie herunterladen oder
installieren möchten. Grundsätzlich bieten sie
Ihnen eine kostenlose Testversion. Sobald eine kostenlose Testversion abgelaufen ist, müssen
Sie für Professional bezahlen,
sowohl
für Professional - als auch für
Enterprise-Erweiterungen. Was sind im Grunde die Schritte, um Visual
Studio in Unity zu installieren? Okay, der erste Schritt
besteht darin, einfach
zur Microsoft Visual
Studio-Download-Seite zu gehen . Ich habe hier einen Link eingefügt. Das ist der Link dafür. Als Nächstes, als Nächstes, sobald Sie auf diesen Link klicken, sobald Sie auf diesen Link klicken, finden
Sie eine Schaltfläche mit der
Bezeichnung Visual Studio herunterladen. Sie müssen nur auf die Schaltfläche
klicken
, um zu einer anderen Seite zu gelangen. Okay, wo Sie
tatsächlich die Version auswählen können , die Sie in Visual Studio installieren oder herunterladen
möchten. Sobald Sie auf die Schaltfläche
Zurück geklickt haben, gelangen Sie zu den Slash-Downloads auf sttpsvisualtudiotmicrosoft.com Okay, und so wird die Seite aussehen. Das ist Visual Studio 2022. Es gibt auch andere Optionen. Wenn Sie möchten, können Sie Visual Studio 2019
herunterladen. Sobald Sie
hier auf dieser Seite sind,
auf der Download-Seite
für Visual Studio,
müssen Sie auch auf der Download-Seite
für Visual Studio, auf
den kostenlosen Download für die
Community-Version klicken , da wir hier eine kostenlose Version
verwenden werden. Wir werden keine
Professional- oder
Enterprise-Versionen verwenden,
da es sich um Professional- oder
Enterprise-Versionen eine kostenpflichtige Version handelt. Also werden wir auf die Schaltfläche
klicken, die kostenlos heruntergeladen werden kann. Und was passiert als Nächstes, wenn Sie auf diese
Schaltfläche klicken? Es ist sehr einfach, wird mit der
Installation des Installers beginnen. Das Installationsprogramm für
Visual Studio
wird also im Grunde genommen installiert, was eine EX-Datei sein wird. Sie müssen also nur auf
diese EX-Datei klicken und
den Installationsvorgang starten. Sobald der
Installationsvorgang gestartet ist, sehen
Sie so etwas,
diesen speziellen Bildschirm. Und auf diesem Bildschirm sehen
Sie einen Workload-Tab. Hier müssen Sie nur einen
Workload-Tab auswählen. Okay, im Workload-Bereich musst
du hier die
Spieleentwicklung mit Unity überprüfen. Okay, das ist ein sehr
wichtiger Teil bei der Installation von Dual
Studio für Unity. Also musst du das nur überprüfen. Sobald dies
angeklickt oder aktiviert ist, müssen
Sie nur noch auf
die Schaltfläche Installieren klicken , um mit
dem
Installationsvorgang fortzufahren Erstellen Sie ein neues Projekt
mit Unity Hub. Sobald das Projekt erstellt wurde, finden
Sie die Bearbeitungsoption. Im Unity-Editor müssen
Sie nur
auf die Option Bearbeiten klicken und dann
die Option Einstellungen auswählen. Sobald Sie also auf
die Option Einstellungen klicken, wird ein Popup-Fenster geöffnet, bei
dem
es sich um ein externes Tool handelt. Hier wird es so
etwas öffnen. Okay? Jetzt müssen
Sie im
Einstellungsfenster hier
externe Tools auswählen. Okay? Sobald Sie also
auf die externen Tools geklickt haben,
müssen Sie den externen Skripteditor aufrufen.
Sie müssen die
Version anhängen, die Sie gerade heruntergeladen
haben
, nämlich Studio 2019. Sobald dies von
nun an erledigt ist
, müssen
Sie in Ihrem Unity-Editor auf
Ihre Windows-Registerkarte
gehen Ihre Windows-Registerkarte und Package Manager
auswählen. Sobald Sie
in der Fensterregisterkarte auf
diesen Paketmanager klicken , wird ein Bildschirm wie
dieser angezeigt und Sie
müssen
Visual Studio co hier in
das Suchfeld eingeben Visual Studio co hier in oder einfach
Visual eingeben.
Sie werden feststellen, dass das Paket vom Visual
Studio-Code-Editor
benannt wird . Sie müssen es nur überprüfen. Sobald dieser
Vorgang abgeschlossen ist, können Sie
Visual Studio oder C Sharp
in Ihrem Unity-Editor verwenden . Danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
5. Erstelle mein erstes C#-Skript in Unity: Guten Abend Leute.
Ich heiße Roan In der letzten Sitzung
haben wir alle gesehen, wie wir
Visual Studio in Unity installiert haben In dieser Sitzung werde
ich Ihnen jetzt erklären, wie
Sie tatsächlich ein
C-Sharp-Skript in Unity
erstellen. Erstens haben wir hier einen
Assets-Ordner. Sie können auf
den Assets-Ordner klicken und den Assets-Ordner auswählen. Um nun alles zu organisieren und alle Skripte
in einem Ordner zu speichern, werden wir
hier einen Ordner
in diesem Ordner erstellen. Okay, wir müssen hier klicken und dann auf Erstellen
klicken. Dann müssen Sie hier die
Ordneroption auswählen. Wir möchten nicht, dass es
ein neuer Ordner ist, also werden wir ihn einfach in Skripte
umbenennen. Okay, jetzt öffnen wir
den Scripts-Ordner. Okay? Doppelklicken Sie auf
den Ordner mit den Skripten. So erstellen Sie ein Skript. Jetzt, im
Scripts-Ordner, ist es sehr einfach. Sie müssen nur schreiben, hier mit der Maus
klicken
und dann zu Erstellen gehen. Auch hier haben wir das letzte Mal, als
wir einen Ordner erstellt
haben, die Ordneroption gewählt. Okay. Aber dieses Mal
werden wir ein Drehbuch erstellen. Wir müssen ein scharfes Drehbuch haben. Klicken Sie einfach auf das
C-Sharp-Skript, okay. Jetzt musst du es umbenennen. Standardmäßig lautet der Name
des Skripts
neues Verhaltensskript, aber wir wollen das nicht
so haben, weil wir das Skript umbenennen
wollen. Lassen Sie uns es jetzt
als mein erstes Skript umbenennen. Okay, dein Skript
ist jetzt erstellt. Jetzt klicken wir einfach auf
das Skript, um es zu öffnen. Das ist ein Leute, wir sehen uns
in der nächsten Sitzung. Ich danke euch vielmals, Leute.
6. Den Ablauf und die Struktur eines C#-Skripts verstehen - Teil 1: Guten Abend Leute. Mein
Name ist Rohan Dev In der vorherigen Sitzung
haben wir gesehen, wie man ein C-Sharp-Skript
in Unity erstellt Wie wir alle hier sehen können, ist
diese Klasse in Unity eine
Blaupause für Ihr Objekt Jetzt beginnen alle Skripte in Unity immer mit
einer Klassendeklaration Und diese Klasse wird
automatisch erstellt, wenn Sie ein
C-Sharp-Skript in Unity erstellen. Der Name der Klasse,
wie wir alle hier sehen können, mein erstes Skript wird
immer derselbe sein wie der
Name Ihres Skripts. Als wir das letzte Mal ein
Skript erstellt haben, war
der Name des Skripts, das
wir behalten haben, mein erstes Skript, also wird es auch der
Name der Klasse sein, also wird es immer derselbe sein. Was ist System Dot Collection? System Dot Collections oder
Generic And Unity Engine, im Grunde
sind das alles Namespaces
, also eine Sammlung
von Klassen Unity, die
Monobehavior-Klasse hier, einschließlich aller anderen
Kernfunktionen von Unity, sich im Unity-Engine-Namespace Okay, Unity Engine wird also
im Grunde
alle Unity-Kernfunktionen
und auch die Monobehavior-Klasse haben alle Unity-Kernfunktionen
und auch die Monobehavior-Klasse Wenn Sie ein Skript
erstellen,
hat das Skript im Allgemeinen fünf wichtige
Aspekte Was sind also diese Aspekte? Zuerst dieses öffentliche Schlüsselwort, dann kommt deine Klasse. Der vierte ist der
Name des Skripts oder der Name der Klasse. Dann kommen der Doppelpunkt
und das Mono-Verhalten. Lassen Sie uns zunächst verstehen
, was hier öffentlich ist. Nehmen wir zum Beispiel an,
es gibt zwei Skripte. Und Sie möchten, dass ein Skript mit einem anderen Skript
interagiert. Wenn Sie etwas öffentlich machen bedeutet das, dass es
von einem anderen Skript aus zugänglich ist. Außerdem wird diese spezielle
Klasse von einer anderen Klasse oder auch
von einem anderen Unity-Skript aus
zugänglich sein anderen Klasse oder auch
von einem anderen Unity-Skript aus
zugänglich . Jetzt können wir hier alle das Verhalten von
Mono sehen. Was ist Mono-Verhalten? Das Verhalten von Mono ist im Grunde eine Basisklasse für alle Skripte. Und dieser Doppelpunkt bedeutet, dass
es von der Monobehavior-Klasse erbt, es bedeutet einfach, okay, dass
alle Skripte, die wir in
Unity C Sharp erstellen , von der Monobehavior-Klasse
geerbt werden Hier in der nächsten Sitzung werde
ich Ihnen sagen, was diese Funktionen
sind,
nämlich void start
und void update Okay, diese werden
auch automatisch erstellt, wenn wir
ein Unity C-Sharp-Skript erstellen. Danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke dir vielmals.
7. Den Ablauf und die Struktur eines C#-Skripts verstehen - Teil 2: Hallo Leute, mein Name
ist Rohan Vasudev. In dieser Sitzung
werden wir sehen, was Void Start und Void Update Schauen wir uns zuerst an, was ungültig ist. Void ist der
Rückgabetyp, also in diesem Fall die hier erstellte Startfunktion nichts zurück. Startfunktion wird
grundsätzlich aufgerufen sobald der Frame der
Szene erstellt wurde. Ein Frame ist nur
ein Standbild. All diese Bilder
werden
in schneller Folge zusammen eine Bewegung
für das Spiel erzeugen. Start wird aufgerufen, sobald
der erste Frame des Spiels erstellt wurde. Es wird nur ausgeführt, wenn
das Skript aktiviert ist. Wenn das Skript nicht aktiviert ist. Wenn es deaktiviert ist und die Startfunktion überhaupt
nicht ausgeführt wird. Es wird auch einmal im
Lebenszyklus des Shaft-Skripts aufgerufen. Es gibt also einen Lebenszyklus für die Unity-Skriptstartfunktion, die nur einmal
im Lebenszyklus
aufgerufen wird . Wofür wird die Startfunktion verwendet? Startfunktion wird zum Initialisieren von
Objekteigenschaften oder Variablen
verwendet Objekteigenschaften oder Variablen Jede Variable, die Sie initialisieren
möchten, oder jede Objekteigenschaft, die Sie initialisieren
möchten, können
Sie jederzeit
innerhalb der Startfunktion initialisieren Lassen Sie uns hier über die
Aktualisierungsfunktion sprechen. Auch hier haben wir
void, einen Rückgabetyp für
die Aktualisierungsfunktion. Diese Aktualisierungsfunktion wird
also nichts zurückgeben. Aktualisierungsfunktion wird erst aufgerufen nachdem die
Startfunktion ausgeführt wurde. Die Aktualisierungsfunktion führt jeden
Frame des Spiels oder des gesehenen Frames aus. Okay? Es wird also bei jeder
Frame-Ausführung der Aktualisierungsfunktion
aufgerufen Frame-Ausführung der Aktualisierungsfunktion der
Bildrate des Spiels
abhängt. Bildrate bedeutet einfach , dass wie
viele Frames im Allgemeinen alle
60 Sekunden
erstellt oder abgerufen werden? Generell gilt: Je höher
die
Bildrate des Spiels ist , desto geringer wird das Zeitintervall zwischen der Aktualisierungsfunktion
sein Der Aufruf einer
Aktualisierungsfunktion
hängt vollständig von der
Framerate Ihres Spiels ab. Das war's, Leute.
Danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung.
8. Schreibe ersten Code in C# und drucke 'Hello Code': Hallo Leute, mein Name ist Rohan Vasudev und in dieser
Sitzung werde ich Ihnen erklären, wie man
Hello-Code in der Unity-Konsole druckt Zunächst müssen
wir also ein leeres Spielobjekt erstellen Alles in Unity ist
im Grunde ein Spielobjekt. In diesem Fall müssen
wir hier also ein leeres
Spielobjekt erstellen. Wie erstellen wir hier also ein
leeres Spielobjekt? Okay, zu diesem Zweck klicken Sie
einfach mit der rechten Maustaste auf Ihre Szene, das ist meine erste Szene. Wählen Sie hier ein Spielobjekt aus
und wählen Sie Create Leer. Auf diese Weise erstellen wir also
ein leeres Spielobjekt. Der Name des
leeren Spielobjekts lautet
standardmäßig Spielobjekt. Wir werden es einfach in
mein erstes Spielobjekt umbenennen. Wir werden das Skript,
mein erstes Skript hier,
das wir in
den vorherigen Sessions erstellt haben,
an dieses Spielobjekt anhängen mein erstes Skript hier, das wir in
den vorherigen Sessions erstellt haben, . Wir benötigen hier keine
Update-Funktion. Lassen Sie uns diese
Funktion einfach entfernen, weil
wir unseren Code
in die Startfunktion schreiben werden. Beginnen wir hier damit, einen Code zu
schreiben. Ich werde die
Debug-Log-Funktion in
Unity verwenden , um Hello-Code zu drucken Das endet mit einem Semikler. Debug Dot Log ist im Grunde eine Funktion innerhalb von Unity,
bei der Sie hier eine
Zeichenfolge übergeben
müssen. Dadurch wird der Hello-Code
in der Unity-Konsole ausgegeben Lass uns einfach das Skript speichern. Klicke einfach auf mein
erstes Spielobjekt und wähle hier Konsole. Klicken Sie einfach auf Komponente hinzufügen, klicken Sie hier und fügen Sie das Skript
zu diesem leeren Spielobjekt hinzu. Okay, klicken Sie auf Komponente hinzufügen
und geben Sie meine erste ein. Bei der Suche
findest du das Skript. Klicke auf mein erstes
Script und das Script wird an dein
leeres Spielobjekt angehängt. In unserem Fall ist es mein
erstes Spielobjekt. Okay, speichern Sie jetzt die Szene und starten Sie sie, indem Sie hier auf
diese Play-Schaltfläche klicken. Und hier haben wir den
Hello-Code in der Unity-Konsole gedruckt. Das war's, Leute. Vielen
Dank für die Sitzung. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
9. Verstehen von Datentypen und Variablen in Unity C#: Hallo Freunde, mein Name ist Rohan. Sicher. Und in dieser Sitzung werde
ich Ihnen Datentypen und Variablen
in C Sharp und Unity erklären. Ein Datentyp spezifiziert
den Datentyp. Bei diesen Daten kann es sich um eine Zeichenfolge, eine Ganzzahl, eine Bullion, eine Fließkommazahl
oder eine Doppelzahl handeln Auch hier
können je nach akzeptiertem
Wert oder Datentyp verschiedene Operationen mit
dieser bestimmten Datenzeichenfolge ausgeführt werden dieser bestimmten Datenzeichenfolge Datentyp wird verwendet, um eine
Folge von Zeichen,
Zahlen und Zeichen in
Form von Wörtern oder Sätzen zu speichern . Ein Wert vom Datentyp Zeichenfolge ist in Doppelcodes eingeschlossen. Er wird immer
in Doppelcodes eingegeben. Der andere Datentyp
ist Ihr Datentyp
, der zum Speichern von
32-Bit-Ganzzahlen verwendet wird. Bei den Zahlen handelt es sich im Allgemeinen um
ganze Zahlen, die auch positive und
negative Zahlen enthalten. Auch hier haben wir einen
Float-Datentyp
, der zum Speichern von
Fließkommazahlen auch zum Speichern von
Fließkommazahlen verwendet wird. Der einzige Unterschied
zwischen Float
und Double besteht jedoch darin, dass Double größere
Zahlen speichert als Float. Auch hier haben wir einen ganzen
Datentyp, der im Allgemeinen zum Speichern von wahren
oder falschen Werten
verwendet wird, im Allgemeinen zum
Speichern von Informationen verwendet wird Diese Information
könnte ein Name des Spielers sein, eine Punktzahl
oder eine Hölle Jetzt kann der einer
Variablen zugewiesene Wert während der
Ausführung eines Programms jederzeit geändert und
modifiziert werden . Auch hier gilt: Wenn eine
Variable erstellt wird, wird
etwas Speicherplatz zugewiesen. Die Deklaration einer Variablen beginnt
immer mit einem Datentyp, gefolgt
vom Namen der Variablen. Hier ist mein Editor. Wir haben bereits
ein leeres Spielobjekt erstellt. Ich habe dieses
leere Spielobjekt
in Variablenobjekt umbenannt . Auch hier habe ich ein Skript erstellt. Hier ist der Name des
Skripts meine Variablen. Lassen Sie uns das
Skript öffnen und
einige Variablen
innerhalb des Skripts deklarieren . Lassen Sie uns zunächst
eine Zeichenkettenvariable deklarieren. Okay? Vorname ist gleich, weisen
wir der Variablen einen Wert
zu Okay, Danny, bei der
Deklaration einer Variablen ist
Zeichenfolge der Datentyp, Vorname ist der
Name der Variablen
und Danny ist der Wert, der der Variablen
zugewiesen wurde, Okay. Lassen Sie uns nun eine
Variable mit Datentyp deklarieren. Okay, nennen wir
es Nummer eins. Lassen Sie uns einen Wert zuweisen. Lassen Sie uns eine Variable
mit dem Datentyp Float deklarieren. Nennen wir es Nummer zwei. Und lassen Sie uns einen
Wert 10,5 zuweisen. Nun
deklarieren wir eine Variable mit einem Datentyp, dem die doppelte
Zahl drei entspricht Abschließend deklarieren wir
eine Variable mit dem Bull-Datentyp val Mein Wert ist der Name
der Variablen. Weisen wir den Variablenvariablen,
die
wir hier deklariert haben, den Wert true zu. Wir werden diese
Variablen in der Konsole drucken. Fangen wir an, die
Werte für die Variablen zu drucken. Okay, wir müssen hier nur
den Namen für die Variable übergeben . Speichern wir das Skript
und hängen wir dieses Skript an das Spielobjekt an, das
wir hier erstellt haben, bei dem es sich um das
wir hier erstellt haben, bei dem ein Variablenobjekt handelt. Okay, hier ist es.
Also das war's Leute. Danke für die
Sitzung. Wir sehen uns in der nächsten Sitzung.
Ich danke dir vielmals.
10. Einführung in die Operatoren in Unity C#: Hallo Leute. Mein Name ist Rohan
Vasudev und in dieser Sitzung werde
ich Ihnen erklären,
was Operatoren in Unity sind Sharp-Operatoren sind
spezielle einfache Operatoren oder ein Zeichen, das
bestimmte Aktionen mit Operanden oder Variablen ausführt,
steht im Grunde für eine Aktion
oder einen Prozess, den wir mit Variablen oder Operanden ausführen Operatoren sind die Grundlage für
jede Programmiersprache. Ohne die
Existenz von Operatoren wäre
jede Programmiersprache
im Grunde unvollständig. Was sind nun Arten von Operatoren? Wie viele Arten von Operatoren
gibt es in Unity? Scharf? Lass uns sehen. Zuerst sind es Ihre
arithmetischen Operatoren. Dann haben wir
relationale Operatoren, dann haben wir logische Operatoren,
dann haben wir Zuweisungsoperatoren
und Bedingungsoperatoren und Schauen wir uns zunächst an, was
arithmetische Operatoren sind. Was sind arithmetische Operatoren? Arithmetische Operatoren werden
im Allgemeinen verwendet, um
mathematische Operationen
an Variablen oder Operanden durchzuführen mathematische Operationen
an Variablen oder Operanden Nun gibt es einige Arten von arithmetischen Operatoren
. Der erste ist Ihr
Additionsoperator. Der Additionsoperator wird verwendet, um Additionen von zwei
Operanden oder Variablen zu
berechnen Mit diesem Operator können wir grundsätzlich zwei
Operanden oder Variablen hinzufügen Es kann auch für die
Verkettung von zwei Zeichenkettenvariablen verwendet werden Verkettung von Beispiel: Wenn eine Ganzzahl
a gleich fünf ist und eine Ganzzahl B auf den Wert Zehn
gesetzt ist, dann wäre die Ausgabe für die
Addition 15. Es berechnet im Grunde
eine grundlegende Addition von zwei Variablen oder Operanden Als nächstes kommt Ihr
Subtraktionsoperator. Subtraktionsoperator
wird verwendet, um den
rechten Operanden erneut vom
linken Operanden zu subtrahieren rechten Operanden erneut vom
linken Operanden Der dritte ist Ihr
Multiplikationsoperator, bei dem wir tatsächlich die
Multiplikation von Operanden oder Variablen berechnen Multiplikation Wir haben einen
Divisionsoperator, der
Ihren linken Operanden durch
seinen rechten Operanden dividiert Ihren linken Operanden durch
seinen rechten Operanden Auch hier handelt es sich um Ihren
Modulooperator, der
den Rest zurückgibt, wenn der linke Operand durch den rechten Operanden geteilt
wird Wenn Sie also eine Division durchführen, dann wäre der Rest, den Sie erhalten, Ihre Ausgabe
in Gehen wir nun in den
Unity-Editor und schauen wir uns an, wie wir tatsächlich einige Aktionen
mit arithmetischen Operatoren ausführen
11. Arithmetische Operatoren und ihre Verwendung verstehen: Leute, wir mögen Unity Editor. Wie Sie alle sehen können, habe
ich bereits
ein leeres Spielobjekt erstellt , das ein Operator-Objekt ist. Und wieder habe ich
ein C-Sharp-Skript erstellt , das aus arithmetischen Operatoren
besteht Um nun einige
Aktionen oder Berechnungen durchzuführen, öffnen wir das von
uns erstellte Skript
, bei dem arithmetische Operatoren
in A gleich fünf,
in B gleich in Okay, Bug Dot Log A plus, das ist Das ist ein kommentierter Code. Im Grunde
wird es kein Debug-Protokoll ausführen. Okay, lassen Sie uns hier a von
B abzüglich des Debug-Logs d subtrahieren B abzüglich des Debug-Logs d ,
hier ist Lassen Sie uns das
Thema Operatoren
in der nächsten Sitzung fortsetzen .
Ich danke Ihnen vielmals.
12. Relationale Operatoren und ihre Verwendung verstehen: Hallo Freunde. Mein Name
ist Rohan Vase In der letzten Sitzung haben wir arithmetische
Operatoren gesehen. In dieser Sitzung werden wir
etwas über
relationale Operatoren lernen Was sind relationale Operatoren? Relationale Operatoren
werden verwendet, um
zwei Werte oder
Variablen oder Operane zu vergleichen zwei Werte oder
Variablen oder Operane Was sind nun die Arten von
relationalen Operatoren? Der erste relationale Operator
ist gleich gleich wird verwendet, um zu überprüfen, ob zwei Werte gleich
sind oder Wenn beide Werte gleich sind, wird „Wahr“ zurückgegeben Oder wenn sie nicht gleich sind, wird falsch zurückgegeben. Wenn wir zum Beispiel zwei Variablen
haben, in denen A gleich fünf und
in b gleich fünf ist, dann ist das Ergebnis bool Wir speichern den Wert in
einer Variablen namens result. Okay? Wir prüfen hier, ob beide Variablen dieselben Werte
haben und
wie wir das machen. Wir machen das mit dem
Equal-to-Operator, okay? In diesem Fall
ist fünf gleich fünf, die Ausgabe wird jetzt wahr sein. Als Nächstes ist Ihr Operator nicht gleich
, okay? Der Operator „Nicht gleich“ wird verwendet, um zu überprüfen, ob zwei Werte gleich
sind oder nicht. Wenn nun beide
Werte nicht gleich sind, gibt es zwei zurück, andernfalls fällt er, dann haben wir den Operator
größer als. Der Operator „Größer als“ wird
hauptsächlich verwendet, um zu überprüfen, ob der linke Operand
größer als der
rechte Operand ist größer als der
rechte Operand Zum Beispiel, wenn wir
eine Variable a haben, deren Wert auf 50 gesetzt
ist, und eine Variable
, deren Wert auf zehn gesetzt ist Dann ist das bol-Ergebnis
für a größer als in diesem Fall zwei, weil
50 größer als zehn ist. Gehen wir nun zum nächsten Operator über
,
der kleiner als Operator ist. Der Operator „Weniger als“ wird
hauptsächlich verwendet, um zu überprüfen, ob der Operand für die linke Hand
kleiner ist als der für die
rechte Hand nach oben. In diesem Fall haben wir
den Wert von A auf 50
und einen Wert von 210 Ein Wert, der kleiner ist,
fällt natürlich, weil 50 nicht
geringer ist als die Ausgangsleistung für dieses spezielle
Beispiel fällt. Auch hier wird der
Operator größer
als gleich, größer als gleich verwendet, um zu überprüfen, ob der linke Rand
größer oder gleich der Marke für die
rechte Hand ist größer oder gleich der Marke für die
rechte Hand Es prüft für beide
Bedingungen, ob
es größer oder gleich
dem rechten Operanden Der letzte relationale Operator
ist oder kleiner als, gleich, kleiner als gleich Der Operator wird verwendet, um zu überprüfen, ob die Marke für die linke Hand nach oben
kleiner oder gleich der Marke für die
rechte Hand ist nach oben
kleiner oder gleich der Marke für die
rechte Hand In diesem Beispiel überprüfen wir
hier den Wert von A
, der auf zehn gesetzt ist, und dessen Wert erneut auf zehn gesetzt
ist. Okay, wir prüfen hier, ob a kleiner oder gleich b ist, aber in diesem Fall ist a
nicht kleiner als es gleich ist, es wird hier offensichtlich
die Ausgabe als wahr ausgeben. Gehen wir nun in den Editor und
schreiben wir einen Code und drucken wir die
Werte im Editor aus. Okay Leute, ich bin jetzt
im Unity-Editor und habe hier bereits
ein Operator-Objekt erstellt. Das ist ein leeres Spielobjekt. Außerdem habe ich
ein C-Sharp-Skript erstellt, das ein relationales
Operator-Skript ist Ich habe das Skript als
relationale Operatoren benannt und das Skript
hier an das Objekt des
Operators Lassen Sie uns das Skript öffnen
und den Code sehen. Okay, wir haben hier schon einen Code
geschrieben. Wir haben eine Variable deklariert
, die gleich
fünf ist, und eine Variable
vom Datentyp inc, und der Wert der
Variablen ist auf zehn gesetzt Und wir haben hier eine
Bool-Variable deklariert, Ergebnis. Und wir haben
hier keinen Wert für die bool-Variable festgelegt. In der
Startfunktion prüfen
wir nun zunächst, ob
a gleich b ist. Dann
wird hier der Wert
des Ergebnisses der Variablen
bull zugewiesen Da die Ausgabe
dafür eine Bo-Ausgabe sein wird, weisen
wir diese Ausgabe hier
der Bool-Variablen result zu der Bool-Variablen result Schließlich prüfen wir, ob a kleiner oder
gleich B
ist oder nicht, und der Wert wird hier
der Ergebnisvariablen zugewiesen Lassen Sie uns jetzt einfach diesen Code ausführen und uns die
Ausgabe für den Kern ansehen. Das war's, Leute, lasst uns
die Operatoren in
der nächsten Sitzung fortsetzen . Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
13. Logische Operatoren und ihre Verwendung verstehen: Hallo Freunde, mein Name ist Rohan
V. In der letzten Sitzung haben wir etwas über
relationale Operatoren gelernt In dieser Sitzung werden wir
etwas über logische Operatoren lernen etwas über logische Operatoren lernen Was sind logische Operatoren? Logische Operatoren
werden verwendet, um
zwei oder mehr Bedingungen oder
relationale Aussagen zu kombinieren zwei oder mehr Bedingungen oder und geben den
Pullion-Wert zurück Logische Operatoren ziehen
immer einen Wert ab. Was sind die Arten von
logischen Operatoren? Der erste ist Ihr logischer Operator. Der logische Operator prüft , ob alle Bedingungen wahr
sind oder nicht. Er gibt nur wahr zurück, wenn alle
Bedingungen wahr sind, und er gibt falsch zurück,
wenn eine
der relationalen Aussagen
oder Bedingungen falsch ist Sie als Nächstes mit dem
nächsten logischen Operator fort
, der Ihr logischer Operator ist logische Operator oder
prüft, ob mindestens eine der Bedingungen wahr ist
oder nicht, gibt den Wert true zurück. Ob eine oder alle
relationalen Aussagen
oder Bedingungen wahr
sind nur zurückgegeben, wenn
alle Bedingungen falsch sind Schließlich haben wir den
logischen Operator. Der logische Operator gibt true zurück wenn die Bedingung nicht erfüllt
ist. Gehen wir nun in den Unity-Editor und
schreiben ein Stück Code. Okay Leute, ich bin jetzt im
Unity-Editor, also habe ich hier bereits ein
Operator-Objekt erstellt, das ein leeres Spielobjekt ist. Dann habe ich hier bereits
ein Skript erstellt, das ein Skript für
logische Operatoren
ist , und das Skript bereits an das Objekt
des Operators angehängt. Lassen Sie uns das Skript öffnen
und den Kern hier sehen. Leute, wir haben hier bereits
eine Bullenvariable x deklariert, deren Wert auf wahr gesetzt ist. Wir haben bereits eine
Bullenvariable y deklariert , deren Wert auf False gesetzt
ist. Wir haben bereits
erneut eine Bullenvariable als Ergebnis deklariert. Und wir haben dem Ergebnis noch keinen
Wert zugewiesen. Okay? In
der Startfunktion überprüft
dieser Operator und
hier, ob die
beiden Variablen
x und y wahr sind oder nicht. Aber in diesem Fall ist die
Variable x wahr, die Variable y ist falsch. Daher wird die Ausgabe
hier sinken. Die Ausgabe wird dann hier
der Pool-Variablen result zugewiesen hier
der Pool-Variablen result und dann
in der Konsole gedruckt. Der R-Operator
überprüft hier, ob mindestens einer
der Werte für die Variablen
x und y wahr ist oder nicht. In diesem Fall ist der Wert
für die Variable x wahr,
daher ist die Ausgabe
hier wahr. Die Ausgabe wird dann
wieder
der Bull-Variablen result zugewiesen der Bull-Variablen result und hier in
der Konsole gedruckt. Okay, jetzt haben wir bereits gesehen, dass das Ergebnis für
den Operator falsch ist, aber wir verwenden hier einen
Knotenoperator. Der Knotenoperator gibt wahr zurück,
wenn die Bedingung falsch ist, daher ist die Ausgabe hier wahr. Dieser Wert.
Diese Ausgabe
wird dann hier
erneut der Variablen
result zugewiesen hier
erneut der Variablen
result und dann zuletzt mit der
Bug-Dot-Log-Funktion in der Konsole gedruckt mit der
Bug-Dot-Log-Funktion in der Konsole Lassen Sie uns nun diesen Code ausführen und uns die Ausgabe in
der Unity-Konsole ansehen .
Lassen Sie uns den Code ausführen. Okay, das ist es. Und der Operator
gibt mir die Ausgabe von Falsch oder Operator
hier gibt mir Ausgabe von Wahr und
nicht Operator hier. Schließlich gibt es mir
die Ausgabe von true. Das war's also, Leute. Das
war's für die Sitzung. Wir sehen uns in
der nächsten Sitzung. werden wir mit
dem
Thema Operatoren fortfahren nächsten Sitzung werden wir mit
dem
Thema Operatoren fortfahren. Vielen Dank, Leute.
14. Verstehen von bedingten Operatoren und deren Verwendung: Meine Freunde, mein Name
ist Rohan Masdev. In der letzten Sitzung haben wir logische
Operatoren gesehen. In dieser Sitzung werden wir etwas über
bedingte Operatoren lernen. Was sind bedingte Operatoren? Bedingte Operatoren
haben drei Operanden. Die Syntax für bedingte
Operatoren lautet wie folgt. Der erste wird
Ihr Zustand sein. Dann gibt es einen
ersten Ausdruck und dann kommt ein
zweiter Ausdruck. Da dieser
Bedingungsoperator nun drei Operanden hat, wird
er auch als
ternärer Operator bezeichnet Im Allgemeinen
funktioniert er so, dass
er zunächst die Bedingung hier bewertet Wenn die Bedingung nun wahr ist, der erste Ausdruck ausgewertet
und wird zur Ausgabe Und wenn die Bedingung falsch ist, der zweite Ausdruck ausgewertet und
wird zur Ausgabe. Gehen wir in den Unity-Editor und schreiben wir einen Code. Okay Leute, wir mögen
Unity Editor. Jetzt habe ich bereits
ein leeres Spielobjekt erstellt, das das Objekt des Operators ist. Und ich habe bereits
ein Skript erstellt , das ein
bedingter Operator ist. Lassen Sie uns das Skript öffnen und den Code hier sehen. Jetzt haben wir bereits
eine Variable a deklariert , die vom Datentyp int
ist, und der Wert ist auf fünf gesetzt. Wir haben auch eine
Variable vom Datentyp end deklariert, und der Wert ist auf zehn gesetzt. Wir haben auch eine
Bull-Variable als Ergebnis deklariert, und wir haben ihr zunächst
keinen Wert zugewiesen. Jetzt prüfen
wir in der Startfunktion, ob
a größer als ist. Im Grunde haben wir hier eine
Bedingung angewendet, um zu prüfen, ob a größer ist, als ob
die Bedingung wahr ist. Dann wird der erste Ausdruck
, der hier wahr ist
, der hier boolisch wahr ist, der Variablen result zugewiesen Wenn die Bedingung falsch ist, dann wird der zweite Ausdruck
, der hier falsch ist,
hier dem
Variablenergebnis zugewiesen. Die Ausgabe wird
dann in
der Unity-Konsole mithilfe der
Debug-Punktlog-Funktion gedruckt der Unity-Konsole mithilfe der
Debug-Punktlog-Funktion Ähnlich
prüfen wir hier, ob a kleiner als B ist, der Wert von a kleiner als B. Und wenn die Bedingung wahr ist, dann wird der erste Ausdruck
, der wahr ist, der Variablen result zugewiesen Und wenn die Bedingung falsch ist, wird der zweite
Ausdruck, der falsch ist,
dem Variablenergebnis
hier zugewiesen und in der Unity-Konsole mithilfe
der
Debug-Punktlog-Funktion gedruckt Unity-Konsole mithilfe
der
Debug-Punktlog-Funktion Lassen Sie uns den Code
im Editor ausführen und sehen wir uns einfach
die Ausgabe für
den Code an, hier ist er, Leute Die Ausgabe für den Code, a größer als ist falsch, a kleiner als B ist wahr. Das war's, Leute.
Danke für die Sitzung. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
15. Einführung in die Control Flow Statement in Unity C#: Hallo Freunde. Mein
Name ist Rohan Dev, und in dieser Sitzung
werden wir mehr über
Kontrollflussanweisungen
in Unity, C Sharp, lernen Kontrollflussanweisungen
in Unity, C Sharp, Was sind
Kontrollflussanweisungen in C Sharp? Kontrollflussanweisungen sind
Anweisungen, die den Ablauf eines Programms oder
des Codes ändern oder modifizieren. Sie ermöglicht eine bessere Kontrolle über den Ausführungsablauf eines Codes. Komplexere
Programme können auch mithilfe
von
Kontrollflussanweisungen geschrieben werden . Jetzt wird das Programm
von oben nach unten in
der Reihenfolge ausgeführt , in der es geschrieben wurde. Kontrollflussanweisungen können
den Ablauf der
Ausführung eines Programms ändern . Der Code, der
von oben nach unten ausgeführt wird kann mithilfe von
Kontrollflussanweisungen geändert werden. Danke für die Sitzung. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
16. If-Statements in Unity C# verstehen: Hallo Freunde. Mein Name ist Rohan
Dev, und in dieser Sitzung werden
wir mehr über
Controlled
Flow-Anweisungen im Unity-Shop erfahren Controlled
Flow-Anweisungen im Unity-Shop Was sind nun die Arten von
Kontrollflussanweisungen? Das erste sind Ihre Aussagen
zur Entscheidungsfindung. Wir haben Switch-Statements und dann
Looping-Statements Was sind
Entscheidungserklärungen? Aussagen zur Entscheidungsfindung ähneln denen,
Entscheidungen zu treffen. In Ihrem wirklichen Leben führt
es einen bestimmten
Codeblock aus, wenn die Bedingung wahr
oder erfüllt ist. Die if-Anweisung prüft, ob
die Bedingung vorliegt. Wenn die Bedingung wahr ist, wird der
Codeblock ausgeführt, andernfalls wird er nicht ausgeführt. Gehen wir in den
Unity-Editor und schreiben
wir einen
Code für eine if-Anweisung. Leute, wir haben hier bereits
eine variable Spielergesundheit deklariert , die vom Datentyp end ist und deren Wert auf 30 gesetzt ist. In der Startfunktion
gibt es eine F-Bedingung, und wir prüfen, ob Gesundheit des
Spielers
unter 50 liegt oder nicht. Wenn die Gesundheit des Spielers unter 50
liegt, geben wir in der Konsole
an, dass die Gesundheit des
Spielers zu suchen ist. Wir haben unsere Ausgabe also hier
in der Unity-Konsole. Danke für die Sitzung. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
17. Verstehen von if-else-Aussagen in Unity C#: Hallo Freunde, mein Name ist Rohan
Dev und in dieser Sitzung
werden wir mehr über
Kontrollflussanweisungen in Unity lernen .
Scharf C. Wenn Statements
nach dem Zustand sucht. Und wenn die Bedingung wahr ist, wird der
Codeblock in der if-Anweisung ausgeführt. Aber was ist, wenn die
Bedingung falsch ist? In diesem Fall
wird der Code in der L-Anweisung ausgeführt. Die L-Anweisung teilt dem Kern mit, was zu tun ist, wenn
die Bedingung falsch ist. Auch hier haben wir eine
Variable vom Datentyp int deklariert,
was der Spielergesundheit entspricht, und der Wert ist auf 70 gesetzt. In der Startfunktion überprüfen
wir, ob
die Gesundheit der Spieler, der Wert der Spielergesundheit kleiner als 50
ist oder nicht. Wenn die Bedingung zutrifft,
geben wir an Gesundheit der
Spieler
in der Unity-Konsole zu niedrig ist. Und wenn die Bedingung
hier falsch ist, dann
wird die Gesundheit des Spielers ist gut in
der Unity-Konsole gedruckt. Leute, hier ist es.
Hier ist das Ergebnis, Gesundheit der
Spieler ist gut. Danke für die Sitzung. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
18. Verstehe If-Other-If-Leiter-Aussagen in Unity C#: Hallo Freunde. Mein Name ist Rohan
Dev und in dieser Sitzung werden wir mehr über
Kontrollflussanweisungen
in Unity C Sharp lernen Kontrollflussanweisungen
in Unity C Sharp Wenn die Ladder-Anweisung
nach jeder If-Bedingung sucht, werden
alle Anweisungen von oben nach unten
geprüft erste Bedingung
wird zuerst geprüft, dann
wird die zweite Bedingung geprüft, dann geht es weiter mit der dritten
und so weiter und so fort. Der Code in der
if-Anweisung wird ausgeführt, was als wahr
ausgewertet wird Nur der Code oder
der Codeblock innerhalb der if L-Anweisung
wird ausgeführt, was zutreffen wird Wenn keine der
if-Bedingungen
zutrifft, wird der letzte L-Block hier ausgeführt. Jetzt ist die Gesundheit des Spielers auf den Wert 50
gesetzt. In der Startfunktion haben
wir eine Wenn-Bedingung. Innerhalb der Wf-Bedingung überprüfen
wir, überprüfen
wir die Gesundheit des Spielers
größer als 80 und die Gesundheit des Spielers
kleiner oder kleiner
als 200 ist . Und wenn die Bedingung
zutrifft, drucken wir die Gesundheit des
Spielers als super aus. Wenn die Bedingung hier nicht
zutrifft, geht es hier
zur L-Anweisung über. Jetzt wird erneut geprüft, ob die Gesundheit eines
Spielers größer
als 60 ist und ob die Gesundheit des
Spielers kleiner
als 79 ist. Wenn die Bedingung hier erfüllt
ist, wird dieser
Codeblock ausgeführt. Andernfalls, wenn es falsch ist, der nächsten Aussage fortgefahren, die besagt, die Gesundheit des Spielers
größer als
40 und die Gesundheit des Spielers
kleiner als 59 ist . Auch hier
gilt: Wenn die Bedingung hier
zutrifft, wird der
Codeblock ausgeführt und die Gesundheit des Spielers ist schlecht wird in
der Unity-Konsole angezeigt. Wenn die Bedingung hier falsch ist, wird mit
der L-Anweisung fortgefahren. Und schließlich, wenn alle
Bedingungen hier zutreffen. Schließlich wird der Code
in der L-Anweisung, Gesundheit der
Spieler ist
in einem schlechten Zustand, in
der Unity-Konsole gedruckt. Lassen Sie uns nun den Code ausführen
und die Ausgabe sehen. In der Unity-Konsole, Spieler, ist die
Gesundheit nicht gut,
also hier ist sie. Hier ist die Ausgabe. Danke für die Sitzung. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
19. Verstehen von Switch-Case-Anweisungen in Unity C#: Freunde, mein Name ist Rohan Dev. In der letzten Sitzung haben wir
über
Entscheidungserklärungen gesprochen über
Entscheidungserklärungen In dieser Sitzung werden wir über Switch-Statements
sprechen. Was sind Switch-Anweisungen? Switch-Anweisungen
sind eine Alternative
zu FLSA-Ladder-Anweisungen Die Switch-Case-Anweisung ist
eine Auswahlanweisung. Hier ist die Syntax für eine
Switch-Case-Anweisung, bei der wir ein Switch-Schlüsselwort haben und dann den Ausdruck
in die Klammer setzen müssen, und dann haben wir Fälle. Jetzt wird der
Code- oder Anweisungsblock ausgeführt, wenn der Ausdruck mit einem der Groß- und
Kleinschreibung oder dem Ausdruckswert
übereinstimmt. Auch hier haben wir ein
Break-Schlüsselwort. Nun
wird diese Break-Anweisung verwendet, um
den Schalter zu verlassen , sobald der Ausdruck mit einem der Fälle
übereinstimmt Sobald der Wert für
den Ausdruck mit dem
Wert für den Fall
übereinstimmt, wird die Break-Anweisung
verwendet und der Switch wird beendet. Der Switch sucht weiterhin
nach allen Fällen,
bis die Break-Anweisung
gefunden wird oder der Switch beendet ist. Wenn nun keiner der Fälle
mit
dem Ausdruck übereinstimmt, wird der letzte Standard ausgeführt und der Codeblock innerhalb
des Standardfalls wird
gedruckt oder ausgeführt. Auch hier wird der Switch
im Standardfall mit
der Break-Anweisung beendet . Gehen wir nun in den Unity-Editor und
schreiben wir ein Stück Code. Jetzt Leute, wir sind hier im
Unity-Editor. Wir haben ein
leeres Spielobjekt erstellt. Wir haben auch
ein Shaft-Skript erstellt. Und der Name des
Skripts ist Switch Case. Lassen Sie uns das
Switch Case-Skript öffnen. Und schauen
wir uns die Codeseite an. Im Skript haben wir bereits eine Variable
deklariert, Gesundheit des
Spielers, und
der Wert ist auf 20 gesetzt. In der Startfunktion haben
wir bereits die Gesundheit der Spieler im
Switchcase deklariert. Hier ist ein Ausdruck, mit dem Case Ten überprüft
wird, ob der Wert der Gesundheit eines Spielers gleich zehn ist oder nicht. Wenn der Wert von Play
Health gleich Zehn ist, dann wird der Block von Core ausgeführt, bei dem
der Fall zehn ist wird in
der Unity-Konsole gedruckt und die Break-Anweisung
beendet den Switch. Wenn der Wert nicht mit dem Ausdruck
übereinstimmt, wird mit Fall 20
fortgefahren. In Fall 20 wird geprüft, ob der Wert von Flares Health
gleich 20 ist oder nicht Wenn der Wert von flares
health gleich 20 ist, dann
wird der Block von Core,
der Fall 20 ist, ausgeführt, in
der Unity-Konsole ausgegeben und die Break-Anweisung beendet
den Switch Wenn der Wert der Spieler nicht gleich 20 ist, wird
zum Standardfall übergegangen Und der Standardfall wird ausgeführt und
in der Unity-Konsole gedruckt. Schließlich beendet die Break-Anweisung
den Switch hier. Hier ist der
Ausgangsfall, 20 wird ausgeführt. Vielen Dank
für die Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
20. Schleifen in Unity C# verstehen: Hallo Freunde, Ich
heiße Rohan Vdv. In der letzten Sitzung haben wir
Switch-Statements gesehen. In dieser Sitzung
werden wir mehr
über Loop-Control-Segmente lernen . Also, was sind
Schleifensteuerungsanweisungen? Okay. Im Allgemeinen werden
Loop-Control-Segmente verwendet, wenn eine Anweisung
oder ein Codeblock mehrfach ausgeführt werden
soll. Auch hier hängt es von den auszuwertenden
Bedingungen ab. Die auszuwertende Bedingung
muss für
die Ausführung der Anweisungen oder des
Codeblocks innerhalb des Looks wahr Anweisungen oder des
Codeblocks innerhalb des sein.
Die Bedingung
muss also wahr sein, wenn Sie möchten, dass diese Anweisungen innerhalb der Schleifen
mehrfach ausgeführt werden Was sind die Arten
von Schleifen, die wir haben? Hier haben wir eine Y-Schleife, eine Y-Schleife und eine Y-Schleife. Schauen wir uns eine Y-Schleife an. Was ist eine Y-Schleife? Okay, die Bedingung wird am Anfang
der Schleife
angewendet. Variableninitialisierung erfolgt vor und außerhalb der Schleife Die Variable, die
Sie initialisieren werden,
befindet sich also außerhalb der Schleife und nicht
innerhalb der Schleife Jetzt wird der Codeblock
innerhalb der Schleife ausgeführt, bis die
Bedingung erfüllt ist Und sobald die Bedingung falsch
wird, wird die Schleife
verlassen oder beendet Hier ist die Syntax
für eine breite Schleife. Die erste ist die Initialisierung Ihrer
Schleifenvariablen. Hier initialisieren Sie die Variable, die sich
außerhalb der Y-Schleife befindet Dann haben wir eine Y-Schleife und dann haben wir eine Bedingung innerhalb der Klammern
für eine breite Schleife Jetzt haben wir innerhalb der Y-Schleife einen Codeblock, der ausgeführt werden muss, und sobald
der Kernblock ausgeführt ist, oder
dekrementieren
wir eine Schleifenvariable Gehen wir in den
Unity-Editor und
schreiben wir einen Code,
um eine Schleife auszuführen Okay Leute, ich bin hier
im Unity-Editor. Ich habe bereits
ein leeres Spielobjekt erstellt, das ein Kontrollfluss-Objekt ist. Und ich habe bereits
ein C Sharp-Skript erstellt. Ich habe das Skript Y Loop genannt. Außerdem habe ich dem
leeren Spielobjekt bereits
eine Skriptschleife angehängt . Lassen Sie uns das Skript hier öffnen. Okay, innerhalb des Skripts haben
wir bereits
eine Variable Health
vom Datentyp int deklariert , und der Wert ist auf fünf gesetzt. In der Startfunktion haben
wir auch eine
Schleife deklariert, in der wir
eine Bedingung haben , in der
wir überprüfen ob der Wert von health größer als Null
ist. Innerhalb der Y-Schleife drucken
wir den
Gesundheitswert, und sobald der
Gesundheitswert gedruckt ist, verringern
wir den
Gesundheitswert um eins Die Schleife wird
hier so lange laufen, bis
der Wert für Gesundheit eins wird Sobald der Wert für
Health Null ist, wird
die Schleife
beendet oder beendet Lassen Sie uns das Skript ausführen. Und sehen wir uns die Ausgabe hier an. Okay, hier ist die Ausgabe. Die Gesundheit der Spieler ist fünf, Gesundheit der
Spieler ist vier, Gesundheit der
Spieler ist drei, Gesundheit der
Spieler ist zwei und die Gesundheit der Spieler ist eins. Sobald wir den Wert
der Gesundheit auf eins gebracht haben, ist
die Schleife beendet Die Schleife ist hier beendet. Lassen Sie uns nun verstehen,
was vier Schleifen sind. Also, was sind vier Schleifen? Vierschleife ähnelt der der Y-Schleife mit einem
Unterschied in der Steuer und Initialisierung
einer Schleifenvariablen Testen eines Zustands, das
Inkrement und Dekrement einer Schleifenvariablen
erfolgen in einer einzigen Zeile Hier wird der Codeblock innerhalb
der Schleife
erneut ausgeführt , bis die Bedingung zwei ist Und sobald die Bedingung falsch
wird, wird die Schleife
innerhalb des For-Loop-Skripts beendet In der Startfunktion haben
wir eine vierfache Schleife, die
in den Klammern deklariert Für die vier Schleifen
haben wir bereits
eine Variable initialisiert , deren
Wert auf eins gesetzt ist Dann haben wir eine Bedingung,
in der wir prüfen ob der Wert von I
kleiner als fünf ist Andererseits wird der
Wert von I bei jeder Iteration um eins erhöht Innerhalb der Schleife führen wir eine Anweisung
aus. In diesem Fall
drucken wir nur den Wert von in der Unity-Konsole mithilfe
der
Debug-Punktsperrfunktion Lassen Sie uns den Code ausführen. Sehen wir uns die Ausgabe
hier an. Das war's Leute. Hier ist die Ausgabe für Loop. Das Spiel hat eins, zwei Punkte. Spiel hat drei Punkte und
Spiel vier ist vier. Sobald der Punktewert fünf ist, wird
die Schleife hier beendet
oder beendet. Okay, was ist eine Y-Schleife? Okay, die Y-Schleife
ähnelt der Y-Schleife, außer dass sie die Bedingung erst überprüft ,
nachdem
die Anweisungen ausgeführt wurden führt die Anweisungen mindestens einmal aus, bevor sie nach der Bedingung
sucht Jetzt haben
wir im Skript bereits eine Variable
deklariert,
Münzen, deren Wert auf eins gesetzt ist In der Startfunktion haben
wir eine Schleife deklariert. Innerhalb des Blocks
drucken wir den Wert
der Münzen. Sobald der Wert der Münzen in der Unity-Konsole
gedruckt ist, wird
der Wert der Münzen um eins
erhöht der
Y-Schleife wird geprüft,
ob der Wert der Münzen kleiner als Null
ist Wenn die Bedingung wahr ist, wird
sie wieder in den Zwei-Block aufgenommen und
der Codeblock wird ausgeführt. Wenn die Bedingung falsch ist, wird
die Schleife hier
beendet oder beendet Lassen Sie uns den Code ausführen
und uns die Ausgabe
in der Unity-Konsole ansehen Dafür ist hier die Anzahl der Münzen von Output
Guys, eins. Da die Bedingung falsch war, wird
die Schleife hier beendet. Das war's, Leute. Wir
sehen uns in der nächsten Sitzung. Ich danke euch vielmals, Leute.
21. Einführung in Sammlungen in Unity C#: Freunde. Mein Name
ist Ro und Sudev In dieser Sitzung werden
wir über
Sammlungen in Unity C sprechen .
Was sind Sammlungen Sammlungen sind
spezialisierte Klassen , die eine Reihe von Werten, Objekten
oder Elementen speichern . Mit Hilfe von Sammlungen können
wir
verschiedene Operationen ausführen. Was sind diese
Operationen, die wir mit Hilfe
von Sammlungsklassen
ausführen können ? Wir können Daten speichern, unsere Werte, wir können Daten aktualisieren, unsere Werte, wir können Daten löschen, unsere Werte, wir können sie abrufen und wir können sie auch sortieren. Was sind die Arten
von Sammlungen? Sammlungen werden
grundsätzlich
in zwei Sammlungsklassen eingeteilt , und zwar wie folgt:
generische Sammlungen und
nicht generische Sammlungen. Was sind generische Sammlungen? Generische Sammlungen
sind im
System definiert . Geben Sammlungen einen
generischen Raum ein. Wann immer wir
generische Sammlungen verwenden wollen, müssen
wir das
Namespace-System verwenden. Machen Sammlungen generisch, definiert durch eine Reihe von Schnittstellen
und Klassen. Interface ist eine
Blaupause für ein Generikum. Collections behandelt Daten
typsicher
und verhindert
Typkonflikte Was ist der Typ sicher? Type Safe bedeutet hier einfach, dass ein Datentyp keinem anderen Datentyp
zugewiesen werden kann. Hier sind einige generische
Sammlungsklassen. Erstens enthält Ihre Liste
Daten eines bestimmten Typs. Liste wächst automatisch Daten oder Elemente
hinzugefügt werden. nach der kurzen Liste sortierte Liste
speichert Daten immer in Schlüssel
- und Wertepaaren. Die Daten, die in
der sortierten Liste gespeichert
werden, befinden sich immer in Schlüssel-Wert-Paaren. Die Elemente werden in aufsteigender Reihenfolge
des Schlüsselwörterbuches hinzugefügt aufsteigender Reihenfolge
des Schlüsselwörterbuches Wörterbuch speichert Daten wieder in
Schlüssel-Wert-Paaren, aber die hinzugefügten Elemente werden nicht in der aufsteigenden Reihenfolge
des Schlüssels Q angezeigt. Was ist ein Q Werte werden nach dem Prinzip „zuerst
rein“ und „zuerst raus“ gespeichert. Was ist die
First-in-First-Out-Methode? Es bedeutet einfach, dass
die Elemente, die zuerst
hinzugefügt werden ,
zuerst abgerufen werden. Es gibt eine Q-Methode zum Hinzufügen von Werten
zur Q und eine DQ-Methode zum
Abrufen der Werte Wenn Sie die Q-Methode verwenden
, werden nicht nur die Werte abgerufen, sondern auch
die Werte aus
den nicht
generischen Sammlungen entfernt den nicht
generischen Sammlungen Nichtgenerische Sammlungen
sind
im System-Namespace für
Punktsammlungen definiert im System-Namespace für
Punktsammlungen Wenn wir nicht
generische Sammlungen verwenden wollen, müssen
wir
System-Sammlungen mit Punktpunkten als
Namespace innerhalb des Skripts angeben System-Sammlungen mit Punktpunkten als
Namespace innerhalb des Es kann jeden
Objekttyp verarbeiten, aber die Daten werden nicht typsicher behandelt
. Hier ist das der
Unterschied zwischen einer generischen Sammlung und einer
nicht generischen Sammlung. Generische Sammlungen
behandeln Daten
grundsätzlich typsicher. Nicht generische Sammlungen
behandeln Daten nicht typsicher. Hier sind einige nicht generische
Sammlungsklassen. Zuerst ist deine Arraylist. All speichert Objekte
eines beliebigen Datentyps und
wächst automatisch, wenn das Element
hinzugefügt Dann haben wir eine Hash-Tabelle. Hash-Tabelle speichert Daten
wieder in Schlüssel-Wert-Paaren Werte können durch
Hash-Werte der Schlüssel abgerufen werden. Dann haben wir Stack,
der die Werte in der Art Last In
und First Out speichert , was Ihrer Lifo-Manier entspricht. Was ist die Lifo-Manier? Lifo-Methode bedeutet einfach
, dass die Daten, die zuletzt
hinzugefügt werden , die
ersten Daten sind, die abgerufen werden Push-Methode wird hier erneut verwendet
, um einen Wert zu speichern, und Pop- und Peak-Methoden
werden verwendet, um
den
im Stapel gespeicherten Wert abzurufen den
im Stapel gespeicherten Wert Das war's für diese Sitzung.
In der nächsten Sitzung werden
wir uns einige generische
Sammlungsklassen
ansehen . Wir werden uns
eine Liste ansehen,
wie man eine Liste in Unity erstellt. Scharf C. Danke Leute. Wir
sehen uns in der nächsten Sitzung.
Ich danke dir vielmals.
22. List und seine Verwendung verstehen.: Hallo Freunde, mein Name
ist Rohan Vasudevn. In dieser Sitzung
werden wir
über Listen und darüber, wie
wir eine Liste erstellen,
sowie über einige der
wichtigen Aspekte
der Liste sowie über einige der
wichtigen Aspekte
der in Wir haben hier also bereits
eine Liste erstellt und der Name
der Liste lautet Playnames. Die Liste hat hier den
Datentyp Zeichenfolge, sodass alle Werte,
die wir der Liste
hinzufügen können , hier vom
Datentyp Zeichenfolge sein werden. Außerdem haben wir
die Liste mit
einem neuen Schlüsselwort in
der Startfunktion initialisiert einem neuen Schlüsselwort in
der Startfunktion Für Code eins fügen wir der Liste
die Werte
Dan und Sam hinzu , indem wir die Methode
add für die Liste verwenden die Werte Dan und Sam in der Liste kann
über den Index zugegriffen werden. Hier beginnt der Index einer Liste
immer bei Null. Für Code zwei geben wir den
Wert Dan aus, der den Index
Null hat, und den Wert Sam
, der an erster Stelle
in der Liste der Spielernamen steht. Auch für Code drei entfernen
wir den Wert am Nullindex
, der dein Dan ist. Wenn Sie den Wert
Dan aus dem nullten Index entfernen, wird
der Wert durch
den Wert am ersten
Index ersetzt , der Sam ist In diesem Fall
ersetzt Sam hier Dan, wenn wir Wert innerhalb der
Spielernamen an der Null am Index ausgeben In diesem Fall wird
Sam für
Code Nummer drei in
der Unity-Konsole gedruckt, wird
Sam für
Code Nummer drei in
der Unity-Konsole gedruckt wobei hier die
Bug-Punkt-Log-Funktion verwendet wird. Für Code vier
fügen wir am ersten Index einen Wert ein Wir fügen einen Wert ein,
Rachel, am ersten Index und verwenden hier die Insert-Methode für die Liste Für Code fünf drucken wir alle Werte aus der
Liste in einer Viererschleife Wir haben bereits eine Viererschleife
deklariert. Der Wert von I wurde mit einer Punktanzahl von null
Spielernamen
initialisiert Hier ist die Anzahl der Elemente in der Liste der Spielernamen und ich wurde hier bei jeder Iteration
um eins erhöht Wir geben hier dann
den Wert Sam aus, der ersten Iteration am nullten Index
befindet Und bei der zweiten Iteration drucken
wir dann den Wert
Rachel in der Unity-Konsole Sobald der Wert von I hier zwei
wird, wird
die Schleife
beendet und beendet Gehen wir in den
Unity-Editor und sehen uns die Ausgabe für den gesamten Code
in der Unity-Konsole Okay, hier ist es also. Hier sind die ausgegebenen
Druckwerte aus der Liste unter Verwendung des Index. Okay? Dan hatte anfangs den Index
08 und Sam
den ersten Index. Also drucken wir Dan
und Sam hier und drucken Werte aus der Liste, nachdem den Wert bei Index 08
entfernt haben. Da Dan aus der Liste
entfernt wurde, befindet Sam
jetzt auf dem Nullindex druckt
nun alle Werte
aus der Liste mit
Loop und Index Okay, das war's also, Leute. Das war's für die Liste hier. In der nächsten Sitzung werden
wir wieder mit der Sammlung
einiger generischer Klassen fortfahren . Ich danke dir vielmals.
Wir sehen uns in der nächsten Sitzung.
23. Verstehe Sortierte Listen und ihre Verwendung.: Hallo Freunde. Mein Name
ist Roan Masudev In der letzten Sitzung
haben wir über List gesprochen. In dieser Sitzung werden wir
über sortierte Listen sprechen. sortierte Liste enthält
alle Die sortierte Liste enthält
alle Elemente in
Schlüssel- und Wertepaaren. Die der Liste
hinzugefügten Elemente werden in aufsteigender Reihenfolge des Schlüssels In diesem Skript haben
wir bereits eine
sortierte Liste für Code eins deklariert Wir fügen der sortierten Liste Schlüssel- und
Wertepaare hinzu. In unserem Fall ist es die
Kernliste mit der Methode add Drei ist hier der Schlüssel und 100 ist der Wert
für den dritten Schlüssel. Für Code zwei drucken wir die Werte aus der
sortierten Liste mit Hilfe von Schlüsseln. Wenn wir hier einen Wert in
die Klammern setzen, erhalten
wir den Wert
für diesen bestimmten Schlüssel. Wenn wir die Funktion Bug Dot
Log verwenden, um die Punkteliste eins
innerhalb der Klammer zu drucken. Dann wird der Wert 200 in der Konsole
gedruckt. Auch hier
wird die Punkteliste drei
in den Klammern in
der Unity-Konsole 100 gedruckt. Hier für Code drei erstellen
wir hier einen Schlüssel, zwei, und weisen dem Schlüssel zwei den
Wert 150 zu Für Code vier verwenden wir
eine Inhaltsschlüsselmethode, um zu überprüfen, ob ein bestimmter
Schlüssel existiert oder nicht Und wenn der Schlüssel existiert, werden wir
einen Wert
dieses Schlüssels in der Unity-Konsole ausgeben. Für Code fünf
drucken wir alle Schlüssel und
Werte aus der sortierten
Liste und verwenden dabei für jede Schleife. Für jede Schleife wird grundsätzlich für alle Elemente, Schlüssel
und Werte in
der Punkteliste hier, unserer sortierten
Liste
,
iteriert und Werte in
der Punkteliste hier, unserer sortierten
Liste
, . Hier ist sie Hier ist die Ausgabe von
Druckwerten aus der sortierten Liste mit Hilfe von Schlüsseln. Wir haben die Werte
für die jeweiligen Schlüssel gedruckt. Schließlich haben wir alle Schlüssel und Werte
aus
der sortierten Liste gedruckt , wobei wir für jede Schleife
verwendet haben. Also hier ist die Ausgabe dafür, Schlüssel ist eins und Wert ist 200, Schlüssel ist zwei, Wert ist 150, Schlüssel ist drei und Wert ist 300. Das ist es. Das
war's für die Sitzung. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
24. Wörterbuch und seine Verwendung verstehen.: Hallo Freunde. Mein Name
ist Rohan Masugev In der letzten Sitzung haben wir über eine kürzere Liste
gesprochen. In dieser Sitzung werden wir über
das Wörterbuch sprechen. Wörterbuch speichert
Schlüssel-Wert-Paare, Schlüssel-Insider, Wörterbuch darf nicht
Null sein und muss eindeutig sein. Jetzt kann der Wert in
einem Wörterbuch Null
sein und
auch dupliziert werden In diesem Skript haben wir hier
bereits ein
Wörterbuch deklariert Der Datentyp für den
Schlüssel ist hier Zeichenfolge, und der Datentyp für den
Wert wird hier Zeichenfolge sein. Spielerdetails ist hier der Name
des Wörterbuches. Und wir haben auch
ein Wörterbuch mit einem neuen Schlüsselwort
in der Startfunktion initialisiert ein Wörterbuch mit einem neuen Schlüsselwort in der Startfunktion Für Code eins fügen wir Wörterbuchnamen
Schlüssel und Werte hinzu Hier ist der Schlüssel und Danny, hier ist der Wert
für den Schlüsselnamen Auch hier ist das Land der Schlüssel und USA hier der Wert
für das Schlüsselland Code zwei: Wir drucken die Werte im Wörterbuch
mit ihren Schlüsseln. Für Code drei
entfernen wir hier das Schlüsselland, indem wir die Methode remove
für das Wörterbuch verwenden. Für Code vier
drucken wir alle Schlüssel
und Werte aus dem Wörterbuch und
verwenden dabei für jede Schleife. Gehen wir also in
den Unity-Editor und lassen Sie uns den Code ausführen. Und sehen wir uns die Ausgabe hier an. Okay Leute, hier
ist die Ausgabe für den Code, der Werte aus
dem Wörterbuch mit Schlüssel druckt. Wir haben also unsere Ausgabe
als Danny und USA hier. Sobald dies erledigt ist,
entfernen wir das
Schlüsselland aus dem Code Und schließlich haben wir eine Ausgabe als Schlüsselname und Wert. Danny,
hier gibt es kein Land, weil wir das Land
bereits
aus dem Wörterbuch entfernt haben das Land
bereits
aus dem Wörterbuch entfernt Das war's Leute, vielen
Dank für die Sitzung. Ich werde dich in
der nächsten Sitzung sehen.
25. Verstehe ArrayList und seine Verwendung.: Hallo Freunde. Mein Name
ist Rohan Vasdev In der letzten Sitzung
haben wir über Q gesprochen. In dieser Sitzung werden wir über eine
ganze Liste sprechen Ery-Liste ist eine
geordnete Sammlung von Elementen eines beliebigen Datentyps Eralst wächst automatisch, wenn die Elemente
hinzugefügt werden Eryalist kann auch
doppelte Elemente enthalten. In diesem Skript
haben wir bereits
einen Eryallisten deklariert und der Name
der Aral-Liste ist meine Liste Wir haben auch
die Aral-Liste mit
einem neuen Schlüsselwort initialisiert die Aral-Liste mit
einem neuen Schlüsselwort und fügen der Liste zwei Elemente hinzu, Dan und John Nach der Initialisierung innerhalb der
Startfunktion im ersten Code drucken
wir alle Werte
aus der R-Liste mit a. Für jede Schleife haben wir hier
bereits eine
für jede Schleife deklariert,
die
über alle Elemente
in der
Array-Liste iteriert, also meine Liste darin. haben wir hier
bereits eine
für jede Schleife deklariert, die
über alle Elemente
in der
Array-Liste iteriert , also meine Liste darin Für jede Schleife drucken wir alle Elemente mit der Funktion
Rebug Dot Im Grunde werden damit
Dan und John in
der Unity-Konsole gedruckt Dan und John in
der Unity-Konsole In Code zwei fügen wir der Array-Liste
weitere Werte hinzu,
Sam und Tina, und verwenden dabei die
Methode add für die
Array-Liste in Code drei. Nach dem Hinzufügen
der Elemente drucken
wir erneut alle
Elemente oder Werte in
der Array-Liste und
verwenden dabei für jede Schleife. In Code vier entfernen
wir nun mit der Funktion remove at einen Wert
oder
das Element aus der Aral-Liste am
nullten Index mit der Funktion remove Im Grunde genommen haben
wir Dan hier, was den Eth-Index
Null haben
wir Dan Also streichen wir Dan
von der Very-Liste. Nachdem wir
Dan aus der Very-Liste entfernt
haben, fügen wir mit der Insert-Methode einen neuen Wert auf
dem nullten Index in die
Ery-Liste ein Jetzt drucken
wir in Code 6 alle Werte aus
der ERY-Liste, indem wir für jede
Schleife den Wert aus
dem Nullpunkt entfernen und einfügen Also hier ist es. Hier ist
die Ausgabe, die alle Werte des
Realisten ausgibt, die für jede Schleife verwendet Anfangs haben wir Dan und John
während der
Initialisierung zur Relist hinzugefügt während der
Initialisierung zur Wir drucken hier
Dan und John und drucken dabei alle Werte aus
der A-Liste mit einer für jede Nachdem wir weitere Werte hinzugefügt hatten, haben wir Sam und
Tina zur Liste hinzugefügt. Wir haben hier Dan, John, Sam und Tina. Zum Schluss drucken wir
alle Werte aus der Liste mit
einer für jede Schleife. Nachdem wir
einen Wert an der Null am Index entfernt und eingefügt hatten, haben wir Dan entfernt, der sich bei der Null am
Index
befand , und wir haben Jenny
und Null am Index hinzugefügt Hier ist die Ausgabe dafür. Wir haben Jenny, John,
Sam und Tina. Das war's also, Leute. Danke für die Sitzung. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
26. Hashtable und seine Verwendung verstehen.: Hallo Freunde. Mein
Name ist Rohan Dev In der letzten Sitzung
haben wir über eine Liste gesprochen. In dieser Sitzung werden wir
über Hash-Tabellen sprechen. In der Hash-Tabelle werden Daten oder
Elemente in Schlüsselwertpaaren gespeichert. Die Werte in der
Hashtabelle können mithilfe der
zugehörigen Schlüssel
abgerufen werden . Die der Hashtabelle
hinzugefügten Elemente
können denselben Datentyp oder einen
anderen Datentyp haben. Schlüssel in der
Hashtabelle können nicht Null sein, aber Werte in der
Hashtabelle können Null sein. Hash-Tabellenklasse implementiert Wörterbuchsammlung und
unzählige Schnittstellen In diesem Skript haben
wir bereits eine
Hashtabelle deklariert und der Name
der Hashtabelle ist Spielerdaten Wir haben die
Hashtabelle hier mit
einem neuen Schlüsselwort in
der Startfunktion initialisiert einem neuen Schlüsselwort in
der Startfunktion Für Code eins fügen wir Methode add
Schlüsselwertpaare zur
Hashtabelle hinzu Hier, Code zwei,
drucken wir einen Wert
für einen bestimmten Schlüssel. In diesem Fall drucken wir hier
den Wert für den Schlüsselnamen. Die Debug-Punktsperrfunktion
hier wird gedruckt und welcher Wert hier
für den Schlüsselnamen steht Für Code drei verwenden wir
Eye Collection, um
alle Schlüssel aus
der Hashtabelle abzurufen alle Schlüssel aus
der Hashtabelle Die Schlüssel werden mithilfe
von Punkttasten abgerufen. Für Code vier
drucken wir hier alle Schlüssel und Werte aus der Hashtabelle mit einer für jede Schleife.
Wir haben
hier bereits
eine für jede Lücke deklariert, die
im Grunde
alle Schlüssel innerhalb
der Hashtabelle durchläuft alle Schlüssel innerhalb
der All Keys ist eine Variable
oder ein Objekt, in dem alle Schlüssel hier
mithilfe von Eye Collection
in Code 3 gespeichert werden , wenn wir eine
Debug-Sperrfunktion verwenden In der für jede Schleife. Hier werden alle Schlüssel
gedruckt. Der Wert für jeden Schlüssel wird gedruckt, indem Spielerdaten verwendet werden, die deine Hashtabelle sind, und ein Schlüssel hineingelegt wird
, der in diesem Fall 45 ist. Hier entfernen wir
einen bestimmten Schlüssel. In diesem Fall entfernen wir
im Grunde eine Schlüsselstadt aus der Hashtabelle, indem Methode
remove für
die Hashtabelle verwenden. Für Code sechs
drucken wir alle
Schlüssel und Werte aus der Hashtabelle, drucken wir alle
Schlüssel und Werte aus der indem wir nach
dem Entfernen eines bestimmten Schlüssels eine
For-Each-Schleife verwenden. Gehen wir jetzt zum
Unity-Editor und drucken wir die Ausgabe. Okay Leute, hier ist es. Hier ist die Ausgabe
des Codes, der
einen Wert für den Schlüsselnamen
aus der Hashtabelle druckt . Der Wert für den
Schlüsselnamen ist also und in unserem Code. Also drucken wir, und hier drucken wir alle Schlüssel und
Werte aus der Hashtabelle. Im Grunde drucken wir also alle Schlüssel, den Schlüsselwert für die Stadt, New York, den Schlüsselnamenswert und den Schlüsselalterswert 18. Also drucken wir alle
Schlüssel und Werte hier in unserer Hashtabelle. Zum Schluss drucken wir
alle Schlüssel und Werte aus
der Hash-Tabelle,
indem wir
nach dem Entfernen eines bestimmten Schlüssels eine Futtersuche nach dem Entfernen eines bestimmten Schlüssels eine Wir haben ihn aus der
Hashtabelle entfernt und geben daher den Schlüsselnamen
und den Wert 18 für das Schlüsselalter Es gibt hier also keine Stadt,
da wir sie mit
der
Funktion remove für eine Hashtabelle aus der Hashtabelle entfernt haben . Das war's, Leute.
Danke für die Sitzung. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
27. Stack und seine Verwendung verstehen.: Hallo Freunde. Mein Name
ist Rohan Vasudeven Die letzte Sitzung, über die wir
gesprochen haben, hat einen Tisch. In dieser Sitzung werden
wir über Stack sprechen. Stack ist eine spezielle Art
der Sammlung, bei Daten oder Elemente
in Lifo-Manier
gespeichert Lifo bedeutet hier dauerhaft
und „first out“. Das Element, das zuletzt
hinzugefügt werden soll, ist das erste Element, das aus dem Stapel
abgerufen wird Okay, in diesem Skript haben
wir bereits
einen Stack deklariert und der Name
des Stacks ist mein Platz. Wir haben
den Stack mit
einem neuen Schlüsselwort in
der Startfunktion initialisiert einem neuen Schlüsselwort in
der Startfunktion Für Code eins fügen
wir dem Stack mithilfe
einer Push-Methode Werte
hinzu dem Stack mithilfe
einer Push-Methode Die Push-Methode wird also im Grunde verwendet, um dem Stack Werte hinzuzufügen. Also fügen wir hier Danny hinzu, dann fügen wir hier Sam hinzu Und schließlich fügen wir hinzu, und hier ist Andy
das letzte Element, oder der letzte Wert, der hier in Code zwei
hinzugefügt werden soll, wir drucken alle Werte innerhalb eines Stapels mit
a für jede Schleife, wir haben bereits
a für jede Schleife deklariert Dafür und innerhalb
der For-Each-Schleife verwenden
wir die
Debug-Punktlog-Funktion , um alle
Werte innerhalb eines Stapels zu drucken Dies
wird für jede Schleife grundsätzlich gedruckt und zwar zuerst, weil der Stack auf Lifo-Art funktioniert
, zuletzt rein und zuerst raus, und ist das letzte hinzugefügte Element Es wird also gedruckt und zuerst, dann wird Sam gedruckt, und zuletzt wird es Danny drucken Hier in Code drei rufen
wir mit der Peak-Methode
den letzten Wert ab, der einem
Stapel hinzugefügt wurde, und drucken der einem
Stapel hinzugefügt wurde, Peak-Methode gibt das letzte
Element im Stapel zurück, entfernt das Element
jedoch nicht Sie entfernt den Wert nicht, daher wird
der Wert hier nur abgerufen. Okay, jetzt verwenden
wir in Code vier eine
Pop-Methode, die den zuletzt zum Stapel
hinzugefügten Wert
zurückgibt , aber auch den zuletzt zum Stapel
hinzugefügten Wert
entfernt. Okay, in Code fünf drucken
wir also
alle Werte in
einem Stapel, drucken
wir also
alle Werte in nachdem wir
die Pop-Methode verwendet haben. Jetzt mit einer Pop-Methode. In Code vier haben wir
hier den Wert und aus dem Stack entfernt . Sobald wir
das für jede Schleife ausgeführt
haben, werden wir Danny und
Sam hier in der Unity-Konsole drucken , da Andy im Code 4
abgerufen und
aus dem Stack entfernt wurde im Code 4
abgerufen und
aus dem Stack Gehen wir nun in
den Unity-Editor und sehen uns die
Ausgabe für diesen Code Also hier ist es. Hier
ist die Ausgabe, der alle
Werte in einem Stapel
gedruckt werden. Also drucken wir
Und Sam und Danny, wie ich bereits sagte Okay, Stack funktioniert
wie Lifo,
also Andy war das letzte
Element, das zuerst hinzugefügt wurde, also wird es das erste
Element sein, das Also, wir haben abgerufen und hier zuerst drucken wir Sam und zuletzt
drucken wir Danny hier Okay, rufen Sie den letzten Wert ab, der
einem
Stapel hinzugefügt wurde, und drucken Sie ihn mit der Peak-Methode Also, auch hier
rufen wir das letzte Element ab, das dem Stapel
hinzugefügt wurde, den letzten Wert, der dem Stapel hinzugefügt wurde, nämlich Andy, und
wir drucken es Jetzt drucken wir schließlich alle Werte in einem Stapel,
nachdem wir die Pop-Methode verwendet Also haben wir eine Pop-Methode verwendet und
das letzte Element entfernt, das letzte Element
abgerufen und entfernt und alle verbleibenden
Werte in einem Stapel gedruckt. Also das war's, Leute. Das war's für die Sitzung. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
28. Einführung in die Benutzeroberfläche in Unity und erstelle eine Leinwand: Freunde, mein Name ist Rohan. Wie heute werden wir
über Unity sprechen. Uy, Unity UI
wird in einfachen Worten zum Entwerfen und Erstellen von
Benutzeroberflächen für
Spiele und Anwendungen verwendet . In dieser Sitzung werden
wir speziell über
eine der Komponenten
von Unity UI sprechen , nämlich Ihre UI-Canvas. Also, was ist Canvas? Canvas wird als Spielobjekt mit
einer daran angehängten
Canvas-Komponente erstellt . Wenn Sie also
eine Leinwand in Unity erstellen, wird
sie immer
als Spielobjekt erstellt das eine
Canvas-Komponente angehängt wird. Die Leinwand wird in der Szenenansicht als
Rechteck angezeigt. jede Leinwand wird
eine Transformationskomponente
angehängt. Alle anderen UI-Elemente
sollten sich innerhalb einer Leinwand befinden. Canvas wird immer
oder sollte
von allen anderen UI-Elementen
oder UI-Komponenten deutlich sichtbar sein . Alle Elemente innerhalb
der Zeichenfläche werden
in der Reihenfolge gezeichnet , in der sie
in der Hierarchie erscheinen. Jetzt gibt es drei
Rendermodi für die Leinwand. Da ist zunächst Ihr Screen
Space Overlay, bei dem die UI-Elemente auf dem Bildschirm oben in
der Szene gerendert Das ist im Grunde wie ein Overlay-Bildschirm am
oberen Bildschirmrand Kamera-Leinwand wird in
einem bestimmten Abstand von
der
skalaren Komponente der Kamera-Leinwand platziert der
skalaren Komponente der Kamera-Leinwand Es steuert einfach den Maßstab und Pixeldichte
der UI-Elemente Grünkohl ist deine Größe. Pixeldichte ist die Anzahl
der Pixel in einem bestimmten Bereich, hauptsächlich für die UI-Elemente. Jetzt sind einige Skalierungsmodi in der
skalaren Komponente Canvas
verfügbar Da ist zunächst Ihre
konstante Pixelgröße. Die Größe
der UI-Elemente in Pixeln bleibt hier unabhängig
von der Bildschirmgröße
konstant. An zweiter Stelle steht Ihre Skala. Bei Bildschirmgrößenskalen die UI-Elemente auf
größeren Bildschirmen die auf
der Leinwand platzierten UI-Elemente entsprechend der Bildschirmgröße skaliert. Hier, wenn Sie die skalare
Canvas-Komponente wählen. Schließlich haben wir eine
konstante physische Größe. Die physische Größe
der UI-Elemente bleibt unabhängig
von der Bildschirmgröße
konstant. Ich bin hier im Unity-Editor. Wir haben bereits eine Szene erstellt, und der Name
der Szene ist UIC Lassen Sie uns hier eine
Canvas-Komponente erstellen. Wie machen wir das?
Klicken Sie mit der rechten Maustaste auf die UI-Szene und
wählen Sie Game Object und dann UI hier aus. In der Benutzeroberfläche
müssen wir hier Canvas auswählen. Okay, und das war's. Unsere Canvas-Komponente hier
wird der Szene hinzugefügt. Wir werden
hier nichts sehen können , da wir
keine Elemente hinzugefügt haben. Im Grunde
wird dies
allen anderen UI-Elementen wie
Textfeldern und
Schaltflächen usw. übergeordnet allen anderen UI-Elementen wie sein. Wir haben eine
W-Transformationskomponente
automatisch angehängt oder
automatisch zur Leinwand hinzugefügt angegebenen Bereich
oder auf der Leinwand platziert der Transformation von Spielobjekten werden
im Grunde
alle anderen UI-Elemente
im . Okay, wie wir alle hier sehen können, gibt es
wieder einige Werte, die von der Leinwand
bestimmt werden. Das ist also eine nicht
editierbare Rec-Transformation. Wir können sie
momentan nicht bearbeiten, weil wir mehr auf
Screen Space Overlay oder
Screen Space Camera rendern , dann können wir
die Canvas-Rec-Transformation nicht bearbeiten. Aber wenn wir
es in den Weltraum ändern
, können wir die Transformation hier ändern oder modifizieren Okay, dann haben wir hier
Canvas Scaler. Zuerst ist da deine
konstante Pixelgröße. Dann haben wir die Skalierung der Bildschirmgröße und wir haben eine konstante
physische Größe. Wir sehen uns in
der nächsten Sitzung mit weiteren UI-Komponenten.
Ich danke dir vielmals.
29. UI-Text und Komponenten: Hallo Freunde, mein Name
ist Rohan. In der letzten Sitzung haben wir
über UI Canvas Unity gesprochen In dieser Sitzung werden
wir über UI Text Unity sprechen. Was ist also UI Text
Unity? Sehr einfach. Es zeigt dem Benutzer eine Information
oder einen Text an
, der im Allgemeinen
nicht interaktiv ist. diesen Informationen
kann es sich um eine Punktzahl, eine Gesundheit, Anzahl der Münzen usw. handeln,
die in der Regel mit
uYext angezeigt werden Im Spiel oder in einer
C-UI
wird eine Textkomponente an ein Spielobjekt angehängt Das heißt, wenn Sie
eine UI-Textkomponente erstellen, wird
ein Spielobjekt erstellt, an das die UI-Textkomponente angehängt
ist. Jetzt gibt es eine Summe
von Eigenschaften für ein Textelement I, ein Textelement Diese sind die Schriftart,
die vom Text verwendet wird, die Schriftart,
die vom Text verwendet wird. Die Schriftgröße, die die Größe des
Stils oder den Stil
angibt , der vom Text verwendet
wird, ist der Wert, den die
Textkomponente anzeigt. Der Zeilenabstand ist Art,
Schriftart, Zeilenhöhe. Und Ausrichtung ist die Positionierung
des Textes in der Mitte,
Mitte, oben und unten. Okay, jetzt gehen wir in
den Unity-Editor und
erstellen wir ein
UI-Textelement in Unity. Okay Leute, ich bin
im Unity-Editor. Und um UI-Text zu erstellen, ist
es ähnlich, wie wir Unity Canvas
erstellt haben. Klicken Sie hier mit der rechten Maustaste auf die Benutzeroberfläche
und gehen Sie zu Game Object. Und wähle UI. Und wählen Sie hier Ihr
Textelement aus. Hier ist es. Ihr Text ist erstellt. Wir können also hier Text auf
dem Bildschirm sehen. Das ist also ein
Textspielobjekt, für
das hier eine Rec-Transformation
verwendet wird, die editierbar ist Wir können die
Position entsprechend ändern. Jetzt
wird an das Textspielobjekt Komponententext angehängt. Jetzt können Sie hier sehen,
hier können wir den Text
einfügen. Okay, im Moment ist es neuer Text. Lassen Sie uns hier einen langen Text einfügen. Versuchen wir,
es so zu ändern, dass wir den gesamten Inhalt sehen
können. Der Schriftstil ist normal. Wir können ihn in fett,
kursiv, fett und kursiv ändern . Lassen Sie es uns hier in fett ändern. Dann können wir die Schriftgröße erhöhen oder
verringern. Lass es uns hier auf 18 ändern, okay, es ist größer geworden. Nun, im Absatz,
das ist die Ausrichtung, an der
wir den Text ausrichten können. Halte es grundsätzlich in der Mitte. Dieses Rechteck, das
Sie hier sehen können, ist die Transformation für das Textfeld. Dann haben wir einen
horizontalen Überlauf. Hier haben wir einen langen Text und wir können
den Text,
den gesamten Text gerade nicht sehen den gesamten Text gerade Es ist umgebrochen, wir können es so
ändern, dass es überläuft, aber wir können es trotzdem
nicht sehen Was wir tun können, ist, hier zu klicken und die Transformation
für das nächste Mal zu
erhöhen Lassen Sie uns das hier beibehalten und erhöhen wir das. Erhöhen wir das
entsprechend unserem Text. Lassen Sie uns hier die
Textfarbe ändern. Lass es uns auf Rot belassen. Hier ist es. Das war's, Leute.
Danke für die Sitzung. In der nächsten Sitzung werden
wir über die
UI-Image-Komponente in
Unity sprechen . Ich danke dir vielmals.
30. UI Bild und Komponenten: Hallo Freunde. Mein Name
ist Rohan Vasudev In dieser Sitzung werden
wir über die
UI-Image-Komponente in Unity sprechen UI-Image-Komponente in Unity Was ist eine UI-Image-Komponente? UI-Bildkomponente zeigt dem
Benutzer
ein Bild auf dem Bildschirm an. Ui-Bildkomponente
kann als
Symbolhintergrund für die
Textkomponenten usw. verwendet werden . Es gibt also verschiedene
Szenarien, in denen die UI-Bildkomponente verwendet werden kann Für das UI-Bild muss Quellbild oder der Textur
um ein Sprite handeln Das Quellbild oder das Bild
für die Bildkomponente
muss also ein Sprite sein Was ist ein Sprite? Sprite ist ein einfaches zweistufiges Objekt
mit Texturen darauf Jetzt gibt es einige Eigenschaften
für eine UI-Image-Komponente Was sind diese Eigenschaften? Quellbild,
Quellbild ist im Grunde das Bild,
das in Form einer
Textur oder eines Sprites angezeigt werden soll das in Form einer
Textur oder eines Sprites Dann haben wir noch eine weitere
Eigenschaft, nämlich Farbe. Farbe gibt die Farbe an, die auf das Bild
angewendet wird. Dann haben wir Material. Material ist das Material, das zum Rendern des Bildes
verwendet wird. Seitenverhältnis beibehalten, Seitenverhältnis
beibehalten, das Seitenverhältnis oder die tatsächlichen Abmessungen des
Bilds werden in der ursprünglichen Größe Dadurch werden die Abmessungen
der Bildaufnahmetransformation an die tatsächliche
Pixelgröße der Textur angepasst Dann haben wir noch eine weitere Eigenschaft für die Bildkomponente der Benutzeroberfläche, nämlich den Bildtyp. Bildtyp gibt an, wie das Bild
auf dem Bildschirm angezeigt wird. Es gibt vier
Bildtypen, die verwendet werden können. Zuerst ist dein einfacher. Bei diesem Bildtyp werden die
Bilder so gestreckt, dass sie
der Transformation
der Bildkomponente oder dem Bild entsprechen . We have sliced gibt ein geschnittenes Bild für rechteckige Elemente
oder dekorierte Boxen Dann haben wir ein gekacheltes Bild mit
der Wiederholung von Sprites. Die Sprites oder die Texturen wiederholen
sich. Wenn wir den
Bildtyp auswählen, der gekachelt werden soll. Schließlich
haben wir einen gefüllten Typ , bei dem es sich um ein Teilbild handelt, das im Allgemeinen für Ihren
Countdown, Timer usw. nützlich ist. Okay, jetzt gehen wir in den Unity-Editor und
erstellen wir eine UI-Image-Komponente Hier ist es, Leute. Ich bin
hier im Unity-Editor. Lassen Sie uns unsere Image-Komponente
hier im C erstellen . Okay,
wie machen wir das? Klicken Sie hier mit der rechten Maustaste
auf die UY-Szene, gehen Sie zu Game Object, wählen Sie hier UI und
klicken Sie auf Image. Hier. Wir haben unsere
Bildkomponente in der Szene erstellt. Im Moment ist es leer
, da wir hier
kein
Quellbild angehängt haben . Dieses Quellbild muss
ein Sprite sein , um
ein Quellbild anzuhängen Lassen Sie uns ein
Sprite in Unity erstellen. Wie machen wir das? Lassen Sie uns hier einen Ordner
erstellen, klicken Sie
einfach mit der rechten Maustaste hier, in den Acts, und
gehen Sie zu Hier erstellen. Und klicken Sie auf Ordner. Okay, lass uns den Ordner
in Sprites umbenennen und einfach den Ordner
öffnen Dies ist das Bild, das
wir verwenden werden. Lassen Sie uns
dieses Bild einfach per Drag & Drop in den
Sprites-Ordner hier Ziehen Sie das Bild einfach per Drag &
Drop hierher. Okay? Im Moment ist
dieses Bild standardmäßig ein Bildformat, also müssen wir es in
ein Sprite-Format ändern . Also,
wie machen wir das? Klicken Sie hier auf Standard und wählen Sie hier Sprite to
D und U, Y. Und klicken Sie hier auf Anwenden. Okay, wir haben unseren Sprite
erstellt. Lassen Sie uns dieses Sprite an die
Bildkomponente anhängen. Klicken Sie also erneut auf Image
Component. Okay, und klicken Sie hier. Und wähle das hier aus, was jetzt ein Sprite ist Okay, und das war's. Wir können sehen, wie unsere UY-Bildkomponente in der Szene
hinzugefügt wurde. Dann haben wir hier den
Aspekt beibehalten. Seitenverhältnis
beibehalten“ werden tatsächlich die ursprünglichen
Abmessungen des Bildes beibehalten. Ändern wir die Breite auf 150. Okay? Im Moment sieht es
nicht gut aus, es sieht ein bisschen gestreckt aus. Wenn Sie hier die Option „Seitenverhältnis
beibehalten“ wählen, werden die tatsächlichen
Abmessungen des Bilds zurückgegeben. Schauen wir uns hier also an, was
native Größe ist. Das ist eine Neutransformation
für das Bild. Sobald wir also auf
diese native Größe klicken, wird die Transformation,
dieses Rechteck hier, auf
die tatsächliche
Pixelgröße der Textur zurückgesetzt oder
geändert dieses Rechteck hier, auf . Okay, also lass uns hier einfach auf „Native Größe
festlegen“ klicken .
Okay, und das war's. Es hat die
direkte Transformation an
die tatsächliche
Pixelgröße der Textur angepasst . Das war's also, Leute, das war's für die Bildkomponente hier. Wir sehen uns in
der nächsten Sitzung mit der UI-Button-Komponente. Ich danke euch vielmals, Leute.
31. UI-Schaltfläche und Komponenten: Hallo Freunde. Mein
Name ist Rohan Dev In dieser Sitzung werden
wir über die Immunität
von UI-Tasten sprechen Immunität
von UI-Tasten Was ist Immunität gegen UI-Tasten? Es handelt sich um eine interagierbare
Elementimmunität , die auf das Klicken
des Benutzers reagiert Es wird verwendet, um eine Aktion in
der Szene oder einem Spiel auszuführen oder zu
initiieren angehängt Wenn Sie eine Tastenimmunität einrichten, wird standardmäßig eine Bildkomponente an die
Schaltfläche Eine Bildkomponente ist
immer an diese Schaltfläche angehängt. Sie können also ein beliebiges Bild auf
die Schaltfläche Ihrer Wahl anwenden. Was sind also die Eigenschaften
eines Button-Elements? Erstens, ist Ihr interaktives Element,
das angibt, ob die
Schaltfläche anklickbar ist oder nicht Dann gibt es den Übergang
, der den Prozess des
Wechsels von einem
Zustand in einen anderen spezifiziert Wechsels von einem
Zustand in einen anderen Okay, wenn Sie also auf die Schaltfläche
tippen oder auf die Schaltfläche
klicken, ändert sich
der Status der Schaltfläche. Und diese Zustände können Ihr Normalzustand
sein,
Ihr hervorgehobener Zustand
gedrückt und Ihr deaktivierter Status sein. Für den
Übergang gibt es vier Optionen . Was
sind diese Optionen? An erster Stelle steht deine Nonne. Dann haben
wir hier Farbe Zehn. Dann haben wir hier Sprite Swap. Und schließlich haben wir Animation. Lassen Sie uns nun nacheinander sehen, was diese Optionen für
Übergänge im Grunde bedeuten. Keiner wird keinen Einfluss
auf den Zustandswechsel haben. Sie hat keine
Auswirkung auf die Taste, grundsätzlich immer dann, wenn die
Taste gedrückt wird oder wenn die Taste
deaktiviert ist oder wenn die
Taste markiert ist. Dann haben wir einen Farbton, der
die Farbe der Taste mit
der
Änderung des Status ändert Taste mit
der
Änderung des Status Wir können hier also verschiedene Farben für verschiedene Staaten verwenden, Sprites, verschiedene Sprites können für jeden einzelnen
Status angezeigt werden Wir können hier also
unterschiedliche Sprites
für jeden einzelnen Bundesstaat anwenden für jeden einzelnen Schließlich haben wir hier einen
Animationsübergang. Animationen können
je nach
Status der Schaltfläche abgespielt werden , sodass wir je
nach Status Animationen auf
die Schaltfläche anwenden können . eine Schaltfläche muss immer eine Animator-Komponente
angehängt , damit der
Animationsübergang funktioniert Okay, jetzt gehen wir in den Unity-Editor und
erstellen wir eine UI-Schaltfläche in Unity Okay Leute, hier bin ich
im Unity-Editor. Und lassen Sie uns
hier eine Schaltfläche erstellen, um eine Schaltfläche zu erstellen. Klicken Sie einfach mit der rechten Maustaste
auf die UI-Szene, okay? Und gehe einfach zu Game Object und wähle dann UI hier aus. Und dann klicken Sie hier auf die Schaltfläche. Okay, wir haben unseren
Button hier erstellt, wie wir alle
hier auf dem Bildschirm sehen können. Schauen wir uns nun an,
welche Elemente hier an das
Button-Spielobjekt
angehängt sind. Erstens wird es eine Rec-Transformation
sein , die hier
standardmäßig angehängt wird. Okay, dann haben wir
eine Bildkomponente , die angehängt wird
, wenn wir eine Schaltfläche erstellen. Gehen wir nun zur
Button-Komponente, hier haben wir eine
interaktive Eigenschaft, die gerade überprüft wird Lass uns das Okay ausführen. Im Moment können wir hier auf die Schaltfläche
klicken, und es ist im Grunde eine anklickbare
Schaltfläche Okay, lassen Sie uns das einfach deaktivieren. Und der Button ist hier deaktiviert. Wir können hier nicht auf die
Schaltfläche klicken, okay? Dann haben wir die
Übergangseigenschaft, die es
vier Optionen gibt: Keine, Farbe, Farbton, Sprite
Swap und Animation Wenn Sie keine auswählen
, bedeutet das einfach, dass die Schaltfläche
keine Auswirkung auf die
Statusänderung hier hat, okay? Aber standardmäßig ist hier der Farbton
eingestellt. Lassen Sie uns
also versuchen, hier herauszufinden,
was ein Farbton ist Okay, Zielgrafik. Zielgrafik bedeutet einfach das Bild, das hier
auf die Schaltfläche gesetzt ist. In diesem Fall
wurde dieses Bild auf die Schaltfläche hier gesetzt. Dann haben wir normale Farbe. Normale Farbe ist
im Grunde die Farbe, die
auf die Taste angewendet wird, wenn
der Zustand der Taste normal ist, wenn sie nicht gedrückt
oder hervorgehoben Im Grunde
ist sie derzeit weiß. Lassen Sie uns die normale
Farbe der Taste ändern. Behalten wir die gelbe Farbe bei. Okay? Die hervorgehobene Farbe ist im Grunde genommen, wenn Sie hier mit der Maus
auf die Schaltfläche Lassen Sie uns diese
Farbe in Rot ändern Okay? Und drückte den Status , als du tatsächlich auf die Schaltfläche
klickst. Derzeit ist es grau. Also lass
es uns auf diese Farbe ändern. Okay. Und die gewählte Farbe ist im Grunde genommen, wenn
sich die Schaltfläche im ausgewählten Zustand Lassen wir sie auf Weiß stehen. Okay? Und deaktivierte Farben sind, wenn die Schaltfläche nicht interaktiv
ist,
im Grunde genommen, wenn Sie dieses Ding
deaktivieren Dann haben wir hier endlich eine
On-Click-Funktion. Okay? Die On-Click-Funktion
ist eine Unity-Funktion, die ausgelöst wird, wenn die
Taste hier gedrückt wird. Auf die
Einzelheiten werden wir in den kommenden Sitzungen eingehen, wenn wir
mehr über Ereignisse,
Auslöser und
Funktionen in Unity erfahren werden. Im Moment
befindet sich die Schaltfläche also im Normalzustand. Im Normalzustand hat
die Schaltfläche eine gelbe Farbe. Okay?
Die hervorgehobene Farbe hier ist rot. Wenn ich also hier mit
der Maus auf die Schaltfläche
fahre, wird die Farbe der Schaltfläche rot Okay, dann gedrückt, die
Farbe ist rosa. Also, wenn ich auf die Schaltfläche klicke, okay, du kannst hier sehen, dass
sie rosa wird. Und sobald ich die Taste verlasse oder den Klick verlasse, wird sie
weiß, weil das ein ausgewählter
Status der Schaltfläche ist. Okay, hier wird es weiß. Und wenn Sie hier eine
Button-Komponente erweitern, okay, oder das Button-Spielobjekt hier, innerhalb des Button-Spielobjekts, haben
wir ein Textspielobjekt. Okay, wo wir den Text tatsächlich auf die Schaltfläche
anwenden können. Im Moment ist die Schaltfläche „Text ist“, sodass wir ihn in „Senden“
oder in den Text unserer Wahl ändern können. Okay. Der Text auf der Schaltfläche
ändert sich zu Senden. Hier. Das war's, Leute. Danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
32. UI-ScrollAnsicht und Komponenten: Hallo Freunde, mein Name
ist Rohan Vase. In dieser Sitzung
werden wir über die
UY-Scroll-Ansicht in Unity sprechen UY-Scroll-Ansicht in Unity Was ist die UY-Scroll-Ansicht? Die Uy-Scroll-Ansicht wird
verwendet, um
Inhalte in einem
scrollbaren Rahmen anzuzeigen . Es wird im Allgemeinen verwendet
, wenn ein großer Inhalt in
einen kleinen Bereich einer Szene eingefügt werden
muss. Eine Scroll-Ansicht besteht aus einem Scroll-Wrack und einer daran
angehängten Bildkomponente Wenn du ein Spielobjekt mit
Scroll-View-Ansicht erstellst, standardmäßig ein Scroll-Wrack und eine Bildkomponente daran
angehängt Ein Scroll-Wrack bietet
Funktionalität, das
Scrollen über den Inhalt, was viel
Platz beansprucht und in
einem kleinen
Bereich in einer Szene platziert werden muss einem kleinen
Bereich in einer Szene platziert Nun gibt es einige wichtige
Elemente in einer Scroll-Ansicht. Zuerst ist dein Viewport. Viewport ist das untergeordnete Element
des Root-Spielobjekts
, also der Scroll-Ansicht Es handelt sich um eine Rec-Transformation
, die eigentlich als Fenster zum Inhalt auf
Scroll-Ebene
fungiert Jetzt ist die Maskenkomponente an das Viewport
angehängt ,
um jegliche Inhalte
außerhalb des Viewports auszublenden Dann haben wir zweitens Inhalt. Der Inhalt ist ein untergeordnetes Element
des Viewport-Spielobjekts Die
Inhaltskomponente, in der wir den
gesamten scrollenden
Inhalt haben werden . Im Grunde genommen befindet sich der
Inhalt, den wir in eine Scroll-Ansicht
einfügen, in Ihrem Inhalt, Spielobjekt oder Ihrer
Inhaltskomponente Die Größe der
Inhaltskomponente muss so erweitert werden, dass sie in den
gesamten scrollbaren Inhalt passt . Nur wenn der Inhalt größer
als der Viewport ist,
funktioniert der
Scroll-Effekt Nehmen wir also an, der Inhalt ist
kleiner als das Viewport, dann funktioniert der Scroll-Effekt überhaupt
nicht, also muss er größer als Ihr Viewport sein Dann haben wir Scrollbälle. Hier gibt es zwei Arten
von Bildlaufleisten, horizontale und
vertikale Bildlaufleisten sind
dem Root-Game-Objekt untergeordnet,
das Ihr
Scroll-View-Spielobjekt ist Auch hier werden sie verwendet, um das
horizontale und
vertikale Scrollen
für die Scrollleistenelemente zu definieren horizontale und
vertikale Scrollen
für die Scrollleistenelemente für horizontale Bildlaufleiste
wird also verwendet, um das
horizontale Scrollen zu definieren, und die vertikale Bildlaufleiste wird
verwendet, um das
vertikale Scrollen zu definieren Wie erstelle ich eine
dynamische Scroll-Ansicht? Jetzt wird der scrollbare Inhalt innerhalb der
Inhaltskomponente
hinzugefügt Okay, also welche Objekte
wir auch hinzufügen werden, sie werden sich alle in
der Inhaltskomponente befinden Die Größe der
Inhaltskomponente oder des Spielobjekts
ist
standardmäßig größer als der Hauptteil der Scroll-Ansicht und kann nach Bedarf
geändert werden. Nun, das passt perfekt für den Inhalt
auf statischer Scroll-Ebene, wenn wir genau wissen, wie viel
Inhalt im Grunde in der
Scroll-Ansicht enthalten sein
wird . Aber was ist, wenn wir nicht wissen wie viel Inhalt da sein
wird? Was ist, wenn der Inhalt
zur Laufzeit hinzugefügt wird? Was dann? Dann passt die Inhaltskomponente
ihre Größe nicht entsprechend an und der
Inhalt außerhalb des Inhaltsbereichs
ist nicht sichtbar. Daher kann die Größe der
Scroll-Ansicht
dynamisch geändert werden ,
indem der Inhaltskomponente zwei Elemente hinzugefügt werden. Und was sind diese Elemente? Dies sind Ihre
vertikale Layoutgruppe. Was ist eine vertikale Layoutgruppe? vertikale Layoutgruppe wird verwendet , um untergeordnete Elemente
untereinander anzuordnen. Okay? Untereinander. Der scrollbare
Inhalt wird hier vertikal
untereinander
platziert. Dann haben wir die horizontale
Layoutgruppe. horizontale
Layoutgruppe wird verwendet, um untergeordnete Elemente
nebeneinander anzuordnen. Der scrollbare Inhalt wird
hier grundsätzlich horizontal
nebeneinander
platziert Okay? Und dann
haben wir endlich Content Size Fitter Was ist Content Size Fitter? Der wichtigste Aspekt dabei ist, passende
Inhalt
die Größe der angeschlossenen
Rec-Transformatoren bestimmt Okay, dieser
Inhaltsgrößenanpasser wird also im Grunde zu Ihrer
Inhaltskomponente oder Ihrem Spielobjekt
hinzugefügt Tatsächlich wird sogar die
vertikale Layoutgruppe oder die
horizontale Layoutgruppe Ihrem Inhalt, Ihrem
Spielobjekt oder Ihrer
Inhaltskomponente
hinzugefügt oder sollte hinzugefügt werden Spielobjekt oder Ihrer
Inhaltskomponente
hinzugefügt oder Inhaltsgrößenanpasser bestimmt die Größe
der
Rec-Transformation, an die er angehängt ist, auf der
Grundlage
des Layouts der untergeordneten Objekte Es funktioniert nur in Kombination
mit einer Layoutkomponente wie Ihrer vertikalen
Layoutgruppe oder horizontalen Layoutgruppe Man kann sagen, dass der Inhaltsgrößenanpasser
eine horizontale Passform hat , die bevorzugte Größe für horizontale Layoutgruppen So können wir die horizontale Anpassung
auf die bevorzugte Größe für
Inhaltsgrößenanpassungen einstellen . Dies ist also eine Eigenschaft
für die Anpassung der Inhaltsgröße , die auf die bevorzugte Größe
eingestellt werden kann Dadurch wird die ID grundsätzlich
erhöht, wenn
mehr untergeordnete Objekte hinzugefügt werden und welche für alle geeignet ist.
Das war's also, Leute. Wir sehen uns in
der nächsten Sitzung. In der nächsten Sitzung
werden wir ein Beispiel für eine Scroll-Ansicht mit
einer
vertikalen Layoutgruppe
und einer Anpassung der Inhaltsgröße erstellen Scroll-Ansicht mit
einer
vertikalen Layoutgruppe . Ich danke euch vielmals, Leute.
Ich danke euch vielmals.
33. Erstelle vertikale ScrollView mit der Gruppe „Vertikale Layout“: Meine Freunde, mein
Name ist Rohan Sev. In der letzten Sitzung haben wir
über UY Scroll View in Unity gesprochen über UY Scroll View in In dieser Sitzung
werden wir
eine Scroll-Ansicht in
Unity mit vertikaler
Layoutgruppe und Inhaltsgröße Bitter erstellen eine Scroll-Ansicht . Lassen Sie uns
hier eine Scroll-Ansicht erstellen. Wie machen wir das? Klicke einfach hier mit der rechten Maustaste
auf die UY-Szene, was dein Name der Szene ist, gehe zu Game Object, gehe zu UY und wähle
Scroll View Here. Ja, unsere Scroll-Ansicht
wurde hier erstellt. Okay, wir können
hier einfach in
den Szenenmodus wechseln und die Breite und
Höhe der Scroll-Ansicht anpassen. Klicken Sie hier einfach auf Wreck Tool und passen Sie einfach
das
hier erstellte
Spielobjekt mit Scrollansicht auf
der Innenseite der Leinwand der Scroll-Ansicht
ist standardmäßig eine
Bildkomponente und standardmäßig ein Scroll-Wreck angehängt Horizontal und vertikal
wird hier angegeben, in welche Richtung
gescrollt wird Im Moment sind
beide überprüft. Dann haben wir einen Momenttyp
, der auf elastisch gehalten wird. Elastic verschiebt
die Absicht grundsätzlich in alle
Richtungen. Das wollen wir nicht tun. Ändern wir es auf geklemmt. Okay, dann haben
wir in
der Scroll-Ansicht hier ein Viewport Gehen wir hier zum Viewport. Viewport wird im Grunde genommen auch hier wieder eine Bildkomponente
angehängt, an die
eine Rec-Transformation und eine Maske angehängt Jetzt haben
wir im Viewport einen Inhalt, haben
wir im Viewport einen Inhalt im Grunde den gesamten
scrollbaren Okay? Was auch immer der
scrollbare Inhalt wir hier platzieren müssen, er muss
in diese Inhaltskomponente
oder dieses Inhaltsspielobjekt oder dieses Inhaltsspielobjekt Fügen wir dem Inhalt hier eine vertikale
Layoutgruppe hinzu. Okay? Und lassen Sie uns hier die
Inhaltsgröße anpassen. Okay, für die vertikale
Layoutgruppe haben wir Padding. Okay? Polsterung ist
im Grunde der Raum, von links nach
rechts, oben und unten Okay, lassen wir es bei 55. Wir können es auch später anpassen. Okay, dann ist der Abstand im Grunde der Abstand zwischen zwei
verschiedenen Elementen, untergeordneten Elementen innerhalb
des Inhaltsspielobjekts. Lassen wir es hier bei fünf belassen. Auch hier
ist der scrollbare Bereich im Grunde nicht horizontal. Wir müssen das nicht
ändern, okay. Wir werden die Vertikale ändern müssen. Passen Sie hier die bevorzugte
Größe an, sodass sich die Größe des
Inhaltsbereichs grundsätzlich
von
selbst ändert, selbst wenn Sie
weitere untergeordnete Elemente hinzufügen Inhaltsbereichs grundsätzlich
von
selbst ändert, selbst Alle Elemente
werden hineinpassen. Fangen wir hier an,
Bilder zu diesem Inhalt hinzuzufügen. Aber wir müssen hier einige
Änderungen am Bild vornehmen. Wir wollen, dass es ein
wenig gestreckt ist. Okay, lass uns hier zur Szene gehen. Wählen Sie
hier erneut das Rec-Tool und passen Sie es
entsprechend an. Ziehe es einfach. Klicken wir hier mit der rechten Maustaste auf das
Bildspielobjekt. Gehen Sie hier erneut zur Benutzeroberfläche und klicken Sie hier auf Text. Wir haben
hier ein Bild zur Scroll-Ansicht hinzugefügt. Fügen wir weitere Bilder hinzu, damit wir den Scroll-Effekt sehen
können Okay, drücken wir
einfach Strg
D und fügen die Bilder weiter hinzu Kopieren Sie die Bilder hauptsächlich für die Scrollleiste,
horizontal und vertikal. In diesem Fall
wird Horizontal
deaktiviert, da wir hier die
Vertikale Layoutgruppe verwendet haben. Klicken Sie hier auf die vertikale
Scrollleiste. Und lass uns einfach
die Breite dafür ändern , mach
einfach fünf draus. Okay, für horizontal
müssen wir die Höhe ändern. Lass es uns auf Null halten. Lassen Sie uns nun die Szene
durchgehen und sehen, wie sie aussieht. Hier ist es. Wir haben hier eine
scrollbare Ansicht Wie wir bereits besprochen haben, wird die
Bildkomponente an
das
Scroll-View-Spielobjekt angehängt , okay? Und ein Quellbild ist hier standardmäßig auf den
Hintergrund eingestellt, sodass wir
die Farbe dafür ändern können. Ändern wir es in eine dunklere Farbe oder vielleicht in eine rote Farbe oder
etwas Ähnliches. Okay?
Kommt wieder darauf an, welche Farbe du willst, welche Farbkombinationen
du verwendest. Okay, hier ist die Scroll-Ansicht mit vertikaler Layoutgruppe
und einer Anpassung der Inhaltsgröße. Vielen Dank, Leute. In der nächsten Sitzung werden wir über
eine Scroll-Ansicht mit einer horizontalen Layoutgruppe
und
einer Anpassung der Inhaltsgröße
sprechen oder
diese erstellen eine Scroll-Ansicht mit einer . Vielen Dank, Leute. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
34. Erstelle horizontale ScrollView mit horizontaler Layout-Gruppe: Hallo Freunde. Mein Name
ist Rohan Asad In der letzten Sitzung
haben wir ein Beispiel für die
Unity-Scroll-Ansicht gesehen, bei der
vertikale Layoutgruppen
und Inhaltsgrößenanpassungen verwendet vertikale Layoutgruppen
und Inhaltsgrößenanpassungen In dieser Sitzung werden
wir uns ein Beispiel für die
Unity-Scroll-Ansicht mit
horizontaler Layoutgruppe
und Inhaltsgrößenanpassung ansehen Unity-Scroll-Ansicht mit . Im Grunde wird in der
Scroll-Ansicht also gescrollt, der Inhalt in der
Scroll-Ansicht scrollt in horizontaler Richtung
, um eine Scroll-Ansicht zu erstellen Klicken Sie hier mit der rechten Maustaste
auf die UI-Szene. Gehe hier zum Spielobjekt, wähle hier UI aus und
klicke auf Scroll-Ansicht. Lassen Sie uns auch die Höhe
und Breite für die Scroll-Ansicht anpassen . Es gibt zwei Möglichkeiten, dies zu tun. Entweder Sie können
hier auf das Re-Tool klicken, den Szenenmodus wechseln und das Ding einfach ziehen. Oder Sie können
die Breite und Höhe
für das Scrollrad direkt einstellen . Lassen Sie uns hier einfach die
Breite auf 400 ändern, da es sich um eine horizontale
Scroll-Ansicht handelt. Und lassen Sie uns die
Höhe hier auf 150 belassen. Lassen Sie uns hier einfach das
Scroll-View-Spielobjekt erweitern. Okay, erweitere das
Viewport-Spielobjekt hier und klicke hier auf Inhalt. Gehen wir hier in den Szenenmodus. Passen wir
hier mit einem Transformationswerkzeug die Höhe
des Inhalts an die Höhe der Scroll-Ansicht an. Nochmals für die Bildlaufleisten hier. Horizontale Bildlaufleiste. Okay, lassen Sie uns
die Höhe auf fünf einstellen. Okay,
lassen Sie uns für die vertikale
Bildlaufleiste die Breite auf Null belassen, da der Inhalt
hier sowieso nicht vertikal scrollt. Lassen Sie uns die Breite auf Null belassen. Für die
vertikale Scrollleiste hier. Gehen Sie hier erneut zur Scroll-Ansicht. Klicke hier auf das Spielobjekt mit der
Scroll-Ansicht. Und hier den Moment so einstellen, dass
er klemmt und nicht elastisch ist. Lass uns jetzt ein paar Bilder
zum Inhalt hinzufügen, okay? Aber bevor wir diese Bilder hinzufügen, fügen
wir hier zwei Komponenten hinzu. Okay? Eine ist Ihre
horizontale Layoutgruppe, eine andere ist Ihre
Inhaltsgrößenanpassung. Klicken Sie hier auf Komponente hinzufügen und wählen Sie Horizontale
Layoutgruppe Okay? Durch das Padding links
rechts oben wird es später an die Schwester und das Aussehen
des Bildes angepasst. Okay, für die Ausrichtung der untergeordneten Elemente wollen
wir, dass sich scrollbarer Inhalt genau in der Mitte
dieser scrollbaren Ansicht befindet, also quasi von oben links Ändere es hier in die
Mitte, okay? Und fügen Sie dann eine weitere Komponente , die Ihrer
Inhaltsgröße entspricht. Okay, horizontale Passform, wir werden sie hier auf die
bevorzugte Größe ändern Ordnung, nachdem wir das getan haben, fügen
wir hier ein Bild hinzu. Um ein Bild zum
Inhalt hinzuzufügen, klicken Sie mit der rechten Maustaste auf das Inhaltsspielobjekt. Gehe zu KAUFEN und wähle hier Bild aus. Unser Bild wird
hier in der Mitte hinzugefügt. Okay, jetzt lass uns eins tun. Lass uns ein Sprite
für dieses Bild einrichten. Ich habe
hier im Sprites-Ordner schon ein paar Sprites
hinzugefügt hier im Sprites-Ordner schon ein paar Sprites Lassen Sie uns
diesem Benutzer einfach per Drag-and-Drop ein Sprite in das Quellbild für das Bild ,
das wir im Grunde genommen Okay. Klicken Sie hier auf Seitenansicht
beibehalten, wählen Sie
einfach das Bild aus
und drücken Sie Strg D , um das Bild zu kopieren. Okay, lassen Sie uns einfach weiter Bilder
hinzufügen, okay? Klicken Sie jetzt auf Bild eins und lassen Sie uns einfach
das Quellbild ändern. Ändern Sie es dazu einfach, ziehen Sie das
Quellbild hierher und legen Sie es dort ab, oder? Klicken Sie im Grunde einfach hier auf
den Inhalt, okay? Und gehen Sie hier zur horizontalen
Layoutgruppe. Und lassen Sie uns die
Polsterung dafür anpassen. Lassen Sie uns es einfach bei fünf belassen, okay, für das Recht wieder, lassen Sie es uns einfach bei fünf belassen Für die Spitze
ändern wir es auf zehn. Bring es mehr in die Mitte. Okay, unten.
Lass es uns auf Null belassen. Wir wollen es nicht für den Abstand
ändern. Ich denke, der Abstand sieht hier gut aus. Okay. Okay, das wäre alles. Lassen Sie uns die Szene durchgehen und
sehen , wie das Ding hier aussieht. Wir haben gerade
eine Bildlaufansicht mit
einer horizontalen Layoutgruppe
und einer Anpassung der Inhaltsgröße erstellt eine Bildlaufansicht mit ,
obwohl diese
Bildlaufansicht grundsätzlich nur in
horizontaler Richtung
scrollt nur in
horizontaler Richtung
scrollt Okay, danke Leute. Danke für die
Sitzung. Wir sehen uns in der nächsten Sitzung. Ich danke euch vielmals, Leute.
35. UI InpuFeld und Komponenten: Hallo Freunde, mein Name
ist Rohan Vase. In dieser Sitzung
werden wir über
UI-Eingaben sprechen, die in Unity eingegeben wurden Im Grunde wird
ein einfaches Etikett in ein
interaktives
Eingabefeldelement umgewandelt interaktives
Eingabefeldelement dem Sie
Eingaben vom Benutzer entgegennehmen können. Daher wird es im Allgemeinen verwendet, um Benutzereingaben in Unity
entgegenzunehmen. Im Allgemeinen wird es für Anmeldungen,
Registrierungen oder zum Abrufen von
Flare-Daten aller Art
verwendet ,
Registrierungen oder zum Abrufen von
Flare-Daten aller Art Eine Textkomponente oder ein
Textspiel, das entsteht, wenn Sie eine
Eingabefeldkomponente als untergeordnetes Objekt erstellen Jetzt gibt es einige Eigenschaften
für das Eingabefeldelement. Was sind diese Eigenschaften? Interagierbar.
Die Eigenschaft Interactable gibt an das Eingabefeld
alle Benutzereingaben annehmen kann oder nicht Dann haben wir die
Übergangseigenschaft. Die Transition-Eigenschaft wird
verwendet, um zu bestimmen, wie ein Eingabefeld im normalen gedrückten,
markierten, ausgewählten
oder deaktivierten Zustand
reagieren würde . Okay, wir haben wieder eine
Textkomponenteneigenschaft. Die Eigenschaft der Textkomponente
bezieht sich hier im Grunde auf die
Textkomponente. Es ist ein Verweis auf die
Textkomponente, bei der es sich das Textspielobjekt handelt
, das
als untergeordnetes Objekt für die
Eingabefeldkomponente erstellt wird . Dann haben wir Text, der im Grunde genommen
der erste Text an das
Eingabefeld ist , bevor
die Benutzereingabe entgegengenommen Okay. Dann haben wir ein
Zeichenlimit. Zeichenbeschränkung gibt
die maximale Anzahl von Zeichen an, die ein
Eingabefeld aufnehmen kann. Dann haben wir
noch einige weitere Eigenschaften für UI-Eingaben in Unity eingegeben. Eigenschaft „Inhaltstyp“
gibt die Art der Zeichen an, und
das Eingabefeld kann beispielsweise verwendet werden. Dabei kann es sich um ein
Standardzeichen, eine E-Mail-Adresse, ein Passwort, eine Ganzzahl
oder eine Dezimalzahl handeln. Dann haben wir den Zeilentyp. Zeilentyp gibt das Format des Textes im Eingabefeld an. Dieses Format kann weiter in drei Typen
eingeteilt werden. Einzeilig, der
Text darf hier in einer einzigen Zeile stehen, okay? Dann haben wir mehrzeiliges Senden. Der Text kann
nur dann mehrere Zeilen enthalten, wenn dies erforderlich ist. Es bedeutet einfach
, dass die neue Zeile hier automatisch
vom Eingabefeld hinzugefügt
wird. Okay, also mehrzeilig, neue Zeile ist wieder der Text
, der mehrere Zeilen verwenden kann. Eine neue Zeile kann
vom Benutzer hinzugefügt werden , indem er hier
die Eingabetaste drückt. Dann haben wir eine
Platzhalter-Eigenschaft. Platzhalter ist ein Zeichen oder eine Zeichenfolge, die den endgültigen Text oder die endgültigen Daten
als Hinweis oder Überschrift Im Grunde ist es also ein Hinweis
für Ihre endgültigen Textdaten. Dann haben wir die Carrot Blink Rate. Caret-Blinkrate definiert
die Blinkrate für die
Markierung im Eingabefeld, die die
Texteinfügestelle angibt Dann haben wir die Auswahl
der Farbe. Farbe ist die
Hintergrundfarbe für den ausgewählten Text
im Eingabefeld. Unabhängig davon, welchen Text Sie
im Eingabefeld auswählen, die
Auswahlfarbe
die Hintergrundfarbe für
diesen bestimmten Text an . Schließlich haben wir einige Funktionen für das
Eingabefeld in Unity. Da ist zunächst Ihre Funktion On
Value Change. der Funktion Bei Wertänderung handelt es um ein Unity-Ereignis,
das aufgerufen wird, wenn sich der Text im
Eingabefeld ändert. Grundsätzlich wird die Funktion in Unity
aufgerufen oder aufgerufen, wenn Sie
bei einer Änderung des Werts
etwas in das Eingabefeld eingeben Funktion in Unity
aufgerufen oder aufgerufen, wenn Sie
bei einer Änderung des Werts
etwas in Schließlich haben wir eine
Endbearbeitungsfunktion. Bei der Endbearbeitungsfunktion handelt es sich ein Unity-Ereignis, das
aufgerufen wird, wenn der Benutzer den Text im
Eingabefeld durch
Senden
absendet , okay? Es wird sogar aufgerufen, wenn der Fokus
aus dem Eingabefeld entfernt wird Okay, das war's also, Leute,
danke für die Sitzung. In der nächsten Sitzung werden
wir
ein Beispiel für ein
Eingabefeld in Unity sehen . Vielen Dank Leute.
36. Erstelle eine Benutzeroberfläche InputField und verstehe die Komponenten: Hallo Freunde, mein
Name ist Rohan Sev. In dieser Sitzung
werden wir
ein Beispiel für die Immunität gegen
UY-Eingabefelder erstellen ein Beispiel für die Immunität gegen
UY-Eingabefelder Um ein UY-Eingabefeld zu erstellen, klicken
wir
hier mit der rechten Maustaste auf die UY-Szene Gehen Sie zum Spielobjekt, gehen Sie zu UY und klicken Sie auf Eingabefeld. Das Eingabefeld
wurde in Unity erstellt. Lassen Sie uns nun das
Eingabefeld-Spielobjekt
innerhalb des Eingabefeld-Spielobjekts erweitern . Wir werden zwei Spielobjekte haben,
Platzhalter und Text, die
standardmäßig erstellt werden, ihr Spielobjekt Hier ist im Grunde der Hinweistext
, der sich
im Eingabefeld befinden wird Gerade jetzt. Es ist so
eingestellt, dass es Text eingeben kann. Ändern wir es in einen Namen. Hier, ja, unser
Platzhaltertext hat sich jetzt geändert. Ursprünglich war es eingegebener Text, wir haben
ihn geändert, um einen Namen einzugeben Hier können wir die Änderung
hier im Eingabefeld sehen. Okay, dieses Textspielobjekt ist im Grunde das, bei dem der Benutzer den Text eingibt , der hier
vom Benutzer übernommen wird. Okay, gehen wir hier zum
Eingabefeldspielobjekt. Auch hier gilt: Wenn Sie ein
Eingabe-Feldspielobjekt erstellen, wird diesem
standardmäßig eine
Rec-Transformationskomponente zugewiesen. Im Moment sind die Breite
und Höhe für die Rec-Transformation
auf 160,30 gesetzt Ändern
wir sie hier auf
170,70, okay Wir können also die Größe
für das Eingabefeld ändern, indem die Rec-Transformation
für das Eingabefeld erneut
anpassen. Daran wird eine
Bildkomponente angehängt,
sodass wir die Farbe ändern können Wir können auch das
Quellbild ändern. Okay? Kommen wir nun zur Eingabefeld-Komponente für das
Eingabefeld-Spielobjekt, okay? Es wird eine
interagierbare Eigenschaft haben sobald es überprüft ist Es bedeutet einfach, dass es Benutzereingaben entgegennehmen
kann Wenn Sie dies also deaktivieren, kann
es
keine Eingaben vom Benutzer entgegennehmen Dann haben wir
Übergangseigentum. Die Übergangseigenschaft gibt
im Wesentlichen an wie das Eingabefeld
auf die Änderung des Status oder
die Statusänderung reagiert auf die Änderung des Status oder ,
die hier zur
Eigenschaft der Textkomponente kommt . Textkomponenteneigenschaft ist hier der Verweis auf das
Textspielobjekt. Okay, wieder haben wir hier eine
Texteigenschaft. Die Texteigenschaft
ist hier der ursprüngliche Text , den wir hinzufügen können,
bevor wir die Benutzereingabe annehmen. Dann haben wir die Eigenschaft „
Zeichenlimit“. Limit
gibt im Grunde die Anzahl der Zeichen an, die dieses spezielle
Eingabefeld aufnehmen kann, okay? Im Moment gibt es also keine
Einschränkungen für das Zeichen. Ich werde das
Zeichenlimit auf Null setzen, okay? Dann haben wir eine weitere Eigenschaft
, die ein Inhaltstyp ist. Inhaltstyp
gibt im Grunde die Art des Inhalts an, den dieses
Eingabefeld annehmen wird, okay? Hier gibt es verschiedene Optionen. Wir haben einen Standard, dann haben wir automatisch korrigierte Ganzzahlen und wir können Dezimalzahlen verwenden. Dann haben wir Name, E-Mail, E-Mail, ID, Passwort und Film. Wir können hier auch einen benutzerdefinierten
Inhaltstyp festlegen. Dann haben wir eine weitere
Eigenschaft, nämlich den Linientyp. Zeilentyp gibt das Format des Textes
im Eingabefeld an. Okay, dafür gibt es drei
Optionen. Einzelne Zeile. Einzeilig erlaubt den Text nur
in einer einzigen Zeile. Okay, wir können nicht
mehrere Zeilen haben. Wenn wir einzeilige Eigenschaften verwenden, müssen wir hier
mehrzeiliges Senden verwenden. Okay, lassen Sie uns das
auf mehrzeiliges Senden ändern. Und lassen Sie uns die Szene durchspielen. Und lass uns sehen, wie das
Ding hier funktioniert. Okay, lassen Sie uns versuchen, hier im
Eingabefeld
einen langen Text hinzuzufügen . Dies ist ein langer Text für die
Eigenschaft okay, mehrzeiliges Absenden. Okay? Wie Sie hier sehen können, wird beim Hinzufügen
des Textes hier automatisch eine
neue Zeile erstellt. Okay? Dann haben wir eine
Platzhalter-Eigenschaft. Die Platzhalter-Eigenschaft
ist auch hier wieder ein Verweis auf Ihr
Platzhalter-Spielobjekt Dann haben wir eine Karotte. Karotte ist die Markierung, die eigentlich der Ort ist dem der Text hier eingefügt wird. Sie können hier also eine
Markierung blinken sehen, das ist die Karotte
im Eingabefeld Okay? Also kannst du hier das Blinklicht
für die Karotte erhöhen oder
verringern Dann haben wir eine Karottenbreite. Versuchen wir also, die Breite
der Karotte zu ändern, okay, also nimmt die Breite der
Karotte hier zu. Wenn ich es auf vier ändere, okay, dann haben wir
hier eine benutzerdefinierte
Karottenfarbe , benutzerdefinierte Karottenfarbe. Wir können tatsächlich
die Farbe für die Karotte ändern. Im Moment ist sie schwarz. Okay, wir können
diese benutzerdefinierte Karotteneigenschaft
hier überprüfen , Farbeigenschaft hier. Und ändern Sie die Karottenfarbe
so, wie wir es möchten. Also lass es uns auf Rot ändern. Sie können hier jetzt sehen,
dass es rot geworden ist. Okay, dann haben wir
eine weitere Eigenschaft bei der es sich um eine
Auswahlfarbeigenschaft handelt. Im Moment ist es auf Blau eingestellt. Die Eigenschaft „Auswahlfarbe“ ist
im Grunde die Hintergrundfarbe
für den ausgewählten Text. Lassen Sie uns hier also einen Text auswählen. Das ist also die
Hintergrundfarbe für den ausgewählten Text,
die blaue Farbe ist. Lassen Sie uns die Farbe
auf etwas anderes ändern. Okay, lass es uns wahrscheinlich
etwas dunkel machen. Ja. Okay, also können wir hier
die Hintergrundfarbe für
den ausgewählten Text ändern. Dann haben wir hier zwei Funktionen. Erstens ist Ihre eigene Wertänderung. Bei Wertänderung gibt es das
Unity-Ereignis, das ausgelöst wird, wenn der Benutzer hier etwas
in das Eingabefeld eingibt Und schließlich haben wir noch eine Bearbeitungsfunktion,
bei es sich wiederum um ein Unity-Ereignis handelt, das aufgerufen wird, wenn der
Benutzer den Text aus
dem Eingabefeld abgibt oder wenn Sie den Fokus
aus dem Eingabefeld entfernen Wir werden auf die Einzelheiten
dieser Funktionen eingehen, wenn wir mit
den Sitzungen
fortfahren, in denen wir mehr über Ereignisse
und Funktionen erfahren Okay, das war's
für die Sitzung, Leute. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
37. UI-Slider und Komponenten: Hallo Freunde. Mein Name
ist Rohan Vasudev In dieser Sitzung werden
wir über den UI-Slider
Unity sprechen UI-Slider
Unity Was ist Immunität gegen UI-Slider? Es handelt sich um einen Standardschieberegler
, mit dem
ein bestimmter Wert zwischen Minimal
- und Maximalwertpaar eingestellt wird . Er wird häufig
für die Audiosteuerung und die Bildschirmhelligkeit in
einer Szene oder in einem Spiel verwendet. Wenn Sie jetzt eine
UI-Slider-Komponente erstellen, drei
Unity-Spielobjekte, Füllbereich für den
Hintergrund, der Griff Folienbereich, ebenfalls
automatisch als untergeordnetes Objekt erstellt. das Spielobjekt im Hintergrund für das Root-Slider-Spielobjekt Was ist das Spielobjekt im Hintergrund für das Root-Slider-Spielobjekt? Hier ist an das
Spielobjekt im Hintergrund eine Rec-Transformation, also eine Bildkomponente,
angehängt. Dieses Bild wird das Hintergrundbild für den Füllbereich
des Sliders sein. Dem Füllbereich ist wiederum eine Rec-Transformationskomponente
zugeordnet, sich vom
Minimalwert bis zum aktuellen
Wert des Schiebereglers erstreckt Minimalwert bis zum aktuellen
Wert des Schiebereglers Ein untergeordnetes Spielobjekt für das Spielobjekt „Fläche füllen“ wird
ebenfalls automatisch erstellt dieses Spielobjekt werden
eine Transformationskomponente und eine Bildkomponente
angehängt. Diese Bildkomponente spezifiziert das Bild und die Farbe für
das Füllspielobjekt. Was ist Griff? Folienbereich? Folienbereich mit Griff ist
eine Transformationskomponente angehängt, die dem
aktuellen Wert eines Sliders folgt. Für den
Griff gibt es einen Objekt-Handle aus dem Spiel Folienbereich wird ebenfalls automatisch
erstellt. diesen Griff werden
eine Komponente für die Neutransformation und eine Bildkomponente
angehängt. Diese Bildkomponente gibt das Bild und die Farbe für
das Handle-Spielobjekt an. Standardmäßig ist Unity
Knobprt als Bildeigenschaften
eines Slider-Elements an
das Handle-Spielobjekt angehängt als Bildeigenschaften
eines Slider-Elements an
das Handle-Spielobjekt Bildeigenschaften
eines Slider-Elements an
das Die Eigenschaft Interactable
gibt an, ob der Slider interagierbar ist
oder Die Transition-Eigenschaft wird verwendet, um zu
bestimmen, wie ein Slider
reagieren würde, wenn er normal gedrückt,
markiert, ausgewählt
und deaktiviert Fill ist für
uns eine Transformation als Füllung für den Slider
und ist ein Verweis auf das Fill-Game-Objekt
, das erzeugt wird, wenn Sie eine
Slider-Komponente in Unity erstellen. Handle ist wiederum eine Transformation, die als Griff für den
Slider
verwendet werden soll. Es ist ein Verweis auf das Spielobjekt, das
automatisch erstellt wird, wenn Sie
eine Slider-Komponente in Unity erstellen . Richtung ist die
Richtung des Sliders vom Minimalwert zum Maximalwert. Wir haben vier Optionen für die
Richtung von links nach rechts, rechts nach links, von oben nach
unten und von unten nach oben. Mindestwert ist
der Wert, der für
den Schieberegler festgelegt oder
für den Schieberegler zulässig ist. Maximalwert ist
der Höchstwert für den Schieberegler
festgelegt oder für den Schieberegler
zulässig Der
Wert ist der aktuelle
Wert des Schiebereglers. Und schließlich sind ganze Zahlen
im Grunde ein Goldbarrenwert. Wenn es aktiviert oder
auf „true“ gesetzt ist, zulässig für den Schieberegler nur ganze Zahlen
zwischen
Minimal- und
Maximalwerten Das war's Leute. Wir
sehen uns in der nächsten Sitzung. In der nächsten Sitzung werden
wir
ein Beispiel für den UI-Slider in
Unity sehen . Vielen Dank, Leute.
38. Erstelle UI-Slider und verstehe die Komponenten: Hallo Freunde. Mein
Name ist Rohan Dev In dieser Sitzung
werden wir uns
ein Beispiel für den
UI-Slider in Unity ansehen ein Beispiel für den
UI-Slider in Unity Um einen UI-Slider in Unity zu erstellen, klicken Sie mit der
rechten Maustaste hier
auf die UY-Szene, gehen Sie zum Spielobjekt, gehen Sie zur Benutzeroberfläche und wählen Sie hier den Slider aus. Unser Slider wurde in Unity erstellt. Wählen Sie hier den Slider aus und gehen Sie zu Inspector Taber Und wir können sehen, wie die
Rec-Transformationskomponente automatisch
an
das Slider-Spielobjekt angehängt wird Indem wir die Breite und
Höhe der Rec-Transformation ändern, können
wir grundsätzlich das Gewicht und die Höhe
des Sliders ändern. hier runter kommen, haben wir standardmäßig eine
Slider-Komponente
an das
Slider-Spielobjekt angehängt . Okay? Wir können
hier also einige Eigenschaften für die Slider-Komponente sehen . Die Eigenschaft Interactable gibt
grundsätzlich
an, ob der Slider interagierbar
ist oder Im Moment ist es aktiviert, das bedeutet, dass der Slider interagierbar
ist Dann haben wir eine
Übergangseigenschaft. Die Übergangseigenschaft wird
verwendet, um zu bestimmen, wie dieser Schieberegler bei
einer Zustandsänderung oder bei
einer bestimmten Zustandsänderung reagieren würde . Kommen wir zur Eigenschaft „
Wreck füllen“. Die Eigenschaft Wreck füllen“ wird
im Grunde genommen als
Füllung für den Schieberegler verwendet Es ist auch ein Verweis auf die Fülltransformation der Rec-Transformation , die automatisch
im Spielobjekt Field Area erstellt wird im Spielobjekt Field Area Okay, die Eigenschaft Handled Reck
wird hier als Ziehpunkt für
den Schieberegler verwendet. Auch hier handelt es um
einen Verweis auf das
Griff-Spielobjekt automatisch
im
Griffbereich erstellt
wird . Das Spielobjekt in der
Slider-Richtungseigenschaft gibt die Richtung
eines Sliders vom Minimal-
zum Maximalwert an. Okay. Wir haben vier Optionen für die Richtungseigenschaft von
links nach rechts, rechts nach links, von unten
nach oben, von oben nach unten. Okay. Lassen Sie uns die
Szene hier ausführen und sehen, wie die Richtungseigenschaft für einen Schieberegler
funktioniert. Derzeit ist die Richtung
des Schiebereglers von links
nach rechts eingestellt. Dieser Schieberegler bewegt sich
grundsätzlich von links nach rechts. Okay, ändern wir
es von rechts nach links. Dieser Schieberegler
bewegt sich im Grunde von rechts nach links, und dann haben wir von unten nach oben. Okay? Dieser Slider
bewegt sich von unten nach oben. Und schließlich
haben wir von oben nach unten. Dieser Schieberegler bewegt sich
von oben nach unten. Okay, ändern wir
es auf die Standardeinstellung, die hier von links nach rechts ist. Okay? Dann haben wir den Mindestwert. Mindestwert ist im Grunde der Mindestwert, der für den Schieberegler eingestellt
ist Derzeit ist er auf Null gesetzt. Und der Maximalwert ist der Maximalwert, der für den Schieberegler eingestellt
ist. Derzeit ist er auf eins eingestellt. Lass es uns auf 100 ändern, okay? Dieser Wert hier ist der
aktuelle Wert des Sliders. Okay? Lass uns den Schieberegler oder das **** hierher bewegen, okay? Wir können hier im Grunde Dezimalzahlen sehen ,
wenn wir den
Schieberegler bewegen. Und wir können sehen, dass der
Wert, der sich ändert,
im Grunde der aktuelle
Wert des Schiebereglers ist . Im Moment ist es 24,83 und
es ist wieder auf Null. Lassen Sie uns hier also die
ganzen Zahlen überprüfen. Bei ganzen Zahlen dürfen der Minimal- und Maximalwert nur ganze Zahlen sein, okay? Lassen Sie uns hier also die Eigenschaft ganzer
Zahlen überprüfen. Und versuchen wir erneut,
den Schieberegler zu bewegen. Der sich ändernde Wert, den wir
hier sehen können, besteht aus ganzen Zahlen. Wir können hier keine
Dezimalzahlen mehr sehen, okay? Und das passiert
, weil wir hier gerade
die Ganzzahlen-Eigenschaft überprüft haben . Okay? Also das war's Leute. Das war's für die
Slider-Komponente in Unity. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
39. Anker von UI-Elementen in Unity: Freunde, mein Name ist Rohan Vdv. In dieser Sitzung werden wir ein Beispiel für die Größenänderung,
Skalierung und Verankerung von
UI-Elementen in Unity
erstellen Skalierung und Verankerung von
UI-Elementen das zu tun, lassen Sie uns
eine UI-Schaltfläche in Unity erstellen. Okay, klicken Sie mit der
rechten Maustaste hier auf
die Hauptkamera, gehen Sie zu UY und klicken Sie hier
auf die Schaltfläche. Okay, unsere Schaltfläche wird also hier in der Unity-Szene
erstellt. Was ist, wenn wir diese Schaltfläche
genau in der linken unteren
Ecke der Szene
anzeigen möchten , unabhängig von
Bildschirmgröße oder Auflösung. Unity bietet uns hier
nur wenige Seitenverhältnisse. Im Moment ist es
auf Free Aspect eingestellt. Wir haben ein Seitenverhältnis
von fünf ist zu vier, wir haben vier ist zu drei, dass wir drei zu zwei haben, dass wir 16 mal zehn haben, wir haben 16 zu neun und wir
haben 1.024,2 768 Wir können auch
mehr Seitenverhältnisse hinzufügen. Okay, lassen Sie uns ab sofort das
freie Seitenverhältnis einstellen, was im Grunde das
Standard-Seitenverhältnis ist. Was ist, wenn wir
diese Schaltfläche hier ganz links
unten
im C anzeigen möchten ? Versuchen Sie, ? Versuchen Sie diese Schaltfläche hier zu platzieren,
indem Sie sie einfach
hierher ziehen und die
Position für die Schaltfläche festlegen Okay, für diese
spezielle Bildschirmgröße befindet sich
die Schaltfläche hier
unten links in der Szene Versuchen wir, das
Seitenverhältnis auf fünf mal vier zu ändern. Nein, das ist nicht richtig, es verschwindet aus der Szene. Okay, versuchen wir,
das Seitenverhältnis
auf vier mal drei zu ändern . Versuchen wir, das
Seitenverhältnis auf 16 mal neun zu ändern. Das ist nicht richtig, weil wir möchten, dass diese Schaltfläche unabhängig
von
der Bildschirmgröße, Bildschirmauflösung
oder dem AS-Verhältnis genau an der richtigen Position verankert unabhängig
von
der Bildschirmgröße, Bildschirmauflösung
oder dem AS-Verhältnis genau an der richtigen Position von
der Bildschirmgröße, Bildschirmauflösung
oder AS-Verhältnis Okay, versuchen wir es jetzt. Um das zu tun, klicken
wir zunächst hier auf die Leinwand. Okay, für die Leinwand haben
wir eine skalare
Canvas-Komponente
an das
Canvas-Spielobjekt angehängt . Für die Y-Skala wurde der Skalierungsmodus von
konstanter Pixelgröße auf
Skalierung mit Bildschirmgröße geändert konstanter Pixelgröße auf
Skalierung mit Bildschirmgröße Okay, jetzt klicken wir hier
auf die Schaltfläche. Jetzt wollen wir
diesen Button unten links auf
dem Bildschirm verankern . Um das für
die Rec-Transformation zu tun, stellt uns
Unity hier
einige Anker-Voreinstellungen Okay, das ist
vertikale Verankerung, und das ist im Grunde genommen horizontale
Verankerung Okay, also wir wollen, dass diese Schaltfläche vertikal links verankert ist, also klicken Sie hier auf links Und wir möchten, dass diese Schaltfläche horizontal
unten
verankert ist, also klicken wir hier auf unten Okay, auf diese Weise wird
die Schaltfläche in der unteren
linken Position
verankert Gehen wir jetzt hier in den
Szenenmodus. Und lassen Sie uns die Schaltfläche einfach wieder
hierher
ziehen und die Position
für die Schaltfläche
so einstellen , wie wir es möchten. Okay, jetzt gehen wir wieder
in den Spielmodus. Und lassen Sie uns
jetzt die Position für den Bildschirm 16 mal neun sehen. Ja, es ist in der
unteren linken Ecke. Versuchen wir,
es auf einen freien Aspekt umzustellen. Ja, es ist an derselben Position. Versuchen wir,
es auf fünf mal vier zu ändern. Ja, versuchen wir,
es auf vier mal drei zu ändern. Versuchen wir,
es auf drei mal zwei zu ändern, dann versuchen wir
es auf 16 mal zehn zu ändern. Und lassen Sie uns versuchen, es auf
Standalone zu ändern, 1024 in 768. Lassen Sie uns ein weiteres
Textelement erstellen. Und lassen Sie uns es an
der oberen linken Position
hier auf dem Bildschirm verankern . Okay, um einen UI-Text zu erstellen, klicken Sie hier mit der rechten Maustaste
auf die Leinwand, gehen Sie zu UY und gehen Sie hier zum Text. Okay, unser Text wird hier erstellt, genau in der Mitte
des Bildschirms. Okay, wähle dein
Textspielobjekt aus, gehe zu Rec Transform, Anchor Presets hier, okay? Vertikal. Wir wollen
, dass es links verankert ist, okay, horizontal, wir wollen, dass
es oben verankert Wählen wir hier oben aus. Gehen wir jetzt wieder in
den Szenenmodus. Und lassen Sie uns das Textelement
hier oder das Textspielobjekt hier verfolgen , genau in der oberen Ecke hier. Gehen wir jetzt wieder in den
Spielmodus. Versuchen wir nun,
das Seitenverhältnis zu ändern. Versuchen wir,
es auf ein freies Seitenverhältnis umzustellen. Versuchen wir,
es auf fünf mal vier zu ändern. Versuchen wir,
es auf vier mal drei zu ändern. Versuchen wir,
es auf drei mal zwei zu ändern. Versuchen wir,
es auf 16 mal zehn zu ändern. Versuchen wir,
es auf 16 mal neun zu ändern. Lassen Sie uns das beim freien Aspekt belassen. Okay, so verankern, skalieren oder
ändern Sie Größe eines UI-Elements oder einer
beliebigen UI-Komponente in Unity Okay, das war's für
die Session, Leute. Ich danke dir vielmals.
Wir sehen uns in der nächsten Sitzung. Ich danke euch vielmals, Leute.
40. Einführung in Unity-Events: Hallo Freunde. Ich
heiße Rowan Suv. In dieser Sitzung werden
wir
über Event-Funktionen in Unity sprechen über Event-Funktionen in Unity Was sind
Ereignisfunktionen in Unity? Der Code im
Unity-Skript funktioniert nicht wie ein herkömmlicher Code in anderen Programm
oder einem anderen Code. Stattdessen übergibt Unity die Kontrolle an das Skript, indem es
bestimmte Funktionen darin aufruft. Diese Funktionen werden als
Ereignisfunktionen bezeichnet, da sie als Reaktion auf
bestimmte Ereignisse während
des Spiels
ausgeführt werden. Unity identifiziert
diese Funktionen anhand ihrer von der Unity selbst
angegebenen Namen und führt sie entsprechend
dem Ereignis während des Spiels Einige der wichtigen
Event-Funktionen in Unity sind wie folgt Wir haben die Weckfunktion, wir haben die Startfunktion,
wir haben ein Update, wir haben ein spätes Update und wir haben die
Update-Awake-Funktion repariert. Die erste Szene des Spiels wird beim Ausführen
der Spielanwendung
geladen. Wenn Sie also eine
Spielanwendung ausführen, wird
die Szene geladen
und alle Objekte, die im Wesentlichen in der Szene
oder innerhalb der Szene
befinden, werden beim Laden
der Szene initialisiert Sobald die Objekte
erstellt und initialisiert sind, wird Awake-Funktion
im Unity-Skript aufgerufen Okay, die Awake-Funktion
im Skript ist im Grunde eine
Initialisierungsfunktion, die erste Funktion, die innerhalb eines Skripts ausgeführt
wird innerhalb eines Skripts ausgeführt
wird Diese Funktion wird
nur einmal aufgerufen und auch dann
ausgeführt, wenn das Skript nicht aktiviert oder aktiv
ist Mal sehen, was die
Startfunktion ist. Startfunktion im Skript wird erst
aufgerufen, nachdem eine
Weckfunktion aufgerufen wurde. Und sie wird einmal
im Lebenszyklus eines Skripts aufgerufen. Im Gegensatz zu einer Weckfunktion wird
sie nur ausgeführt, wenn das
Skript in Unity aktiviert ist. Aktualisierungsfunktion ist
in der
Monobehavior-Klasse definiert und wird
automatisch in jedem Frame des
Spiels ausgeführt automatisch in jedem Frame des , wenn das
Monobehavior aktiv ist Was ist Frame?
Ein Frame ist im Grunde ein Standbild, das auf dem Bildschirm
gerendert wird. Okay? Die Update-Funktion läuft regelmäßig, während
unser Spiel läuft. Die Aktualisierungsfunktion wird einmal pro Frame aufgerufen
oder aufgerufen. Der Aufruf einer
Aktualisierungsfunktion
hängt von der Framerate des
Spiels ab. Was ist Framerate? Bildrate ist im Grunde
die Frequenz, mit
der die aufeinanderfolgenden Stahlbilder auf dem Bildschirm wiedergegeben
werden. Das Zeitintervall
ist bei
hohen Bildraten grundsätzlich niedrig und bei niedrigen Bildraten
hoch. Funktion für späte Updates wird
einmal pro Frame aufgerufen , nachdem das
Update abgeschlossen ist. Wird aufgerufen. Die Funktion für spätes
Update verhält sich
genau so
wie eine Aktualisierungsfunktion, außer dass sie
erst aufgerufen wird , nachdem die
Aktualisierungsfunktion aufgerufen wurde Diese Funktion wird grundsätzlich
häufig verwendet,
um die Kamera dem Spieler
oder einem anderen Spielobjekt
folgen oder einem anderen Spielobjekt Schließlich haben wir die Aktualisierungsfunktion
repariert. Die feste Aktualisierungsfunktion hängt
nicht von der Bildrate ab. Das feste Update wird
konstante Zeitintervalle haben. feste Aktualisierungsfunktion kann mehrmals pro
Frame
aufgerufen werden , wenn die Bildrate
niedrig ist , oder sie kann nicht pro Frame
aufgerufen werden. Wenn die Bildrate hoch ist, ist
es durchaus möglich, dass das
feste Update häufiger
aufgerufen wird als die
Update-Funktion. Okay, das war's Leute, das war's für die Sitzung. In der nächsten Sitzung werden wir
ein Beispiel für die Funktionen Start Update,
Late Update und Fixed
Update sehen ein Beispiel für die Funktionen Start Update, . Wir werden auch den
Unterschied zwischen ihnen sehen. Ich werde euch
in der nächsten Sitzung sehen. Ich danke euch vielmals, Leute.
41. Verstehe Unity Event-Funktionen in einem Drehbuch / Skript: Hallo Freunde, mein
Name ist Rohan Sev. In dieser Sitzung
werden wir uns
ein Beispiel für die Funktionen „Wake-Start“, „Update“, „Late
Update“ und „
Fixed Update“
innerhalb des Skripts in Unity ansehen ein Beispiel für die Funktionen „Wake-Start“, „Update“, Late
Update“ und „Late
Update“ und „
Fixed Update“
innerhalb des Skripts in Zu diesem Zweck haben wir hier
bereits ein
leeres Spielobjekt erstellt. Und der Name des leeren
Spielobjekts ist Event Functions. Wir haben auch ein
Skript erstellt, Event-Funktionen. Lassen Sie uns das Skript hier öffnen. Okay, lassen Sie uns dem Skript eine Wake-Funktion,
eine Late-Update-Funktion und eine
Fixed-Update-Funktion
hinzufügen Late-Update-Funktion und . Okay, Leute, wir haben dem Skript hier die Weckfunktion, die
Aktualisierungsfunktion und
die
feste Aktualisierungsfunktion
hinzugefügt Weckfunktion, die
Aktualisierungsfunktion und
die
feste Aktualisierungsfunktion , okay? Die Awake-Funktion ist im Grunde die
Initialisierungsfunktion. Und es wird die
erste Funktion sein, innerhalb des Skripts aufgerufen wird Wenn Sie eine Anwendung ausführen, beliebige Spieleanwendung, werden
die Objekte zuerst
initialisiert und erstellt Sobald die Objekte
erstellt und initialisiert sind, wird die
Awake-Funktion
aufgerufen und
im Unity-Skript aufgerufen Lassen Sie uns etwas
in der Awake-Funktion drucken. Das ist eine Weckfunktion, okay? Kommen wir also zur Startfunktion, die Startfunktion wird
grundsätzlich erst aufgerufen nachdem die Erwache-Funktion
ausgeführt wurde, okay? Startfunktion
wird nur
einmal im
Lebenszyklus des Skripts aufgerufen . Lassen Sie uns auch etwas in
der Startfunktion drucken. Funktion starten. Okay, um zur
Update-Funktion hier zu kommen, Update-Funktion wird erst
aufgerufen , nachdem die
Startfunktion aufgerufen wurde Die Update-Funktion wird einmal pro Frame
aufgerufen. Der Aufruf der
Update-Funktion
hängt vollständig von der
Framerate des Spiels ab. Lassen Sie uns auch etwas in
der Update-Funktion ausdrucken. Okay, die Aktualisierungsfunktion
wird ausgeführt. Fügen wir in
Unity eine Funktion hinzu, die
Zeitpunkt-Delta-Zeit ist. Im Grunde gibt uns
die
Zeitpunkt-Delta-Zeit die Zeit an, die für die Fertigstellung
des letzten Frames benötigt wurde.
Okay, um zur Funktion für
spätes Update zu kommen, die Aktualisierungsfunktion
wird wieder als ein Frame bezeichnet. Es ist genau wie die
Aktualisierungsfunktion, aber der einzige Unterschied besteht darin
, dass die Aktualisierungsfunktion erst
aufgerufen wird , nachdem die
Aktualisierungsfunktion ausgeführt wurde. Aktualisierungsfunktion
kann verwendet werden, wenn Sie möchten, dass Ihre Kamera dem Spieler
folgt oder
etwas Ähnliches, oder wenn Sie möchten, dass Ihre Kamera einem anderen Spielobjekt folgt. Lass uns etwas in der Funktion für
spätes Update ausdrucken. Funktion für spätes Update wird erneut ausgeführt Fügen
wir die Zeitdeltazeit hinzu. Dies zeigt uns die Zeit, die für die Fertigstellung
des Frames benötigt wurde. Um zur letzten
festen Update-Funktion zu kommen, die feste Update-Funktion
hängt
im Grunde genommen nicht von der
Bildrate des Spiels ab, okay? Das Zeitintervall zwischen dem fester Aktualisierungsfunktionen Aufruf
fester Aktualisierungsfunktionen ist in Unity immer
konstant. Lassen Sie uns
innerhalb der festen
Aktualisierungsfunktion erneut etwas drucken . Okay? Das Update wird ausgeführt, fügen
wir erneut die Zeit-Delta-Zeit hinzu. Okay, lass uns den Senior
leiten. Okay, Leute, hier ist die
Ausgabe für den Code. Das ist eine Wachfunktion. Die Awake-Funktion ist die
erste Funktion, die ausgeführt wird. Dann haben wir die Startfunktion,
die der Awake-Funktion folgt. Später werden dann die Funktionen
Update, Update
und Late Update ausgeführt. feste Aktualisierungsfunktion hängt
nicht von der
Bildrate ab und das Zeitintervall in der festen Aktualisierungsfunktion ist
immer konstant, okay? Also die ganze feste
Aktualisierungsfunktion wird hier im Grunde 0,02
haben, okay? Als Ausgabe-Aktualisierungsfunktion
und als Late-Update-Funktion haben beide 0,02 als
Zeitintervall, okay? Aber wenn wir nach unten gehen, ändert sich
diese Zeit hier
sowohl für die Update-Funktion als auch für die
Late-Update-Funktion, da beide
Funktionen im Grunde von
der Framerate
des Spiels abhängen im Grunde von
der Framerate
des Spiels Okay, das war's also, Leute. Danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
42. Einführung in benutzerdefinierte Funktionen in Unity: Meine Freunde, mein Name
ist Rohan Vasudev. In dieser Sitzung werden
wir mehr über benutzerdefinierte
oder benutzerdefinierte Funktionen
in Unity C Sharp lernen oder benutzerdefinierte Funktionen
in Unity Was sind also benutzerdefinierte
Funktionen in Unity? Eine Funktion
ist im Grunde ein
Codeblock, der verwendet wird, um eine
einzelne Aktion oder eine Aufgabe auszuführen. Es bietet Erweiterbarkeit der Spieleanwendung
sowie Wiederverwendbarkeit des Codes und spart Zeit
beim Umschreiben des Eine Funktion in Unity besteht aus
folgenden Komponenten. Funktionsname, Rückgabetyp, Textzugriffsspezifizierer
und Parameter Die Syntax für eine grundlegende Funktion in Unity C Sharp lautet wie folgt Zuerst geben wir
den Zugriffsspezifizierer an
, gefolgt vom Rückgabetyp, dann dem Namen der Funktion, gefolgt von Klammern
und Kalibrierungen In den Kalibraten geben
wir Codeblock oder
den Funktionskörper
an Schauen wir uns eins nach dem anderen an. Was ist der Funktionsname?
Was ist der Rückgabetyp? Was ist Körper? Was
ist der Zugriffsspezifizierer Und was sind Parameter
in einer Funktion? Name der Funktion.
Funktionsname ist ein Name , der der Funktion
gegeben wurde, okay? Dann haben wir den Rückgabetyp. Rückgabetyp gibt an, welcher Datentyp der Funktion als Wert zurückgegeben werden
würde. Dann haben wir Body, hat einen Codeblock, der innerhalb der Funktion
ausgeführt werden soll. Dieser Hauptteil oder der Codeblock wird sich im Grunde innerhalb der
Funktion befinden. Dann haben wir den Zugriffsspezifizierer. Der Zugriffsspezifizierer
spezifiziert den auf eine Funktion innerhalb
der Anwendung Parameter sind die in einer Funktion
übergebenen Argumente. Dies ist eine optionale Komponente. Jetzt kann eine Funktion eine Basisfunktion oder eine
Funktion mit Rückgabetyp oder eine Funktion mit Parametern sein. Basisfunktion ist im Grunde eine einfache Funktion
mit einem
Codeblock, der darin ausgeführt werden soll. Eine Funktion mit Rückgabetyp spezifiziert den Datentyp des
von einer Funktion zurückgegebenen Werts. In einfachen Worten, sie spezifiziert
die Art der Ausgabe. Wenn der Ausgabetyp Zahl ist, kann der Rückgabetyp int, float, double usw. sein. Funktion mit Parametern. Parameter sind im Grunde
die Informationen an die Funktion
übergeben werden. Diese Parameter fungieren als
Variable mit Datentyp. Dies sind Variablen, die
im Grunde genommen einen Datentyp haben. Dieser Datentyp könnte int
oder eine Zeichenfolge usw. sein. Sie werden nach der Deklaration des
Namens der Funktion übergeben. Innerhalb der Klammer geben Sie
den Namen für die Funktion und auf den Namen der Funktion folgen im Grunde die
Klammern Okay? In diesen Klammern deklarieren
Sie diese Parameter. Jetzt gibt es keine
Beschränkung für die Anzahl der Parameter, die Sie an eine Funktion übergeben
können. Aber jeder Parameter
muss getrennt werden durch. Sie können
mehrere Parameter übergeben, aber jeder Parameter
muss durch ein Komma getrennt werden Okay, das war's, Typ. In der nächsten Sitzung
werden wir ein Beispiel für eine
Basisfunktion mit Rückgabetyp
und eine Funktion mit Parametern sehen Basisfunktion mit Rückgabetyp . Vielen Dank Leute. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
43. Schreibe eine grundlegende Funktion in einem Drehbuch / Skript: Hallo Freunde, mein Name
ist Rohan Vase. In dieser Sitzung werden
wir uns ein Beispiel ansehen, um eine einfache
Funktion in Unity
zu schreiben Um eine einfache Funktion zu schreiben, haben
wir bereits
ein leeres Spielobjekt erstellt. Und der Name des leeren
Spielobjekts ist einfache Funktion. Hier haben wir auch Act erstellt, und der Name des Skripts
ist Simple Function. Wir haben
das Skript auch an
das leere Spielobjekt angehängt ,
einfache Funktion. Lassen Sie uns das Skript hier öffnen und einen Code schreiben. Um eine Funktion zu deklarieren, müssen
wir einen
Zugriffsmodifikator für die Funktion angeben Lassen Sie uns hier private verwenden. Privat bedeutet einfach, dass auf
diese Funktion außerhalb
der Klasse oder
außerhalb dieses
speziellen Skripts nicht
zugegriffen werden kann außerhalb
der Klasse oder
außerhalb dieses
speziellen Skripts nicht
zugegriffen . den Zugriffsmodifikator in einer Funktion
folgt ein Rückgabetyp In diesem Fall ist er ungültig, da diese spezielle Funktion nichts zurückgeben
würde Okay? Dann müssen wir
den Namen der Funktion angeben. Lass uns meine Funktion setzen. Dieser Name könnte Ihrer
Wahl entsprechen, er könnte alles Mögliche sein. Wir haben gerade den Namen
als meine Funktion hier eingetragen. Okay? Und dann
haben wir Kalibrationen. Und in die Kalibrationen schreiben
wir den Code, der innerhalb der Funktion ausgeführt
werden soll innerhalb der Funktion ausgeführt
werden In diesem Fall
drucken wir
mithilfe
der Bug-Lock-Funktion etwas in der einzigartigen Konsole Das ist eine einfache Funktion u, okay? Wie führen wir die Funktion direkt hinter dem Namen
der Funktion aus, was
in unserem Fall meine Funktion ist? Innerhalb der Startfunktion. Hier meine Funktion. Okay, speichern wir
das Drehbuch, okay? Also hier ist es, Leute.
Hier ist die Ausgabe. Dies ist eine einfache
Funktion in Unity. Also vielen Dank, Leute. Wir sehen uns in der nächsten, in der nächsten Sitzung, über die
wir sprechen werden, wir werden ein Beispiel
für Funktionen mit einem Rückgabetyp sehen . Ich danke euch vielmals, Leute.
44. Schreibe eine Funktion mit Rückgabetyp: Hallo Freunde. Mein Name
ist Rohan Vasudev In dieser Sitzung werden
wir uns
ein Beispiel für eine Funktion
mit Rückgabetyp ansehen ein Beispiel für eine Funktion
mit Wir haben bereits
eine
Rückgabefunktion für leere Spielobjekte
und eine Skript-Rückgabefunktion erstellt eine
Rückgabefunktion für leere Spielobjekte . Wir haben
das Skript bereits an das
leere Spielobjekt angehängt . Lassen Sie uns hier das
Skript öffnen und einen Code
in das Skript
schreiben. Okay, lassen Sie uns hier
eine Funktion hinzufügen. Eine Funktion mit Rückgabetyp spezifiziert den Datentyp, oder die Wertfunktion
gibt zurück. Fügen wir der Funktion einen
Zugriffsmodifikator hinzu. Und lassen Sie uns hier den
Rückgabetyp hinzufügen. Lassen Sie uns diese Funktion so einrichten
, dass sie eine Zahl zurückgibt. Fügen wir hier den
Rückgabetyp acht hinzu. Und nennen wir die
Funktion Funktionstyp. Das ist der Name der Funktion. Dieser Name kann
beliebig sein, ganz nach Ihrer Wahl. Okay? Da
es sich um einen Rückgabetyp handelt, müssen
wir
die Daten, die
hier von der Funktion zurückgegeben werden,
mit einem Return-Schlüsselwort angeben die Daten, die
hier von der Funktion zurückgegeben werden, . Okay, um das zu tun,
lassen Sie uns nun eine Variable
innerhalb der Funktion
als Variable deklarieren . Lassen Sie uns die
Variable Nummer eins deklarieren, die vom Datentyp interior ist. Und lassen Sie uns den
Wert zehn als Variable zuweisen, okay? Lassen Sie uns einfach
diese Variable Nummer eins zurückgeben ,
da es sich um eine Zahl handelt, okay? Lassen Sie uns nun einfach
die Funktion mit Return
innerhalb der Startfunktion übergeben . Lassen Sie uns diese Funktion also
innerhalb der Debug-Funktion mit
Punktsperre übergeben , weil diese spezielle
Funktion eine Zahl
zurückgeben wird , okay? Funktion mit Rückgabetyp, okay? Okay, das ist es, Leute.
Hier ist die Ausgabe. Also haben wir zehn hier in
der Unity-Konsole. Ich danke euch vielmals, Leute. Wir sehen uns in
der nächsten Sitzung. In der nächsten Sitzung werden wir
ein Beispiel für
Funktionsparameter sehen , wie man Parameter übergibt,
genug Funktionen. Ich danke euch vielmals, Leute.
45. Schreibe eine Funktion mit Parametern: Hallo Freunde. Mein
Name ist Rohan Sue In dieser Sitzung werden
wir uns ein Beispiel für
Funktionsparameter
für diesen Zweck ansehen Funktionsparameter
für diesen Zweck Wir haben bereits
ein leeres Spielobjekt erstellt. Und der Name des
leeren Spielobjekts ist Parameterfunktion. Und wir haben auch eine
Skriptparameterfunktion erstellt. Und wir haben das Skript bereits
an
die
Spielobjektparameterfunktion angehängt . Hier öffnen
wir das Skript und schreiben einen Code
in das Skript. Okay, lassen Sie uns eine Funktion
mit einem Parameter
in diesem Skript deklarieren . Um nun eine Funktion zu deklarieren, beginnen
wir mit einem
Zugriffsmodifikator Geben wir den
Rückgabetyp auf void an, da diese Funktion nichts zurückgeben
wird Nennen wir die Funktion
als meine Funktion. Okay, jetzt müssen wir hier die Parameter
innerhalb der Klammern
übergeben. Der Parameter ist im Grunde
eine Information , die an die Funktion
übergeben wird. Diese Information fungiert
als Variable mit
einem Datentyp. Lassen Sie uns hier einen Parameter
mit einem String-Datentyp übergeben. Vorname der Zeichenfolge, das ist ein
Parameter, Insider-Funktion. Lassen Sie uns einen weiteren Parameter übergeben, Nachnamen vom Datentyp Zeichenfolge
mit einem Komma. Hier können wir mehrere Parameter
übergeben,
Insider-Funktion, okay? Nun drucken wir hier den Vor- und
Nachnamen aus. Um
die Parameter hier zu drucken, verwenden
wir grundsätzlich die Debug-Log-Funktion Und lassen Sie uns etwas
im Bug Dot Log drucken. Okay? Lass uns hier ein
Leerzeichen geben, okay. Willkommen. Vorname, okay? Plus doppelter Nachname. Okay? Wir haben hier
Doppelcodes verwendet, um im Grunde
ein Leerzeichen zwischen Vor
- und Nachnamen vorzusehen . Okay? Fügen wir nun die Funktionsfunktion zur
Startfunktion hinzu. Wenn wir also die Szene ausführen, wird
meine Funktion ausgeführt. Meine Funktion, wir müssen die Parameter hier
übergeben. Okay? Und die Parameter
müssen vom Datentyp Zeichenfolge sein. Geben wir hier also den
Vornamen an, Danny. Und mit einem Komma übergeben
wir den Nachnamen Okay. Santiago. Okay, das ist es. Okay, willkommen, Danny Santiago. Wir haben die Ausgabe hier. Das war's Leute. Das
war's für die Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
46. Einführung in die Unity-Delegierten: Hallo Freunde, Mein Name
ist Rohan Vasudev. In dieser Sitzung werden wir die Delegierten in
Einigkeit sehen. Sha. Was sind Delegierte? Delegierte sind
Referenzzeiger auf die Funktionen oder
Methoden in Unity Die dem Delegaten
zugewiesene Funktion wird als Variable behandelt oder übergeben
, sodass sie
aufgerufen oder ausgeführt werden kann Ein Delegat funktioniert als einfacher Dienst
auf Abonnementbasis, bei dem die Funktion
aufgerufen oder ausgeführt wird, wenn dieser
bestimmte Delegat abonniert Die Funktionen werden grundsätzlich vom Delegaten
abonniert. Wenn Sie den Delegaten aufrufen, wird
die Funktion
ausgeführt den Delegaten aufrufen, werden alle Funktionen
benachrichtigt
, die ihn abonniert haben Die Syntax für einen Delegierten in Unity hat den öffentlichen Delegaten ungültig gemacht Mein Delegierter ist öffentlich statisch,
Mein Delegierter, Mein Delegierter. Ein Delegat in Unity
CR wird mithilfe des Schlüsselworts delegate
gefolgt
von einem Rückgabetyp definiert mithilfe des Schlüsselworts delegate
gefolgt
von Eine Mitgliedsvariable
wird anhand
des Elementtyps, gefolgt
vom Variablennamen, deklariert des Elementtyps, gefolgt
vom Variablennamen Sehen wir uns also einige
der
Delegatentypen in UnityChar an, okay? Einzelne Autos delegieren. Einzelfahrzeuge delegieren Punkte an eine einzelne Funktion oder Methode Eine einzelne Funktion
wird abonniert oder dem Delegierten
zugewiesen, wobei das Gleichheitszeichen
verwendet Das ist also eine Syntax für den Delegaten
einzelner Autos bei der wir den Delegaten
mit einem Gleichheitszeichen angeben, wir geben den Namen
der Funktion an Dann haben wir
Multicast-Delegierte. Multicast-Delegat verweist auf eine oder mehrere
Funktionen oder Methoden. Wenn
ein Multicast-Delegat aufruft ein Multicast-Delegat aufruft alle Funktionen aufgerufen, die
ihn nacheinander abonnieren, eine nach der anderen Funktionen abonnieren den Delegaten, indem
Plus gleich Sinus
ist,
und melden ihn wieder ab, wenn Minus gleich Sinus und Das ist also die Syntax
eines Multicast-Delegaten. Delegat plus entspricht dem
Namen der Funktion. Das war's, Leute.
Danke für die Sitzung. In der nächsten Sitzung werden
wir
ein Beispiel für
Delegierte in Unity erstellen . Scharf C. Vielen Dank, Leute.
47. Delegierte in einem Single-Cast verstehen: Hallo Freunde, Mein Name
ist Rohan Vase. In dieser Sitzung werden
wir ein Beispiel
für einen
Singlecast-Delegierten in Unity erstellen für einen
Singlecast-Delegierten in Wir haben
hier bereits zwei Skripte erstellt. Eines ist Ihr Delegate-Handle
und das andere ist mein Skript. Okay,
lassen Sie uns nun damit beginnen, ein leeres Spielobjekt zu erstellen Um hier ein leeres
Spielobjekt zu erstellen, klicken Sie hier mit der
rechten Maustaste auf
die Delegierten-Szene Okay, gehe zum Spielobjekt und
gehe hier zu Erstellen, Leeren. Okay? Benennen Sie das Spielobjekt
in Delegiertenobjekt um, okay? Und füge einfach das
Skript-Delegate-Handle an dieses leere
Spielobjekt hier an, okay? Klicke
hier auf Komponente hinzufügen und
suche nach dem
Delegate-Handle-Skript, okay? Und lassen Sie uns das Skript anhängen. Lassen Sie uns einfach das Skript hier öffnen und ein Stück Code schreiben. Lassen Sie uns den Delegaten hier
in diesem
Delegate-Handle-Skript im Grunde definieren in diesem
Delegate-Handle-Skript Okay, lassen Sie uns die
Start- und
Aktualisierungsfunktionen von hier entfernen Start- und
Aktualisierungsfunktionen von hier Wir brauchen sie nicht, okay? Um nun den Delegaten zu definieren,
okay, zuerst müssen wir den Zugriffsmodifikator
angeben In diesem Fall
wird es öffentlich sein. Okay, dann werden wir
ein Schlüsselwort delegate verwenden , um im Grunde
einen Delegaten zu definieren Und dann müssen wir den Rückgabetyp
angeben
, der breit ist, weil wir
von diesem
Delegaten nichts zurückgeben werden von diesem
Delegaten nichts zurückgeben Okay, lassen Sie uns einfach
den Namen des Delegierten angeben. Behalten wir ihn als meinen Delegierten. Okay, dann lassen Sie uns einfach
eine Mitgliedsvariable für
diesen bestimmten Delegaten erstellen eine Mitgliedsvariable für , den wir gerade erstellt haben Okay? Also lassen wir
den Zugang auch hier
öffentlich.
Halte es statisch. Okay? Und dann mein Delegierter, okay, der Name des Delegierten,
den wir gerade hier erstellt haben Und dann übergeben Sie einfach die
Variable an den Delegierten. Okay,
behalten wir es als meine Aufgabe. Okay, das ist es.
Okay, dann haben wir erstellt, wir haben hier einen Delegierten
als meinen Delegierten definiert Okay, das ist der Name
des Delegierten. Und dann haben wir eine
Mitgliedsvariable, my del,
für meinen Delegierten erstellt , die wir hier oben erstellt
haben Okay, lassen Sie uns hier eine
Funktion erstellen,
die tatsächlich
auf der Schaltfläche funktioniert Klicken Sie auf den Klick einer Schaltfläche. Wir werden
eine Schaltfläche in der Benutzeroberfläche erstellen und über die Schaltfläche diesen
bestimmten Delegierten aufrufen Okay, lassen Sie uns hier eine
Funktion dafür erstellen, public void, my click Okay, lassen Sie uns
die Variable hier übergeben, mein Dell. Innerhalb des Klicks. Wenn wir auf die
Schaltfläche beim Klicken auf die Schaltfläche klicken, nennen
wir diese
spezielle Funktion My Click. Dann übergeben wir das My Dell in
die My-Click-Funktion, wodurch der
Delegate aufgerufen wird, den wir gerade erstellt
haben, okay? Okay, das Bild wird
in der Mitte erstellt. Wir fügen dem Bild kein
Sprite hinzu, im Grunde genommen für dieses
spezielle Beispiel, okay? Wir werden die Farbe für
das Bild ändern. Im Moment ist es weiß
, okay? Also werden wir
die Farbe mithilfe des Codes ändern, im Grunde über das Skript und auch über den Delegaten Wir haben hier bereits
ein Skript erstellt ,
das mein Skript ist Okay, lassen Sie uns einen Code
in das Skript schreiben , um die Farbe für
das Bild grundsätzlich zu ändern. Okay, wir brauchen
hier
in meinem Skript keine Aktualisierungsfunktion. Lassen Sie uns hier eine Funktion erstellen, um die Farbe des Bildes zu ändern. Okay, also d, nennen wir die
Funktion Farbe ändern. Okay? Um die
Farbe für das Bild zu ändern, müssen
wir die
Komponente Image
für das Bild-Spielobjekt aufrufen .
Also, wie machen wir das? Okay, das Spielobjekt
erhält kein Komponentenbild. Okay? Farbe entspricht. Um dem Bild eine zufällige
Farbe zuzuweisen, verwenden
wir eine
Funktion in der Unity-Engine, nämlich
die zufällige Punktfarbe HSV Rufen wir dazu zunächst die
Unity-Engine auf. Okay? Dann rufen wir die
Zufallsfunktion darin auf, wählen Farbe H, zufällige
Farbe H, okay? Und Color HSV ist eine Funktion. Okay? Dadurch werden also im Grunde zufällige Farben auf die
Bildfarbkomponente
angewendet. Okay? Nun, diese Image-Komponente
hier zeigt einen Fehler, hauptsächlich weil wir hier Unity Engine verwenden müssen. Okay, Unity Engine. Okay, jetzt müssen wir hier
unseren Delegierten anrufen. Der Delegat, den wir gerade
im Delegate-Handle-Skript definiert
haben . Wir müssen hier
im Grunde mein Dell in der
Startfunktion meines Skripts aufrufen im Grunde mein Dell in der
Startfunktion meines Skripts Also wie machen wir das? Wir übergeben einfach den Verweis auf das
Delegate-Handle-Skript und dann müssen wir nur
meinen Del hier anrufen, okay? Entspricht. Daran können wir die
Funktion Farbe ändern übergeben Okay? Die Funktion zum Ändern der
Farbe lautet dann „Mein Delegierter“ abonnieren Okay, wenn wir meinen Delegaten anrufen, wird die Funktion „Farbe
ändern“ ausgeführt. Okay,
sagen wir jetzt einfach das Drehbuch. Wenden wir dieses Skript auf das Bildspielobjekt
auf der Schaltfläche an. Klicken Sie, wir wollen den Delegierten
anrufen, okay, den wir gerade definiert haben Gehen Sie hier zur Schaltfläche, und dann können Sie es sehen, wenn Sie hier
klicken, okay? Klicken Sie hier einfach auf das Pluszeichen , um die Funktion hier
zur Liste hinzuzufügen. Denn im Moment ist es leer. Wir müssen die Funktion hinzufügen. Wir müssen meinen Klick hinzufügen. Okay? Wenn wir
diese Funktion aufrufen, mein Klick,
wird mein Delegierter aufgerufen Okay, lassen Sie uns meine
Klick-Funktion dazu hinzufügen, okay? Lass uns das
Delegate-Objekt einfach hierher ziehen und dort ablegen, okay? Und dann wird derzeit
keine Funktion angezeigt, weil wir
keine Funktion angehängt haben . Klicken Sie
einfach darauf Gehen Sie hier zum
Delegate-Handle, zum Skript. Delegieren Sie das Handle und wählen Sie einfach meinen Klick hier aus. Das ist es Wenn ich jetzt hier auf
die Schaltfläche klicke, sollte sich
die Farbe des
Bildes ändern. Okay? Wählen Sie hier einfach Image
Game Object aus und lassen Sie uns sehen, wie sich die Farbe
hier beim Klicken auf die Schaltfläche ändert und auch hier, okay. Ja, wir können jetzt die
Farbe beim Klicken auf die Schaltfläche ändern. Das ist es. Das
war's für die Sitzung. In der nächsten Sitzung werden wir
ein Beispiel für
Multicast-Delegate in Unity sehen ein Beispiel für
Multicast-Delegate in Ich danke euch vielmals, Leute.
Ich danke euch vielmals.
48. Multi-Cast-Delegierte verstehen: Hallo Freunde, mein Name
ist Rohan Vase. In dieser Sitzung
werden wir
ein Beispiel für
Multicast-Delegate erstellen . In der letzten Sitzung haben wir
ein Beispiel für Single
Cars Delegate erstellt ein Beispiel für Single
Cars Und mit einem
Knopfdruck konnten
wir die Farbe für
das Bild auf diese Weise ändern Okay, in dieser Sitzung werden wir dem Delegierten
im Grunde eine weitere Funktion
hinzufügen Wenn Sie auf die Schaltfläche klicken, wird nicht nur die Farbe
geändert, sondern auch
die Position des Bildes auf
der X-Achse verschoben Bildes auf
der X-Achse Hier ist der Unterschied zwischen einem einzelnen Cars-Delegierten
und einem Multicast-Delegierten In einem einzelnen Cars-Delegaten kann einem Delegierten nur eine einzige Funktion
zugewiesen oder abonniert
werden zugewiesen oder abonniert Und im Multicast-Delegaten können dem Delegaten mehrere Funktionen
oder Methoden
zugewiesen oder abonniert werden zugewiesen oder Fügen wir dem Skript eine weitere
Funktion hinzu. Und lassen Sie uns diese Funktion auch
bei diesem Button-Klick aufrufen . Fügen wir
hier eine Funktion hinzu, um
die Position für das Bild zu ändern . Nennen wir die Funktion als
geänderte Position, okay? Um nun die Position zu ändern, verwenden
wir die
Transformationspunktposition für das Spielobjekt, okay? Im Grunde werden
wir die
Position
des Transformationspunkts ändern und hier den neuen Vektor t verwenden. Ein neuer Vektor, der hier funktioniert, ist die
Angabe
der Richtung von zwei beliebigen Spielobjekten. Lassen Sie uns die
Position des Transformationspunkts für das Bild ändern. Um dieses
Spielobjekt zu erstellen, muss die
Transformationsposition dem
neuen Vektor 2 entsprechen Okay? Das ist die
Funktion von Unity. Und wir müssen hier
die Parameter
für eine Funktion übergeben , okay? Wir wollen die
Position für das Spielobjekt ändern. Grundsätzlich auf der X-Achse transformiert das
Spielobjekt die Position x. Lassen Sie uns
jedes Mal, wenn wir
auf die Schaltfläche hier klicken, 20 Fließkommazahlen hinzufügen . Okay, auf der Y-Achse wollen
wir die Position ab
Position Y nicht
ändern , wir wollen sie konstant halten. Eine Sache noch, lassen Sie uns
diese Funktion
zum Ändern der Position dem Delegierten hier zuweisen , okay? Nun, in der letzten Sitzung, haben
wir
diese
Funktion zum Ändern der Farbe bereits für Del abonniert ,
okay, und zwar gleich dem Sinus Wenn Sie nun möchten, dass der Delegate
mehrere Funktionen abonniert, müssen
Sie hier einen
Plus-Sinus hinzufügen Okay? Also ändern wir
es auf plus gleich. Okay? Dann weisen wir dem Del wieder die
Funktion „Position
ändern“ zu. Okay, also mach das. Lassen Sie uns noch einmal
eine Referenz an den
DL-Delegierten weitergeben noch einmal
eine Referenz an den
DL-Delegierten Okay, das p ist gleich, lassen Sie uns den Namen der
Funktion übergeben, die Position ändern Okay, das ist es. Okay, speichern wir das Drehbuch. Okay, sehen wir uns hier die
Ausgabe für den Code an. Klicken Sie hier einfach auf das
Bildspielobjekt. Im Moment ist die Position X für das
Bildspielobjekt Null und die Position für das
Bildspielobjekt ist Null. Wir werden die Position
für das Bild-Spielobjekt nicht ändern , wir werden nur die Position für
das Bild-Spielobjekt jedes
Mal
ändern , wenn wir auf die Schaltfläche klicken. Hier werden 20 hinzugefügt. Okay, lassen Sie uns die Szene laufen lassen
und uns die Ausgabe ansehen. Okay, also lass uns
auf die Schaltfläche klicken. Okay, es wurden 20 hinzugefügt. Noch einmal
klicke ich auf die Schaltfläche, es sind 40, jetzt 60, und ja, das ist es. Ich ändere auch die Position
und die Farbe. Das war's also, Leute.
Danke für diese Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
49. Einführung in Delegierten-Events: Hallo Freunde, Ich
heiße Rohan Sud. In dieser Sitzung
werden wir sehen, was Geschehnisse in Unity
sind. Scharf C. Grundsätzlich können wir Veranstaltungen mit
Delegierten in Unity
Sharp
nutzen . Was sind Ereignisse? Ereignisse sind spezielle
Multicast-Delegierte , die sich genauso verhalten
wie Delegierte Im Gegensatz zu Delegaten, die von anderen Skripten aufgerufen
werden können, können
Ereignisse nur
innerhalb ihrer Klasse aufgerufen werden . Oder ein Skript. Der Unterschied zwischen Delegierten
und Veranstaltungen ist wie folgt. Jetzt haben wir bereits in den letzten Sitzungen gesehen, wie Sie einen
Delegierten
definieren Die Definition eines Delegaten in Delegate behandelt public delegate void,
My delegate public
static, my delegate del einem anderen Skript
aus aufrufen, Delegaten-Handle Punkt del Einen Delegaten von einem anderen Skript
aus aufrufen, Delegaten-Handle Punkt del. Der obige Code wird ausgeführt,
ohne dass ein Fehler auftritt. Dieses Delegaten-Handle domidel, bei dem wir
den Delegaten tatsächlich aufrufen, indem wir die Referenz
des Skripts übergeben ,
wird Es wird
kein Fehler bei der Definition eines
Ereignisses in Delegate Handle,
Dotscript, public delegate void, my delegate public static event,
my delegate my delegate Wir verwenden also ein Event-Schlüsselwort
im Grunde genommen, um ein Ereignis zu definieren, indem wir
versuchen, ein Ereignis von einem
anderen Skript aus aufzurufen, das Delegaten-Handle anderen Nun
erzeugt der obige Code einen Fehler und
der Fehler ist, dass das
Delegate-Handle del nur
auf der linken
Seite von plus gleich oder minus gleich
y stehen kann Delegate-Handle del nur
auf der linken
Seite von plus gleich oder minus gleich . Del
kann nicht direkt übergeben
oder direkt
in einem anderen Skript verwendet werden, wenn es sich im Grunde um kann nicht direkt übergeben
oder direkt
in einem anderen Skript verwendet werden ein Ereignis
handelt Okay, warum sollte man Ereignisse
zusammen mit Delegierten verwenden? Ereignisse bieten Sicherheit, da sie nicht
durch andere Skripten ausgelöst werden können. Die Logik im Spiel wird nicht
offengelegt, wenn wir Ereignisse verwenden. Event sorgt dafür, dass, wenn ein Delegat
als Teil einer Klasse deklariert wird, nur die
Methoden zum Hinzufügen und Entfernen gemäß
dem
Zugriffsmodifikator verfügbar gemacht werden, der dem Ereignis zugewiesen wurde Okay, nehmen wir an, Sie haben eine Zeitschriftenfirma
und die Leute können Ihr Unternehmen
abonnieren, um jeden Monat eine neue
Zeitschrift
zu erhalten Sie können sich diesen Delegierten
als die Zeitschriftenfirma vorstellen. Und bei der Veranstaltung können die Leute Ihr Magazin
oder Ihre Zeitschriftenfirma
abonnieren Wenn also eine neue
Ausgabe herauskommt, informiert
die Veranstaltung im Grunde alle Personen, die bereits angemeldet haben ,
darüber, dass eine
neue Ausgabe veröffentlicht wird. Und ja, Sie sind jetzt
bereit, das Magazin zu bekommen. Okay. Also das war's Leute.
Danke für die Sitzung. In der nächsten Sitzung werden
wir zusammen mit Delegate ein Beispiel für
Veranstaltungen erstellen Ich danke euch vielmals, Leute. Wir sehen uns in
der nächsten Sitzung.
50. Bewege ein UI-Bild mit Delegate-Events nach links und rechts: Hallo Freunde, mein Name ist Ron Sede. In dieser Sitzung
werden wir
ein Beispiel für
Delegierte mit Veranstaltungen erstellen ein Beispiel für
Delegierte mit Okay, zu diesem Zweck haben wir hier in der Mitte ein Bild
erstellt, und dann haben wir hier
zwei Schaltflächen. Okay, wir haben auch
ein leeres Spielobjekt, ein
Event-Objekt, erstellt und hier ein
Skriptdelegate-Ereignis
angehängt Im
Delegate-Event-Skript werden
wir
Delegate und Ereignisse
auch für das Bild deklarieren .
Hier haben wir
ein Skript-Event-Skript angehängt , in dem wir
einen Code schreiben werden , um das Bild nach links oder rechts zu bewegen Deklarieren wir
zuerst einen Delegierten, einen Delegierten. Dieser Delegierte
wird nichts zurückgeben. Okay, lassen Sie uns den Delegierten als
Delegierten benennen. Dann deklarieren wir ein
Ereignis, öffentlich, statisch. Okay, wir deklarieren ein Ereignis
mit einem Event-Schlüsselwort und verlassen
dann den Delegaten, links Okay, dann deklarieren wir
einen anderen Delegierten. Delegierter, richtiger Delegierter. Lassen Sie uns ein anderes Ereignis deklarieren, öffentliches statisches Ereignis,
rechter Lassen Sie uns nun hier
Funktionen erstellen, um sie separat für den linken
Delegierten der
Funktion zu Und die andere Funktion
ruft den rechten Delegierten auf, den
öffentlichen linken Delegierten öffentlichen In dieser Funktion
rufen wir den linken Delegierten auf. Okay, lassen Sie uns
hier
eine weitere Funktion deklarieren , die Right Delegate,
Public Void, Right Delegate aufruft Public Void, Right Innerhalb dieser Funktion werden
wir den Delegaten aufrufen. Okay, lassen Sie uns
zwei Funktionen deklarieren, public id, left Dies dient dazu, das
Bild auf
der X-Achse nach links zu verschieben . Das ist es. Dieser Code verschiebt das
Bild nach rechts. Jetzt abonnieren wir hier
unsere Funktionen, gehen nach links und gehen nach
rechts zu den Ereignissen. Um das zu tun, übergeben wir einen
Verweis auf das Skript. Ereignis nach links delegieren plus entspricht Bewegung
nach links, okay? Und Ereignis nach rechts delegieren
plus entspricht Bewegung nach rechts plus entspricht Bewegung Das ist es. Sagen wir das Drehbuch. Okay, gehen wir hier
zur linken Schaltfläche und klicken
hier auf
das Plus-Symbol. Okay, lassen Sie uns
das Event-Objekt hier verfolgen und ablegen. Okay? Und lassen Sie uns die Funktion an das
Delegiertenereignis hier anhängen, okay? Und fügen Sie hier die linke
Delegiertenfunktion hinzu. Okay? Jetzt auf die gleiche Weise. Gehen Sie hier zur rechten Maustaste, klicken Sie hier auf das Pluszeichen und
ziehen Sie das Event-Objekt hierher. Und dann gehe zur Funktion Delegate
Event. Und wähle Ausführen, richtig? Delegieren Sie hier. Okay, das ist
es also. Lass uns die Szene durchgehen lassen. Und sehen wir uns die Ausgabe hier an. Okay, lass uns auf
die linke Taste von Moo klicken. Okay, das Bild
bewegt sich nach links. Lass uns auf den rechten Button klicken. Das Bild bewegt sich
nach rechts. Das war's also, Leute.
Danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
51. Einführung in das Unity Eingabesystem: Meine Freunde, mein
Name ist Rohan Sev. In dieser Sitzung
werden wir etwas
über das Eingabesystem in Unity lernen über das Eingabesystem in Was ist ein Eingabesystem? Das Eingabesystem implementiert ein System zur Verwendung
beliebiger Eingabegeräte. Es könnte Ihre Maus sein, es könnte Ihre Tastatur usw. sein
, um
Ihre Unity-Inhalte zu steuern Das Eingabesystem
besteht aus zwei Teilen, Eingabeklasse und dem Eingabemanager Methoden aus der Eingabeklasse werden verwendet, um
Eingaben in einem Spiel zu implementieren. Input Manager legt
die Projekteinstellungen fest, die Schaltflächen auf Eingaben zugreifen. Tastendrücke und
Mausklicks können von realen Geräten
virtuellen Eingaben
zugewiesen werden . Dieser Eingabemanager befindet sich im Eingabemanager
Projekteinstellungen bearbeiten. So würde ein
Input-Manager aussehen. Okay, wie bereits erwähnt, kann das
Eingabesystem in Unity grundsätzlich jede Art von
Eingabegerät
implementieren. Sehen wir sie uns eins nach dem anderen an. Tastatureingaben. Das
Eingabesystem kann verwendet werden, um Tastatureingaben zu implementieren oder zu
erkennen. Wir können Eingaben durch
verschiedene Operationen erhalten , die auf der Tastatur
ausgeführt werden. Einige dieser Operationen lauten
wie folgt. Taste nach unten drücken. Das Drücken der Taste nach unten wird ausgelöst. Grundsätzlich gilt: Wenn Sie eine beliebige
Taste drücken, drücken Sie die Taste nach unten. Funktion wird hier ausgelöst und innerhalb der Funktion
in den Klammern müssen
wir den
Tastencode angeben. Der Punktabstand wird
hier verwendet, um die
Leertaste auf der Tastatur zu identifizieren Es gibt verschiedene solche Werte, Unity akzeptiert
Tastatureingaben Halten gedrückt
halten, Taste gedrückt halten wird ausgelöst, wenn Sie
die Taste drücken und gedrückt halten. Im Grunde wird die Funktion „Eingabepunkt
abrufen ausgelöst, wenn Sie
die Taste gedrückt halten, okay? In der Funktion zum
Abrufen des Eingabepunkts müssen
Sie
die Taste erneut angeben. Taste losgelassen wird ausgelöst , wenn Sie die Taste drücken
und dann loslassen. Eingabepunkt
wird ausgelöst, wenn Sie die Taste nach dem Drücken wieder
loslassen und
sich innerhalb der Klammern befinden. Auch hier müssen wir
die Tasten- und Mauseingaben angeben. Das Eingabesystem kann auch verwendet werden, um
Mauseingaben zu implementieren oder zu erkennen. Wir können Eingaben durch
Mausklicks und Operationen, die mit der Maus
ausgeführt werden, erhalten . Einige dieser Operationen
lauten wie folgt. Maustaste angeklickt. Erneut auf die Maustaste geklickt, wird ausgelöst, wenn Sie mit der Maustaste
klicken Okay, Eingabepunkt mit gedrückter Maustaste ist die Funktion, die hier
ausgelöst wird. Und Null hier ist die
linke Maustaste. In ähnlicher Weise ist eins für die rechte Maustaste und zwei für die
mittlere Maustaste. Maustaste gedrückt halten, wird der
Eingabepunkt mit der Maustaste
ausgelöst, wenn Sie
die Maustaste gedrückt halten. Lassen ausgelöst, wenn Sie
die Maustaste gedrückt halten Maustaste los. Wenn Sie mit der
Maustaste klicken und sie loslassen, Eingabepunkt mit der Maustaste
nach oben gedrückt wird der
Eingabepunkt mit der Maustaste
nach oben gedrückt, wenn Sie dies tun. Okay, lassen Sie uns
zu den Achseneingaben übergehen. Jetzt bezieht sich eine Achse
auf einen Wert zwischen -1,1, wobei Null
ein Standardwert Analogstick liefert Werte
sowohl auf der vertikalen als auch auf der
horizontalen Achse zwischen -1,1. Das Gleiche gilt für die Tastatur, wo die linken und rechten
Pfeiltasten die horizontale Achse und die Aufwärts
- und Abwärtspfeiltasten die vertikale Achse und die
horizontale Achse bilden Der Eingabepunkt erhält die Achse. Horizontal wird hauptsächlich verwendet , um das Moment auf
der horizontalen Achse zu definieren. Und für die vertikale Achse verwenden
wir den Eingabepunkt, um die vertikale Achse zu ermitteln. Das war's, Leute.
Danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung. In der nächsten Sitzung werden wir
ein Beispiel für die
Implementierung von Tastatureingaben sehen . Immunität.
Vielen Dank, Leute.
52. Tastatureingaben in Unity verstehen und umsetzen: Hallo Freunde, mein Name ist Roan Sev. In dieser Sitzung
werden wir
Tastatureingaben in Unity implementieren Tastatureingaben in Unity Okay, zu diesem Zweck haben
wir hier bereits
ein leeres Spielobjekt, ein
Eingabesystemobjekt, erstellt . Und wir haben auch ein Skript
erstellt. Und der Name des Skripts
lautet Tastatureingaben. Wir haben ein Skript
an das leere Spielobjekt angehängt,
das ein Eingabesystemobjekt ist. Lassen Sie uns einen Code
in das Tastatureingabeskript schreiben. Innerhalb des Skripts müssen
wir
alle Tastatureingaben innerhalb
der Aktualisierungsfunktion in Unity implementieren alle Tastatureingaben innerhalb
der . Zunächst müssen wir
überprüfen, welche Art von Operation auf der Tastatur
ausgeführt wird. Bei diesen Vorgängen
wird Ihre Taste gedrückt, Taste wird kontinuierlich gedrückt
und zuletzt wird Ihre Taste losgelassen. Okay,
lassen Sie uns zunächst anhand einer If-Bedingung überprüfen, ob die Taste gedrückt
wurde oder nicht. Okay? Lassen Sie uns hier
eine Wenn-Bedingung deklarieren. Geben Sie die Taste
in die Klammer ein. Hier müssen wir den Schlüssel angeben. In diesem Fall werden wir hier auf
der Tastatur
eine Leertaste verwenden , okay? Tastencoderaum. Das ist im Grunde für die Leertaste auf
der Tastatur, okay? Und darin drucken wir
etwas in der Konsole aus. Let's Print-Taste wurde gedrückt, okay? Funktion „Eingabepunkt, Taste runter“. Wir werden prüfen, ob
die Leertaste auf der Tastatur gedrückt
wurde oder nicht. Lassen Sie uns implementieren, ob die Taste kontinuierlich gedrückt
wurde oder nicht. Okay, lass uns eine weitere
Bedingung dafür schreiben. Eingabepunkt erhält Schlüssel, Tastencoderaum. Lassen Sie uns
auch kontinuierlich etwas innerhalb von
Dysfunktion drucken . Lassen Sie uns abschließend überprüfen, ob die gedrückte Taste losgelassen
wurde oder nicht. Um das zu tun, schreiben wir hier,
ob Bedingung, Eingabe eingetippt wird. Okay? Und lassen Sie uns die Taste, die
Leertaste, angeben , ob die Leertaste
losgelassen wurde oder nicht,
nachdem sie gedrückt wurde. Okay, lassen Sie uns drucken, veröffentlicht. Fügen wir
hier zwei weitere Funktionen hinzu, um zu überprüfen, ob
der Spieler auch die linke
Pfeiltaste und die rechte
Pfeiltaste
gedrückt hat die linke
Pfeiltaste und die rechte
Pfeiltaste
gedrückt . Okay, lass uns hier
noch eine Bedingung schreiben. Geben Sie dazu den Punkt ein, holen Sie den Tastencode nach unten und drücken Sie den
Linkspfeil hinein Wir drucken und drücken Sie Okay. Und um zu überprüfen, ob der Spieler die
rechte Pfeiltaste gedrückt
hat oder nicht, geben wir hier
noch eine weitere Bedingung an. Wenn bei der Eingabe der Tastencode Rechtspfeil nach unten angezeigt wird, drucken
wir die gedrückte
Rechtspfeiltaste aus. Okay. Zuerst drücke ich
hier einfach die Leertaste auf
meiner Tastatur Und lassen Sie uns hier überprüfen, was die Ausgabe
ist. Okay, die Taste
wurde gedrückt, Taste wurde
ununterbrochen gedrückt. Zu diesem Zeitpunkt habe ich
die Taste gedrückt, quasi ununterbrochen
gedrückt. Und zuletzt
wurde die Taste losgelassen, also habe ich zu diesem Zeitpunkt
die Leertaste losgelassen. Okay, versuchen wir es mit den Pfeiltasten
links und rechts. Ich werde jetzt meine
linke Pfeiltaste drücken. Okay, also die linke
Pfeiltaste erneut gedrückt. Linke Pfeiltaste gedrückt. Ich werde jetzt
meine rechte
Pfeiltaste auf der Tastatur drücken . Okay, die rechte
Pfeiltaste wurde erneut gedrückt. Rechte Pfeiltaste gedrückt. Das war's also, Leute, vielen Dank
für die Sitzung. In der nächsten Sitzung
werden wir uns die Mauseingaben in Unity ansehen . Vielen Dank, Leute.
53. Mauseingaben in Unity verstehen und umsetzen: Hallo Franz. Mein Name ist Rohan Sev In dieser Sitzung werden wir die Mauseingabe, Unity, implementieren Zu diesem Zweck
haben wir bereits
ein leeres
Spielobjekt-Eingabesystemobjekt erstellt . Hier haben wir auch
eine Skript-Mauseingabe erstellt. Und wir haben
das Skript an
das leere
Spielobjekt-Eingabesystemobjekt angehängt . Lassen Sie uns das Skript öffnen und einen Code schreiben. Um
Mauseingaben in Unity zu implementieren, müssen
wir
Mauseingaben innerhalb der Aktualisierungsfunktion implementieren. Wie bei
Tastatureingaben müssen
wir überprüfen
, welche Operationen mit der Maus
ausgeführt wurden. Diese Operationen würden zum ersten Mal mit der
Maustaste dann kontinuierlich mit der Maustaste
angeklickt werden Schließlich wird die Maustaste nach dem Drücken
wieder losgelassen. Lassen Sie uns überprüfen, ob
die Maustaste angeklickt
wurde oder nicht Schreiben wir dazu hier
eine Bedingung. Bei der Eingabe wird die Maustaste in die Klammer
gedrückt. Hier müssen wir angeben,
welche Maustaste, ob es sich um eine
linke Maustaste
handelt, ob es sich um eine
rechte Maustaste oder um eine mittlere Maustaste handelt. Okay, Null ist für die
linke Maustaste, eins für die
rechte Maustaste und zwei für die
mittlere Maustaste. Okay, lassen Sie uns
etwas darin drucken. Schreiben wir eine weitere Bedingung oder verwenden wir eine Funktion in der
Pot-Get-Maustaste, um zu überprüfen, ob die Maustaste kontinuierlich gedrückt
wurde oder nicht. Okay? Also, wenn die Eingabe
mit der Maustaste
erfolgt, setzen wir Null
rein, okay? Und lassen Sie uns kontinuierlich etwas
darin drucken. Okay? Lassen
Sie uns abschließend überprüfen, ob die Maustaste
nach dem Drücken
losgelassen wurde oder nicht. Okay? Wenn bei der Eingabe die
Maustaste nach oben gedrückt wird, fügen
wir
wieder eine Null für die linke Maustaste hinzu, dann drucken wir die
Maustaste. Okay. Okay Leute, also werde ich hier mit der
linken Maustaste klicken. Also ja, die
Maustaste wurde zum ersten Mal gedrückt, dann die Maustaste kontinuierlich
gedrückt Zu diesem Zeitpunkt habe ich
die Maustaste gedrückt gehalten und
sie hier nicht losgelassen Also druckte es weiter, die
Maustaste
ununterbrochen gedrückt zu halten, bis ich die Maustaste
losließ Endlich hier. Das war's also, Leute. Danke für die
Sitzung. Wir sehen uns in der nächsten Sitzung. In der nächsten Sitzung werden wir Zugriffseingaben in Unity
implementieren. Vielen Dank, Leute.
54. Axis-Eingaben in Unity verstehen und umsetzen: Hallo Freunde, mein
Name ist Rohan Dev. In dieser Sitzung werden wir
lernen, auf Eingaben in Unity zuzugreifen Zugangseingaben beziehen sich auf die
horizontale und vertikale Achse, und der Wert wird in
Fließkommazahlen zwischen
minus eins und eins liegen . Okay, zu diesem Zweck haben
wir bereits ein
Eingabesystemobjekt erstellt, bei dem es sich um ein leeres Spielobjekt handelt. Und wir haben auch
ein Skript für den Zugriff auf Eingaben erstellt. Und wir haben die
Skriptzugriffseingaben bereits
an das leere
Spielobjekt-Eingabesystemobjekt angehängt Skriptzugriffseingaben bereits
an das leere
Spielobjekt-Eingabesystemobjekt . Lassen Sie uns einen
Code in die Zugriffseingabe schreiben. Skriptachseneingaben
beziehen sich auf die Werte oder Gleitwerte zwischen -1,1 sowohl auf der
horizontalen als auch auf der vertikalen Achse Ein Analogstick
liefert Werte für die horizontale und
vertikale Achse zwischen -1,1. Das Gleiche gilt für die Tastatur Die horizontale Achse wird
Ihre linke und rechte Pfeiltaste sein Ihre linke und rechte Pfeiltaste und die vertikale Achse
Ihre Aufwärts- und
Abwärtspfeiltasten für die Tastatur Schwebe,
schwebe vertikal. Okay? In der Aktualisierungsfunktion weisen
wir
der Variablen horizontal einen Wert zu. Und dieser Wert wird eingegeben, die Achse horizontal zu erhalten, horizontal entspricht der Eingabe, Achse wird horizontal Innerhalb der doppelten
Vertikalen befindet sich
Ihre Eingabe, um die vertikale Achse zu ermitteln, wobei horizontale Achse
auf der horizontalen Achse größer als Null Wenn der Wert
größer als Null ist, bedeutet das, dass der Spieler die rechte Pfeiltaste gedrückt
hat. Okay, lassen Sie uns den
Wert auch für die horizontale Position drucken. Lassen Sie uns nach rechts drucken. Wenden wir hier eine
Else-Bedingung an, L horizontal kleiner als Null. Das bedeutet einfach, dass
der Spieler auf
die linke Pfeiltaste drückt , waagerecht
drucken. Lassen Sie uns die Linkskurve
innerhalb dieser Linkskurve drucken. Das ist für die horizontale Achse. Lassen Sie uns einige Bedingungen
für die vertikale Achse anwenden, deren Vatikanwert größer als Null Dadurch wird geprüft, ob der Spieler die Pfeiltaste gedrückt
hat Wenn der Spieler die Pfeiltaste drückt
, der Wert von Tic größer
als Null. Und wenn der Spieler
auf die Abwärtspfeiltaste drückt, der Wert für Vatical
kleiner als Null Lassen Sie uns den
Wert für vertikal angeben. Wenden wir für
diesen Tic eine L-Bedingung diesen Tic kleiner als Null ist. Okay Leute, auf meiner Tastatur drücke
ich die
linke Pfeiltaste und drucke den Wert für die
horizontale Achse aus. Okay, also lass uns das nach unten scrollen. Okay, es ist links abgebogen und hier
wird minus eins angezeigt. Okay, also werde ich meine rechte Pfeiltaste
drücken. Jetzt ist der Wert für die
horizontale Achse eins. Und es druckt hier
rechts abbiegen. Ich werde
meine Pfeiltaste nach oben drücken. Jetzt ist der Wert für die vertikale Achse
hier eins und er wird gedruckt. Okay, ich werde
meine Abwärtspfeiltaste drücken. Jetzt ist der Wert für die vertikale
Achse minus eins und er wird hier unten gedruckt. Okay, das war's also, Leute. Danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
55. Einführung in die Physik Engine und Rigidbody: Freunde. Mein Name
ist Rohan Vasudev In dieser Sitzung
werden wir über
Physik und Eiskörper in Unity sprechen . Physik in Unity wird von der
Built In Physics Engine verwaltet .
Unity ist eingebaut. Physics Engine steuert die Physik für Interaktionen mit Spielobjekten und verschiedene Effekte wie Schwerkraftbeschleunigung,
Kollisionen usw. Unity simuliert die
Physik, um sicherzustellen, dass die Objekte korrekt beschleunigen und auf Kollisionen,
Schwerkraft und verschiedene andere Kräfte reagieren ,
Schwerkraft und Um ein überzeugendes
physikalisches Verhalten zu
erzielen, muss ein Objekt in einem Spiel korrekt
beschleunigen und durch Kollisionen,
Schwerkraft und andere Kräfte beeinflusst
werden ,
Schwerkraft und Die in der Physics Engine integrierte Unity bietet Komponenten,
die die physische Simulation
für Sie übernehmen die die physische Simulation
für Sie sich passiv und realistisch verhalten In Unity gibt es zwei separate
Physik-Engines, eine für Thredyphysics und
eine für zwei Die Hauptkonzepte der
beiden Engines sind identisch, ihre Implementierung
ist
jedoch Zum Beispiel gibt es eine
starre Körperkomponente für Thrediphysik und eine
starre Zwei-D-Komponente
für die Zwei-D-Physik für Lassen Sie uns über die Immunität
starrer Körper sprechen. Immunität gegen starre Körper
ermöglicht es einem Spielobjekt nun ,
sich physisch zu verhalten. Es wird mit
anderen Spielobjekten interagieren. Die
Unity-Physik-Engine weiß nur dann , dass
die Physik auf ein Objekt einwirken soll , wenn die
starre Körperkomponente dem Spielobjekt verbunden
ist. Eigenschaften einer starren
Körpermasse, Luftwiderstand, Verwendung von
Winkeln, Schwerkraft ist
nematische Interpolation, Kollisionserkennung Schauen wir uns eins nach dem anderen an, was bedeuten diese Eigenschaften? Lassen Sie uns hier über Masse sprechen. Masse ist die Masse
des Spielobjekts. Luftwiderstand ist der Wert für den Luftwiderstand , der auf das
Spielobjekt
angewendet wird. Winkelförmiger Luftwiderstand. Winkelwiderstand ist der Wert des
Luftwiderstands der
sich kinematisch auf
die Drehung des Objekts auswirkt Wenn diese Option aktiviert ist,
wird das Objekt
von der Physik-Engine in
Unity Interpolate nicht beeinflusst von der Physik-Engine in
Unity Es wird verwendet, um den Moment
der Objektkollisionserkennung zu glätten Moment
der Es ändert die Art der
Kollisionserkennung am Objekt, konstante Einfrierungen, Moment und Drehung um eine bestimmte Achse
des Spielobjekts Das war's, Leute.
Danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
56. Anwende Rigidbody auf das Spielfeld Sphere: Hallo Freunde, mein
Name ist Rohan Sud. In dieser Sitzung werden wir ein Beispiel
für Rigid Body
erstellen Zu Demonstrationszwecken werden
wir
ein dreidimensionales Spielobjekt erstellen , das eine Kugel sein
wird. Und wir werden im Grunde einen starren Körper
auf die Kugel
auftragen . Okay, fangen
wir also damit an, einen Boden zu erstellen , der ein dreidimensionales
Spielobjekt sein wird, das eben ist. dazu zum Spielobjekt,
gehen Sie zum Drei-D-Objekt
und wählen Sie hier Platte aus. Okay? Im Moment ist das Flugzeug auf der Kamera
nicht sichtbar. Setzen Sie dazu einfach den
Transformationswert für die Ebene zurück. Okay, und ja, es ist in der Kamera
sichtbar. Lassen Sie uns erneut ein
Drei-D-Spielobjekt erstellen ,
das eine Kugel ist. Gehe zum Spielobjekt, gehe zum Drei-D-Objekt
und wähle hier Sphäre aus. Setzen Sie hier erneut die Transformation
für die Kugel zurück. Okay, gehe hier in den Szenenmodus und bringe die
Kugel
leicht über den Boden. Okay, so sollte
es aussehen. Die Kugel bleibt im Grunde genommen in der Luft
schweben. Im Moment haben wir noch
keinen starren Körper auf die Kugel aufgebracht . Hören wir auf, die Szene zu wiederholen, und wenden wir den starren
Körper auf die Kugel an. Klicken Sie nun auf Komponente hinzufügen, gehen Sie hier zu Rigid Body und ja, die Starrkörperkomponente ist hier an das
Sphären-Spielobjekt
angehängt. Lassen Sie uns die Szene erneut ausführen und sehen wir uns die Ausgabe hier an. Okay, die Kugel
fällt jetzt auf den Boden. Lassen Sie uns die Eigenschaften
des starren Körpers nacheinander verstehen . Okay, hören wir auf, die
Szene hier nachzuvollziehen. Masse ist hier im Grunde
die Masse für die Kugel. Sie ist momentan auf eins eingestellt. Luftwiderstand ist der Wert für den Luftwiderstand , der auf das
Sphären-Spielobjekt
angewendet wird. Winkelwiderstand ist der Luftwiderstandswert, der wiederum auf das Spielobjekt
angewendet wird und sich auf die
Drehung der Kugel auswirkt. Okay, benutze die Schwerkraft. Hier ist die Gravitationskraft auf das
Sphären-Spielobjekt
ausgeübt wird Wenn wir hier das
Kästchen ankreuzen oder wenn wir hier die Option Use gravity
to true aktivieren, bedeutet
das, dass die
Gravitationskraft hier auf das
Sphären-Spielobjekt ausgeübt
wird Lassen Sie uns
hier das Häkchen bei „Schwerkraft verwenden “ entfernen und
die Szene erneut ausführen Da wir gesagt haben, dass die Eigenschaft „Schwerkraft
verwenden“ hier fällt
, fällt sie jetzt
nicht mehr auf den Boden Lassen Sie uns die
Eigenschaft use gravity wieder auf true setzen. Und die Kugel wird
auf das Planspielobjekt fallen. Okay, hören wir auf,
die Szene wieder laufen zu lassen , das ist
kinematische Eigenschaft Hier wird grundsätzlich
definiert, ob die Physik-Engine
das Spielobjekt beeinflusst oder Setzen wir es hier auf true
und lassen uns die Szene
noch einmal ausführen , indem wir hier is
nematic auf true setzen Der Speer wird im Grunde nicht mehr von der
Physik-Engine
beeinflusst Okay, lassen Sie uns das Objekt abwählen und die Kugel wird auf den
Boden fallen Auch hier ist die Kollisionserkennung im Grunde die
Art der Erkennung, die
auf die Kugel einwirkt Es gibt vier Optionen:
Diskret, kontinuierlich, kontinuierlich, dynamisch und
kontinuierlich, spekulativ Dann müssen wir interpolieren. Interpolieren. Es glättet den
Moment des Spielobjekts Im Moment ist es auf „Keine“ gesetzt. Wir haben hier zwei Optionen:
interpolieren und extrapolieren. Wir werden das verstehen
oder wir werden in den kommenden Sitzungen mehr
darüber erfahren in den kommenden Sitzungen mehr
darüber Okay, die Eigenschaft Constraints wird
hier hauptsächlich verwendet, um die Position oder Drehung
des Spielobjekts auf der X-,
Y- oder Z-Achse
einzufrieren . Lassen Sie uns hier die Y-Achse überprüfen
und schauen, ob die Kugel auf den Boden
fällt oder nicht. Okay, die Kugel fällt
nicht auf den Boden, sie schwebt wieder in der Luft. Lassen Sie uns hier die Y-Achse deaktivieren, und ja, die Kugel fällt
wieder auf den Boden So funktioniert Rigid Body bei einem beliebigen 3-D-Spielobjekt Also das war's, Leute.
Danke für die Sitzung. In der nächsten Sitzung sehen
wir uns ein Beispiel an wie die Kugel mithilfe
einer starren Körperkomponente bewegt werden kann. Vielen Dank, Leute. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
57. Material auf das Spielfeld anwenden: Hallo Freunde, mein Name
ist Rohan Vasudev. In der letzten Sitzung haben wir eine
starre Körperkomponente
auf die Kugel aufgebracht starre Körperkomponente In dieser Sitzung
werden wir
die Kugel mithilfe einer starren
Körperkomponente innerhalb des Skripts verschieben . Diese Sitzung wird aus drei Teilen bestehen. In der ersten Sitzung werden
wir
eine Textur erstellen und die
Textur auf die Kugel auftragen. Im Grunde werden
wir
ein Material erstellen . Was ist ein Material? Material gibt die
optischen Eigenschaften des Spielobjekts an. Zum Beispiel ist es die Farbe, ob es matt oder
glänzend ist. Textur ist im Grunde
ein Bild, bei dem es sich um
einen Zwischenraum oder eine Umhüllung des Spielobjekts handelt, wodurch wiederum
die visuellen Effekte für das Spielobjekt Okay,
lassen Sie uns zunächst
hier einen Ordner erstellen und ein Material erstellen, um einen Ordner zu erstellen
. Klicken Sie mit lassen Sie uns zunächst
hier einen Ordner erstellen und ein Material erstellen, um einen Ordner zu erstellen der
rechten Maustaste hier in den
Assets-Ordner, um ihn zu Und klicken Sie hier auf den Ordner benennen Sie den Ordner in Materialien um. Materialien. Okay? Öffnen Sie
den Materialordner, klicken Sie erneut mit
der
rechten Maustaste hier in den Materialordner
und wählen Sie Material, um ein Material zu erstellen. Okay? Nennen Sie das Material
Beachball oder den Namen, es
könnte alles
Ihrer Wahl sein. Okay, wir haben hier ein
Material für den Ball erstellt. Wir müssen hier die
Textur für den Ball auftragen. Nun, Textur ist,
wie ich bereits sagte,
im Grunde ein Bild, also müssen wir ein Bild
aus dem Internet
herunterladen. Was wir hier tun werden,
ist, dass wir hier im Grunde
eine Beachball-Textur
auf unseren Ball auftragen . Okay, klicken Sie einfach hier auf
die Farbkarte. Okay? Und klicken Sie einfach mit der rechten Maustaste
hier und speichern Sie Bilder. Okay, Bilder. Okay, dein Bild
wurde jetzt heruntergeladen. Klicken Sie einfach auf
Ordner anzeigen, öffnen Sie Unity, gehen Sie zu dem Ordner hier und ziehen Sie das Bild einfach per Drag &
Drop hierher in
den Materialordner. Okay, das ist es. Wählen Sie
das Material erneut aus. Okay, klicken Sie hier auf Albedo,
okay, und wählen Sie einfach
Beach Ball Color Wir haben die Textur
hier auf das Material aufgetragen. Wir müssen dieses Material
auf unser Sphärenspielobjekt anwenden. Klicken Sie hier einfach auf das
Sphären-Spielobjekt. Und innerhalb des Inspektorfensters ziehen Sie
einfach
das Material
für das Speer-Spielobjekt hierher .
Okay, und das war's Wir können hier sehen, dass
Material
aufgetragen wurde oder die Textur hier auf den Ball aufgetragen
wurde. Das war's also, Leute,
danke für die Sitzung. In der nächsten Sitzung werden wir einen Boden
schaffen, auf
dem sich der Ball bewegen kann. Ich danke euch vielmals, Leute. Wir sehen uns in
der nächsten Sitzung.
58. Kreiere einen Boden, auf dem sich die Sphäre bewegen kann: Freunde, mein Name
ist Rohan Vasuev. In der letzten Sitzung haben wir Textur
auf den Ball aufgetragen. In dieser Sitzung werden
wir eine Etage erstellen. Wir haben hier bereits ein
Material für den Boden erstellt. Okay. Und wir
haben auch Textur für den Boden
aus dem Internet heruntergeladen. Okay, lassen Sie uns dieses Material hier
auf das Flugzeug-Spielobjekt anwenden . In diesem Fall
wird Plain unser Stockwerk sein. Wir werden
mehrere einfache Spielobjekte haben , um eine große Etage zu bilden. Bevor wir mehrere
einfache Spielobjekte erstellen, müssen
wir ein
leeres Spielobjekt erstellen und es Floor nennen. Das wird das übergeordnete
Spielobjekt für all unsere einfachen Spielobjekte sein, da wir alles organisieren
müssen. Okay, klicken wir hier mit der rechten Maustaste auf die Szene und erstellen ein
leeres Spielobjekt. Benenne das leere
Spielobjekt hier in Boden um, okay? Und verfolge einfach das einfache Objekt innerhalb des Bodenspielobjekts. Okay, jetzt
müssen wir das Flugzeug
hier mehrmals replizieren , um eine große Etage zu
erstellen Wählen Sie dazu einfach „Spielobjekt
planen“ und klicken Sie auf Steuerung D, um das Spielobjekt
zu replizieren Jetzt müssen wir das Flugzeug anpassen, hier
ein Spielobjekt. Um das zu tun,
müssen wir im Grunde das Verschiebewerkzeug hier im
Editor
ausgewählt lassen und es einfach ziehen. Okay? Sieht es gut aus? Ja, es sieht gut aus.
Ja, es sieht gut aus. Okay, nochmal. Klicken Sie nun hier auf Ebene
ein Spielobjekt und klicken Sie auf Steuerung D. Hier haben
wir unsere Etage erstellt. Okay, lass uns in den Spielmodus gehen
und schauen, wie es aussieht. Bringen wir die Kamera nach oben, um
sie besser sehen zu können. Vielen Dank, Leute. Danke für die Sitzung. In der nächsten Sitzung werden
wir
den Ball mithilfe einer
starren Körperkomponente bewegen . Vielen Dank, Leute. Wir sehen uns in
der nächsten Sitzung.
59. Bewege die Kugel mit Rigidbody, die an ihr angebracht ist: Hallo Freunde. Mein
Name ist Rohan Sev In dieser Sitzung bewegen
wir die Kugel
mithilfe einer starren Körperkomponente, die an der Kugel befestigt ist Zu Demonstrationszwecken haben
wir bereits
eine Bewegung mit starrem Körper erstellt und dem Spielobjekt
Kugel hier ein Skript
beigefügt. Um die Kugel nun zu bewegen, müssen
wir hier
einige Variablen deklarieren. Okay, Float variabel,
vertikal, Float variabel, horizontal A, Floatgeschwindigkeit entspricht fünf Und starrer Körper R B. Okay? Dieser starre Körper R B wird im Grunde verwendet, um die starre Körperkomponente
aus der Kugel zu gewinnen. Um die Starrkörperkomponente zu erhalten, müssen
wir die Funktion get
component in Unity verwenden. Okay? Wir müssen die Starrkörpervariable mit
Get Component Function,
Component, Rigid Body initialisieren, okay? Innerhalb der Aktualisierungsfunktion. Das haben wir bereits
in den vorherigen Sitzungen gesehen. Wie verwenden wir Input
Dot Get Axis? In dieser Sitzung werden
wir Eingaben implementieren. Im Grunde genommen können wir
die Kugel bewegen, aber um die Kugel wieder zu bewegen, verwenden
wir eine starre
Körperkomponente der Kugel. Jetzt entspricht
die
Aktualisierungsfunktion horizontal,
entspricht Okay, lassen Sie uns die
Bedingungen von L hier in
der Aktualisierungsfunktion anwenden ,
um zu überprüfen, ob wir
die Aufwärtspfeiltaste drücken
, ob wir die Abwärtspfeiltaste drücken
, ob wir die Linkspfeiltaste oder ob wir
die Rechtspfeiltaste drücken Wenden wir dazu die erste Bedingung hier
für die vertikale Achse an. Wenn die Vertikale größer als Null ist, wird RB ein Kraftvektor drei in Richtung Geschwindigkeit vorwärts bewegt. Wenden wir eine weitere
If-Bedingung an. Wenn vertikal kleiner als Null. Okay, lassen Sie uns wieder Kraft
auf den starren Körper ausüben Kraftvektor drei, zurück zur Geschwindigkeit. Wenden wir nun Bedingungen für die horizontale Achse an, um zu überprüfen , ob der Spieler
die linke Pfeiltaste oder
die rechte Pfeiltaste gedrückt
hat . Okay? Um das zu tun, gilt
diese Bedingung für
die rechte Pfeiltaste, wenn sie horizontal größer als Null ist. Okay? R B ist ein Kraftvektor drei direkt in die Geschwindigkeit. Und schließlich, horizontal
kleiner als Null, R B, addiere den Kraftvektor drei links Geschwindigkeit, okay? Also bewegt sich der Ball jetzt. Wir können die Geschwindigkeit erhöhen oder verringern
, okay? Zu diesem Zweck müssen
wir hier also zwei weitere Variablen
deklarieren. Öffentliches Spielobjekt,
Kamera, okay? Und dann deklarieren wir eine
weitere Variable von Vektor drei. Nennen wir die
Variable Offset. Diese Variable wird im Grunde
die Entfernung sein, die wir zwischen
der Kamera und dem
Kugelspielobjekt
berechnen werden. Okay, lassen Sie uns der
Offset-Variablen
hier einen Wert zuweisen , okay? Der Beginn des Szenenversatzes entspricht dem dritten Vektor n. Kameratransformationsposition x. Kameratransformationsposition y plus eins. Okay? Wir wollen die Kamera im
Grunde etwas
oberhalb der Y-Achse halten . Und dann Kamerapunkttransformation, Position s minus Transformation DO-Position, Transformations-DO-Position ist hier die Position der Kugel. Okay, jetzt haben wir
den Wert für den Offset festgelegt. Erste Bedingung hier. Wenn vertikal größer als Null. Fügen wir hier eine weitere
Codezeile hinzu. Kameratransformation Position der Kameratransformation
entspricht der
Transformationsposition ist die Position
der Kugel, okay? Plus Ihr Offset
plus die Entfernung. Wir müssen
diesen Code replizieren, okay? Im Grunde genommen unter allen
Bedingungen hier. Schließlich müssen wir auch hier eine Ls-Bedingung
angeben. Wobei, wenn
sich der Ball nicht bewegt, wenn sich der Ball nicht
bewegt,
wir wieder denselben Code angeben müssen. Kameratransformation plus Offset. Okay, das ist es.
Speichern wir das Skript hier und gehen wir zum Editor. Okay, klicken Sie hier auf das
Sphere-Spielobjekt. Klicken Sie einfach auf Made
Camera ziehen Sie das Objekt und
platzieren Sie es einfach hier. Das ist es. Okay. Okay, das ist
es also. Das ist es. Unsere Kamera
verfolgt
auch die Kugel . Das war's also, Leute. Vielen Dank
für die Sitzung. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
60. Einführung in Collider und Kollisionen in Unity: Hallo Freunde. Mein Name
ist Rohan Masudev In dieser Sitzung werden wir über Collider
,
Trigger und
Kollisionen in Unity sprechen Trigger und
Kollisionen in Unity Also, was sind Collider in Unity? Collider sind Komponenten
in Unity, die eine Kollisionserkennung
zwischen den Spielobjekten ermöglichen Sie definieren die Form des Spielobjekts zum Zweck
einer physischen Kollision Außerdem muss ein
starrer Körper an einem der Spielobjekte befestigt sein,
um Kollisionen
zu erkennen Mit Collidern kannst du Kollisionen
abhören und darauf reagieren viele Arten von Collidern, aber hauptsächlich gibt es zwei Typen,
zwei De Collider und drei Collider Für zwei Spielobjekte werden
Collider verwendet. Und für drei Spielobjekte werden drei D-Collider verwendet Lassen Sie uns über Box Collider
Three D sprechen . Wenn Sie nun drei
beliebige Spielobjekte in Unity erstellen drei
beliebige Spielobjekte in Unity standardmäßig
drei D-Collider
daran angehängt,
was durch grüne Randlinien
um das Spielobjekt gekennzeichnet ist grüne Randlinien
um das Auf dem Bild hier können
wir sehen, dass wir ein
Spielobjekt mit drei Würfeln
erstellt haben ein
Spielobjekt mit drei Würfeln
erstellt Die grüne Linie, die
das Würfel-Spielobjekt umgibt, ist
im Grunde der Collider Dieser Collider kann so manipuliert
werden dass er größer oder
kleiner als die Box ist, abhängig vom
Ziel Ihres Spiels und davon,
wie die Collider von Unity miteinander interagieren sollen. Dabei kommt es auf von Unity an Lassen Sie uns über Kollisionsauslöser sprechen
. Wenn nun zwei Spielobjekte miteinander
kollidieren, stellt
Unity Ereignisse bereit,
die aufgerufen werden Es gibt hauptsächlich zwei
Arten von Ereignissen und
Kollisionsereignisse Kollisionstrigger werden
hauptsächlich verwendet, wenn wir Ereignisse
auslösen möchten , die von der Physik-Engine
ignoriert werden sollten . Wenn zwei Objekte kollidieren, durchdringen
sie einander, aber einige Ereignisse werden ausgelöst An mindestens einem von ihnen muss eine starre Körperkomponente
befestigt sein Trigger-Ereignisse können
erreicht werden, indem die Trigger-Option
in der Collider-Komponente auf true gesetzt wird Sobald wir es auf true gesetzt haben, wird
es von
der Physik-Engine ignoriert und
kann verwendet werden, um
Ereignisse auszulösen, wenn das Spielobjekt mit
einem anderen Spielobjekt kollidiert Es gibt drei Ereignisse
für Kollisionsauslöser und sie lauten wie folgt
bei Trigger Enter On Trigger Enter wird aufgerufen, wenn ein Collider mit einem anderen in
Kontakt kommt Wenn bei einem der Collider der Trigger aktiviert ist, wird er nur einmal
aufgerufen Dann haben wir einen Trigger-Aufenthalt. On Trigger Stay
heißt Frame, wenn ein Kontakt zwischen
Collider und dem Trigger
besteht.
Es wird
mehrmals aufgerufen, bis
ein Kontakt zwischen
den beiden Collidern besteht ein Kontakt zwischen
den beiden Collidern Beim Trigger-Ausgang wird
der Trigger-Exit
aufgerufen, sobald der Collider den Trigger
nicht mehr berührt Wird nur einmal aufgerufen. Okay, lass uns
über Kollisionen sprechen. Jetzt kommt es in
Unity zu einer Kollision, wenn zwei Spielobjekte Collider angeschlossen sind,
miteinander interagieren Sie können sich berühren, miteinander in Kontakt
bleiben oder aufhören zu kollidieren über eine starre Karosseriekomponente Physik-Engine sie als Beschleuniger
erkennt, muss mindestens
einer von ihnen Es gibt drei
Kollisionsereignisse. Sie lauten wie folgt
bei Collision Enter, das
aufgerufen wird, wenn ein Collider
mit einem anderen Collider in Kontakt
kommt und nur einmal beim
Collision-Stay-Aufruf für
jeden Frame
aufgerufen Collision-Stay-Aufruf für wird, wenn ein
Kontakt zwischen Collidern besteht, die
mehrfach
aufgerufen werden, bis ein
Kontakt am Kollisionsausgang erfolgt,
sobald der Collider aufhört,
einen anderen Collider zu berühren, der nur aufgerufen wird am Kollisionsausgang erfolgt,
sobald der Collider aufhört,
einen anderen Collider zu berühren, der nur aufgerufen sobald der Collider aufhört,
einen anderen Collider zu berühren einen anderen Sehen wir uns den Unterschied zwischen
Trigger und Kollision an. Trigger, der vom Event-System ausgelöst wird , wenn sich zwei Spielobjekte
überlappen Kollision wird
von der Physik-Engine ausgelöst Wenn zwei Spielobjekte
miteinander kollidieren. Kollisionsinformationen werden
über die Auslöserereignisse weitergegeben ,
d. h. beim Eintreten des Auslösers, Auslösers und Auslösers.
Kollisionsinformationen werden an
die Kollisionsereignisse weitergegeben , und zwar bei Kollisionseintritt, Kollisionsstopp und
Kollisionsausgang Die Trigger-Eigenschaft in der
Collider-Komponente ist aktiviert. Die Trigger-Eigenschaft hier in der Collider-Komponente ist für Kollisionen
deaktiviert Der Trigger wird verwendet, um das Vorhandensein
anderer Spielobjekte Collision wird verwendet, um physisch mit anderen
Spielobjekten zu
interagieren. Das war's, Leute. Wir
sehen uns in der nächsten Sitzung. Ich danke euch vielmals, Leute.
61. 3D-Cube-GameObjekte auf dem Boden und Tags hinzufügen Für "The End of the Year": Freunde. Mein Name ist Roan Suev In dieser Sitzung
werden wir
ein Beispiel für
Kollisionserkennungen erstellen ein Beispiel für
Kollisionserkennungen Wir werden hier einige
Hindernisse in den Weg legen. Diese Hindernisse
werden Spielwürfel sein. zunächst Lassen Sie uns hier zunächst ein leeres
Spielobjekt erstellen. Okay? Erstelle ein leeres Objekt und benenne das
Spielobjekt in Hindernisse um. Jetzt werden
wir innerhalb des Hindernisobjekts einige Würfel
erstellen. Klicken Sie dazu mit der rechten Maustaste auf die Hindernisse und gehen Sie hier zu den
drei D-Objekten. Und klicken Sie auf Q. Wie wir alle hier sehen können, beim Erstellen eines
Würfelspielobjekts ist
beim Erstellen eines
Würfelspielobjekts
standardmäßig Box Collider
daran angehängt Fügen wir dem Würfel hier
auch einen starren Körper hinzu. Okay, lassen Sie uns hier
die Masse für
das
Würfel-Spielobjekt auf zehn erhöhen . Lassen Sie uns hier einfach ein
Material per Drag-and-Drop auf den Würfel ziehen. Skalieren Sie die Größe des
Würfelspielobjekts ein wenig. Es sieht zu klein aus. Lass es uns auf 1,5 belassen Okay, lass es uns ein bisschen erhöhen. Das Spielobjekt ist hier
bereits ausgewählt. Klicken Sie einfach auf Steuerung
D, um die
Spielobjekte zu replizieren , sodass wir weitere Hindernisse schaffen
können Auf dem Weg zur Kugel haben
wir die Hindernisse geschaffen, wir haben
123456 Hindernisse geschaffen Auf dem Weg zum Sphere-Tag müssen Sie im Grunde das
Spielobjekt per Skript identifizieren, das Spielobjekt
auswählen
und hier zu den Tags gehen und auf ein T klicken. Okay? Klicke hier auf das Pluszeichen
und füge einen neuen Tag-Namen hinzu. Behalte es als eins. Okay? Füge einen weiteren Tag-Namen hinzu. Behalte es als Würfel zwei. Würfel zwei, speichern. Ordnung, wir haben also zwei Tags
erstellt, Würfel eins und Würfel zwei. Wählen Sie hier erneut einen Würfel
für die Tags aus, mit denen er markiert ist. Klicken Sie jetzt einfach auf das
Drop-down-Menü und wählen Sie hier den ersten Würfel aus. Dann gehe hier zu Würfel eins und
wähle hier einen aus. Okay, im Grunde genommen werden
wir für
die weißen Würfel einen als Tag
auswählen. Für die schwarzen
Würfel werden wir Würfel zwei als Tag auswählen. Okay, lassen Sie uns die Szene durchspielen. Und lass uns den Ball bewegen. Okay, lass uns
die Kugel hierher verschieben. Im Moment
kollidiert die Kugel hier mit den
Würfel-Spielobjekten. Okay, aber da wir dem Skript keine Kollisionsereignisse
hinzugefügt
haben, führen wir
keine Aktionen darauf Grundsätzlich werden wir in der nächsten
Sitzung
Kollisionsereignisse innerhalb des
Skripts verwenden, um Kollisionen zu erkennen Und wir werden auch
die Tags verwenden, die wir
gerade hier erstellt haben Okay Leute, vielen Dank. Ich sehe dich in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
62. Kollisionen mit dem 3D-Cube mithilfe von Tags erkennen: Freunde. Mein Name ist Ron Vase. In dieser Sitzung
werden wir
Kollisionsereignisse innerhalb
des Unity-Skripts implementieren . Diese Kollisionsereignisse
treten beim Eintritt der Kollision,
beim Kollisions-Stopp und beim Kollisions-Austritt
auf. Lassen Sie uns einen Code
in das Unity-Skript schreiben. Fangen wir mit On
Collision Enter an. Funktion bei Kollision
Enter wird aufgerufen , wenn zwei starre Körper miteinander
kollidieren oder wenn zwei Kollisionen
miteinander kollidieren Bei Collision Enter
übergeben wir eine Kollisionsklasse. Die Kollisionsklasse enthält
alle Informationen, z. B. Aufprall, Geschwindigkeit und Kontaktpunkte sowie die
Kollision im Inneren. Bei der Kollisionseingabe werden
wir Tags
verwenden, die wir
in der letzten Sitzung erstellt haben. Wir hatten zwei Tags erstellt, Würfel eins und Würfel zwei. Etikett „Würfel eins“ für die weißen Würfel und das Etikett „Würfel zwei“ war
für die schwarzen Würfel. Lassen Sie uns im Grunde schreiben, ob Bedingung innerhalb eines
Kollisionseingabe-Funktionsaufrufs das Objekt-Tag gleich Würfel eins Wenn es sich um einen weißen Würfel
handelt, werden wir im Grunde etwas in
diesem
Debug-Protokoll
ausdrucken diesem
Debug-Protokoll . Die Kollision begann mit Okay, diese Bedingung
gilt für die weiße Warteschlange. Schreiben wir eine Elsif-Bedingung. Elf Call Game Object
Tag ist gleich,
entspricht zwei
fehlerhaften Logkollisionen
, die mit dem fehlerhaften Logkollisionen Würfel gestartet wurden. Okay? Also lasst uns hier
eine weitere Funktion schreiben, die
auf Collision Stay läuft. Bei Kollision
wird die Stay-Funktion einmal pro Frame aufgerufen. Okay, bei Kollisionsaufenthalt ungültig. Lass uns nochmal eine
Wenn-Bedingung schreiben. Hier
bleiben wir Black Cube. Zu guter Letzt werden wir die Funktion
On-Collision-Exit verwenden. Exit-Funktion bei Kollision
wird aufgerufen, wenn zwei Richard-Körper oder Collider aufhören,
miteinander zu kollidieren Okay, wir haben hier also
alle drei Funktionen bei
Kollisionseintritt,
Kollisionsstopp und
Kollisionsaugang implementiert hier also
alle drei Funktionen bei
Kollisionseintritt,
Kollisionsstopp und
Kollisionsaugang Lassen Sie uns die Szene durchgehen
lassen und sehen, wie das Ding funktioniert. Lassen Sie uns
hier mit
dem weißen Würfel kollidieren , als der Speer
mit dem weißen Würfel kollidierte Wir alle können hier sehen, dass die
Kollision
mit dem weißen Würfel begann und dann die Kollision mit dem
weißen Würfel bleibt , da der Speer
immer noch mit dem Kollisionsausgang kollidiert der Ausgang bei Kollision noch nicht aufgerufen
wurde Aber sobald ich den Kumpel hier vom Würfel
wegbewegt habe. Okay, der Kollisionsausgang mit dem
weißen Würfel wird aufgerufen. Also lass uns jetzt gehen und
mit dem schwarzen Würfel kollidieren. Okay, das ist also der schwarze Würfel. Okay, also Kollision
bleibt bei Black Cube. Lass uns den Speer
vom schwarzen Würfel wegbewegen und
schauen, was er druckt Okay, mit
Schwarz kam es zur Kollision. Also das war's, Leute Danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
63. Einführung in 2D- und 3D-Animationen in Unity: Hallo Freunde, mein Name
ist Rohan Maze. In dieser Sitzung werden wir über Animations
Unity sprechen Was ist also Unity von Animation? Das
Animationssystem von Unity basiert auf dem Konzept von
Animationsclips. Diese enthalten
Informationen darüber, wie bestimmte Objekte ihre Position,
Drehung oder andere
Eigenschaften im Laufe der Zeit
ändern sollten . Diese Animationsclips
werden dann in
einem strukturierten
System organisiert , das einem Flussdiagramm ähnelt , das als
Animator-Controller bezeichnet wird Der Animator-Controller fungiert
als Zustandsmaschine, die
nachverfolgt, welcher Clip gerade abgespielt
werden soll und wann die Animationen
ändern oder zusammenfügen sollen Ein einfacher
Animator-Controller enthält möglicherweise nur einen oder zwei Clips Zum Beispiel, um
eine Drehung oder einen Sprung zu steuern. Oder um zu animieren, dass sich eine Tür zur richtigen Zeit öffnet und schließt Ein
fortschrittlicherer Animator-Controller könnte Dutzende von
humanoiden Animationen für
alle
Aktionen der Hauptfiguren wie Gehen,
Laufen, Schießen usw. enthalten humanoiden Animationen für alle
Aktionen der Hauptfiguren wie Gehen,
Laufen, Schießen usw. So sieht ein
Animator-Controller aus. Dieser Animator-Controller
, der Animationsclips im Leerlauf und
beim Laufen enthält , ist an den humanoiden
Charakter
angehängt Okay, lassen Sie uns jetzt über
Animation State Machine sprechen. Was ist eine Animation State Machine? Animation State Machine
verfolgt, welcher Clip
gerade abgespielt werden soll und wann die Animationen
ändern oder zusammenfügen sollen. Es ist üblich, dass ein Charakter oder anderes animiertes
Spielobjekt über mehrere verschiedene
Animationen verfügt, die
den verschiedenen Aktionen entsprechen, die im Spiel
ausgeführt werden können. Ein Charakter kann leicht schwanken wenn er untätig ist, gehen,
wenn er dazu aufgefordert wird, und seine Arme
panisch heben, wenn er von einer Plattform fällt Eine Tür kann
Animationen für das Öffnen,
Schließen, Verklemmen
und Aufbrechen haben . Unity-Animation verwendet ein
visuelles Layoutsystem , das einem Flussdiagramm
ähnelt, um eine Zustandsmaschine
darzustellen So können Sie die Animationsclips
,
die Sie für Ihren Charakter oder ein
anderes Spielobjekt verwenden
möchten,
steuern und sequenzieren Animationsclips
,
die Sie für Ihren Charakter oder ein
anderes Spielobjekt verwenden
möchten . Was sind
Zustandsmaschinen-Übergänge? Übergang zu Zustandsmaschinen vereinfacht große oder komplexe Zustandsmaschinen. Jede Ansicht im Animatorfenster hat einen Eingangs- und Ausgangsknoten, bei
Zustandsübergängen
verwendet wird Der Eingangsknoten wird beim
Übergang in
eine Zustandsmaschine verwendet Übergang in
eine Zustandsmaschine Der Eingangsknoten wird
ausgewertet und wechselt je nach den festgelegten Bedingungen
zum Zielstatus oder zum Animationsclip Der Ausgangsknoten wird verwendet, um anzuzeigen, dass eine
Zustandsmaschine beendet werden soll. In der Abbildung unten können
wir nun sehen, wie der Eingangsknoten hier in die
Leerlaufanimation
übergeht,
wobei die
Leerlaufanimation hier der Standardstatus ist in die
Leerlaufanimation
übergeht,
wobei die Leerlaufanimation hier der Standardstatus Die Animation im Leerlauf geht dann je nach den im De Animator-Controller
festgelegten Bedingungen entweder
in
den Laufanimationsclip oder in den laufenden
Animationsclip über. Das war's Leute Danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung. In der nächsten Sitzung werden wir
eine Animation auf einem Sprite erstellen eine Animation auf einem Sprite Vielen Dank, Leute.
64. Schneide ein Spritesheet in mehrere Sprites und wende Animation zu Fuß an: Meine Freunde, mein
Name ist Rohan Sev. In dieser Sitzung
werden wir
eine Animation auf dem Sprite erstellen eine Animation auf dem Sprite ist im Grunde ein Bild für Demonstrationszwecke Wir haben bereits
zwei Projekte in Unity erstellt und wir haben auch
eine Sprite NM-Szene
innerhalb des Projekts erstellt eine Sprite NM-Szene
innerhalb des Zunächst müssen wir das
Spritesheet in das Projekt importieren .
Was ist ein Spritesheet Spritesheet besteht im Grunde mehreren Bildern in einem
einzigen Bild in einem Raster So würde ein
Spritesheet aussehen. Dies sind im Grunde
mehrere Bilder ,
die zu einem einzigen Bild zusammengefasst Dies wird
als Spritesheet bezeichnet In Ordnung, lassen Sie uns damit beginnen, dieses Bild hier
herunterzuladen. Lassen Sie uns nun das Spritesheet in das Unity-Projekt hier einfügen. Aber bevor wir
das tun, erstellen wir einen Ordner und benennen den
Ordner als Spritesheet Okay, klicken Sie auf Hier erstellen und dann auf Ordner. Benennen Sie
den Ordner als Sprite Sheet Öffnen Sie den Ordner und ziehen Sie ihn
einfach in
den Sprite Sheet-Ordner Ordnung, das
ist also ein einzelnes Bild, jetzt müssen wir es
in mehrere Bilder aufteilen Also, wie machen wir das?
Wählen Sie zunächst das Bild aus. In Ordnung,
wählen Sie hier im
Sprite-Modus mehrere aus, okay,
und klicken Sie auf Hier anwenden. Und klicken Sie hier auf den
Sprite-Editor. Dieses Fenster wird geöffnet. Ordnung, sobald
Sie dieses Fenster geöffnet haben, klicken Sie hier auf die Option
Slice Slice. Klicken Sie auf eine beliebige Stelle auf dem Bildschirm. Und klicken Sie auf Anwenden,
schließen Sie das Fenster. Und ja, wir haben hier
mehrere Bilder. Okay. Wie Sie alle hier sehen können, haben
wir jetzt Sp-Stern, ein
einzelnes Bild in
mehrere Bilder. Ordnung, jetzt müssen wir
all diese mehreren Bilder verwenden , um eine Animation zu erstellen. Da wir
mehrere Sprites aus
einem einzigen Spritesheet erstellt haben , wählen
wir dieses
spezielle Es ist ein ideales Bild für
die Person, die läuft. Ziehen Sie
die Person einfach hierher und legen Sie sie dort ab. Lassen Sie uns hier die Größe
des Sprites skalieren. Skalieren wir es auf zwei X-Y-Achsen. Okay? Perfekt. Wählen Sie nun hier
das Sprite aus und
gehen Sie zur Registerkarte Animation In Ordnung, also klicken wir auf
Erstellen, um eine Animation hinzuzufügen. Benennen Sie die Animation
Walking Animation um. In Ordnung, klicken Sie hier auf Speichern. Lassen Sie uns den
Animations-Tab irgendwo hierher ziehen. Erweitere das. Was machen wir als Nächstes? Wir müssen hier alle Sprites auswählen, Ausnahme des
Original-Sprites, das sich bereits in der Szene befindet Okay, klicken Sie hier auf die
Steuertaste und
wählen Sie weiterhin alle
anderen Sprites oder alle anderen Animationen aus
, die wir hinzufügen möchten Auch hier kommt es darauf an, um welche
Art von Animation es sich handelt. Vielleicht möchten wir
nur vier Sprites verwenden und
dann einfach vier Sprites auswählen Wenn wir
alle Sprites verwenden wollen,
wählen Sie alle Sprites wählen Sie alle Ordnung, ich brauche
alle Sprites,
also wähle ich hier alle
Sprites Ziehe einfach alle
Sprites hierher, okay? Nochmals, holen Sie sich den Tab hier
, um es komfortabler zu machen. Ordnung, mal sehen, wie die Animation aussieht.
Jetzt ist sie zu schnell. Was machen wir hier?
Okay, scrolle mit der Maus und okay, minimiere das Ding. Okay. Um es etwas langsamer zu machen, erhöhen
Sie es einfach auf, ich denke, 50 ist hier in Ordnung. Ja, versuche es einfach nochmal mit der
Animation. Ich denke, es ist
jetzt perfekt. Es sieht gut aus. Lassen Sie uns das beenden, die Szene speichern, die Szene hier ausführen und sehen wir uns die Ausgabe an.
In Ordnung, perfekt. Unser Geist läuft hier rum. So machen wir Animationen. Vielen Dank, Leute.
Danke für die Sitzung. In der nächsten Sitzung werden
wir hier
ein Hintergrundbild oder den
Hintergrund für die Szene erstellen . Außerdem werden wir
dieses Sprite nach links oder rechts bewegen ,
je nachdem, welche Pfeiltasten
Sie dort unten drücken Ordnung. Also vielen
Dank, Leute. Wir sehen uns in der nächsten
Sitzung. Ich danke dir vielmals.
65. Hintergrund der Szene hinzufügen: Freunde, mein Name
ist Rohan Masudev. In der letzten Sitzung haben wir hier
eine Animation auf dem Sprite erstellt eine Animation auf dem Sprite Wir haben hier einen
Laufanimationsclip für den Sprite erstellt. Ordnung, als wir das gemacht haben, wurde
dieser
Animator-Controller erstellt Im Moment haben wir nur einen
Laufanimationsclip
auf diesen speziellen
Animator-Controller
angewendet auf diesen speziellen
Animator-Controller ,
genau hier in dieser Sitzung werden
wir
ein Hintergrundbild
für diese spezielle Szene anwenden ein Hintergrundbild
für diese spezielle Vorher benötigen
wir ein Hintergrundbild. Entweder können Sie es
erstellen oder Sie können es aus dem Internet
herunterladen. Ich werde dieses Bild herunterladen und es als
Hintergrund für das C verwenden. Ich habe
dieses Bild bereits hier heruntergeladen. Lassen Sie uns dieses Bild
in unser Projekt aufnehmen. Verfolge dieses Bild einfach hier. Wir haben das Bild
hier in unser Projekt importiert. Der nächste Schritt wäre nun ein leeres Spielobjekt
zu erstellen, das im Grunde als
Hintergrundbild dient. Ordnung, klicken Sie
hier mit der rechten Maustaste auf die Szene und gehen Sie zu Game Object und klicken Sie
hier auf Create Empty. In Ordnung. Benenne das Spielobjekt
in den Hintergrund um, okay? Und ziehen Sie dieses Bild einfach per Drag &
Drop auf das leere
Spielobjekt im Hintergrund. Ordnung, im Moment sieht
das Bild überhaupt nicht gut aus. Wir müssen den Maßstab
für das Bild grundsätzlich anpassen. Ordnung, behalten wir es bei, sagen
wir 0,3 auf der X-Achse, 0,3 auf der Y-Achse und 0,3 auf der besagten Achse. Klicken Sie hier auf die Registerkarte Szene. Jetzt ist dieses Bild nicht genug. Wir wollen hier eine
riesige Szene kreieren, weil wir irgendwann
mit den Steuertasten laufen werden. Ordnung, was
als Nächstes zu tun ist, einfach
das Bild hier im leeren Spielobjekt im
Hintergrund auszuwählen das Bild hier im leeren Spielobjekt im
Hintergrund und auf Steuerung
D zu klicken. In Ordnung. Wählen Sie jetzt hier das
Verschieben-Werkzeug aus und
verschieben Sie einfach das Bild, okay? Klicken Sie erneut auf
dieses bestimmte Bild, das sich genau in der Mitte befindet. Klicken Sie erneut auf Steuerung D. Verschieben Sie das Bild
mit Hilfe des
Verschieben-Tools einfach hierher. Ordnung, jetzt
ist der Sprite in der Luft und
er fliegt in der Luft Wir müssen es
so aussehen lassen, als wäre es auf dem Boden. Als Nächstes wählst du einfach
deinen Sprite im Meer aus
und bringst ihn runter Okay, lass uns jetzt ans Meer gehen. Und sieht
jetzt gut aus. Sieht besser aus. Lass uns hier auf den
Play-Button klicken
und sehen, wie es aussieht. In Ordnung, es sieht gut aus. Die Animation wird
abgespielt und wir haben auch
ein Hintergrundbild für unsere Szene eingestellt. Wenn Sie hier sehen, sich
das Sprite
derzeit nicht vorwärts, obwohl die
Animation abgespielt oder die Animation auf das Sprite angewendet oder die Animation auf das Sprite bewegt
sich
das Sprite
derzeit nicht vorwärts, obwohl die
Animation abgespielt
oder die Animation auf das Sprite angewendet wurde Okay, in der nächsten
Sitzung werden wir das Skript
auf das Sprite
anwenden Im Grunde genommen, um
das Sprite
vorwärts und
rückwärts zu bewegen vorwärts und
rückwärts zu Auch hier werden wir eine Animation erstellen, bei der es
sich um eine Leerlaufanimation handeln wird Wenn du keine Tasten
drückst, sollte Sprite
inaktiv bleiben und hier
aufhören zu laufen. In Ordnung Leute,
danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
66. Bewege die animierten Sprite mit Tastatureingaben: Freunde, ich heiße Rowan Suv. In der letzten Sitzung haben wir den
Sprite animiert. In dieser Sitzung
werden wir
das Sprite mithilfe des Sharp-Skripts von
Unity C verschieben das Sprite mithilfe des Sharp-Skripts von
Unity C Okay, zu diesem Zweck erstellen
wir
hier einen Ordner namens scripts Öffnen Sie hier den Scripts-Ordner und lassen Sie uns ein C-Sharp-Skript
in den Scripts-Ordner schreiben . Sprite ist der Name
des Skripts. Lassen Sie uns einen Code
in das Move-Sprite-Skript schreiben in das Move-Sprite-Skript Okay, lassen Sie uns hier eine
Float-Variable deklarieren, Float horizontal Wir werden das Sprite auf
der horizontalen Achse
bewegen , horizontal
schweben In Ordnung, lassen Sie uns
die Startmethode entfernen. Wir brauchen
hier in der Update-Funktion keine Startfunktion . Lassen Sie uns der
horizontalen Float-Variablen,
die Ihre
horizontale Eingabeachse sein wird, einen Wert zuweisen die Ihre
horizontale Eingabeachse sein wird, . Okay, lassen Sie uns eine
Bedingung anwenden, um zu überprüfen, ob sich
das Sprite in
die richtige oder in
die linke Richtung bewegt die richtige oder in
die linke Richtung Um zu überprüfen, ob sich das Sprite in die richtige Richtung
bewegt, wenden
wir eine Bedingung an, wenn es
horizontal größer als Ordnung,
lassen Sie uns darin get component verwenden Und innerhalb von get component erhalten wir
Sprite Renderer, der standardmäßig
an
das Sprite angehängt ist Wenn wir also ein Sprite erstellen, wird ihm eine
Sprite-Renderer-Komponente Sprite-Renderer-Komponente Wir erhalten also die
Sprite-Renderer-Komponente,
okay, Sprite-Renderer-Komponente,
Flip X entspricht Stürzen, okay, Flip X wird das Sprite im Grunde genommen auf der
X-Achse Hier drüben wollen wir das Sprite so
lassen, wie es ist. Wir wollen es nicht umdrehen, wenn das Sprite in
die richtige Richtung bewegt Also belassen wir
es wieder bei Stürzen, lassen Sie uns einen Vektor drei deklarieren, ein variabler Vektor drei Moment entspricht n Vektor Okay? Auf der X-Achse möchte
ich 1,5
0,0 anwenden , okay? Into entspricht der Zeitdelta-Zeit. Ordnung, wir werden
das Sprite
mithilfe der Transform
Translate Funktion bewegen mithilfe der Transform
Translate Transform Translate
und Insight Translate. Wir werden sehr viel
Bewegung hinzufügen. Okay, lassen Sie uns
eine weitere Bedingung anwenden , die
horizontal kleiner als Null ist. Wenn get component sprite render a flip x gleich true ist
, wenn sich das Sprite in die linke Richtung
bewegt, werden
wir das
Sprite auf der X-Achse umdrehen Im Grunde entspricht
das Moment des Vektors drei n, dritte
Vektor -1,5 auf der X-Achse, Null auf der Y-Achse
und Null auf der Z-Achse und Okay, nochmal, die
Bewegung entspricht der Deltazeit von T. Zum Schluss noch die Position
oder Transformation für das
Sprite ändern . Mithilfe der Funktion Transform, Translate in Unity Translate und innerhalb von Translate werden
wir hier einen Moment hinzufügen Okay, lassen Sie uns das
Skript speichern und das Skript
hier
an das Sprite anhängen Lassen Sie uns das Skript einfach per Drag-and-Drop
auf das Sprite ziehen. Das Skript ist
hier an das Sprite angehängt. Lassen Sie uns jetzt das Spiel ausführen
und sehen, wie es funktioniert Ordnung, drücken wir die Rechtspfeiltaste
auf der Tastatur und das Sprite bewegt sich
in die richtige Richtung Drücken wir die linke
Pfeiltaste auf der Tastatur, und das Sprite beginnt sich
in die linke Richtung zu bewegen Es funktioniert gut, aber hier gibt
es ein Problem. Selbst wenn ich aufhöre,
die Pfeiltasten zu drücken, können
wir hier alle sehen, dass die
Animation hier nicht aufhört. Okay, die Animation geht weiter. In der nächsten Sitzung werden wir also im eine weitere Animation auf das Sprite anwenden, bei der es Grunde genommen
eine weitere Animation auf das Sprite anwenden, bei der es
sich
um eine Leerlaufanimation handeln wird Sobald ich also die
Tasten auf der Tastatur loslasse, wird die Animation im Leerlauf abgespielt Und sobald ich wieder auf die Tasten
drücke, wird
die Laufanimation erneut abgespielt. Also vielen Dank.
Das war's, Leute. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
67. Wende Animation im Leerlauf auf die Sprite an und lass die Kamera den Sprite folgen: Hallo Freunde. Mein Name
ist Rohan Vasudev In der letzten Sitzung haben wir das Sprite mithilfe der Funktion
Transformed oder Translate
in Unity
verschoben Transformed oder Translate In dieser Sitzung werden wir
eine Leerlaufanimation auf
das Sprite anwenden , sodass, wenn wir aufhören , die linke oder
rechte Pfeiltaste zu
drücken, die Leerlaufanimation
abgespielt und die Laufanimation gestoppt
wird Ordnung, um das zu tun, beginnen
wir hier damit ,
eine Leerlaufanimation
für das Sprite zu erstellen eine Leerlaufanimation
für das Sprite Wählen Sie das Sprite
hier in der Szene aus. Gehen Sie zur Registerkarte Animation und
klicken Sie hier auf das Drop-down-Menü. Und erstelle einen neuen
Clip für das Sprite. Okay, klicken Sie einfach hier auf
Neuen Clip erstellen. In Ordnung. Jetzt können
wir in einem beliebigen Ordner oder
im Sprite Sheet-Ordner einen neuen
Animationsclip erstellen Benennen Sie den Clip als Leerlaufanimation. Okay, speichere das Skript. Bringen Sie den Animations-Tab hierher. Klicken Sie hier auf das Spritesheet und ziehen Sie das erste Sprite hierher handelt es sich um ein
Animations-Sprite im Leerlauf Im Grunde genommen handelt
es sich dabei um ein Leerlauf-Sprite , das für Animationen im Leerlauf verwendet
wird Bringen Sie erneut den
Animations-Tab hierher. Klicken Sie einfach auf den Play-Button. Okay, es macht nichts weil es eine inaktive Animation ist. Wenn wir aufhören, die
linke oder rechte Pfeiltaste zu drücken, wird
diese Animation abgespielt. Wir haben hier zwei Animationen. Eine davon ist die Laufanimation. Eine andere ist die Animation im Leerlauf. Ordnung, hier drüben ist
die Standardanimation eine Laufanimation. Wenn wir die Play-Taste
drücken, wird die Startanimation eine Laufanimation sein. Lassen Sie uns das in eine Animation
im Leerlauf ändern. Okay? Weil das der Einstiegspunkt
sein sollte. In Ordnung, also gehen wir wieder
zum Animator-Tab. Klicken Sie hier auf Animation im Leerlauf und dann auf
Als Standardstatus festlegen Dies ist der
Standardstatus, sobald wir im Spiel auf die
Play-Schaltfläche klicken. Lassen Sie uns einige Übergänge erstellen. Wenn wir
auf die Schaltfläche „Abspielen“ klicken, wird
diese Animation grundsätzlich so
abgespielt, wie sie jetzt als Standardanimation
festgelegt ist . Wenn wir jedoch auf die
linke oder rechte Pfeiltaste klicken, wird eine
Laufanimation abgespielt. Klicken Sie dazu einfach mit der rechten Maustaste
auf die Leerlaufanimation. Klicken Sie auf den Übergang zur
Laufanimation. In Ordnung. Klicken Sie ebenfalls mit der rechten Maustaste auf
die Laufanimation. Machen Sie einen Übergang und
bringen Sie ihn dann zur Leerlaufanimation zurück. Klicken Sie
hier einfach auf den Pfeil und deaktivieren Sie ihn. Klicken Sie hier auf die Einstellungen. Und die Übergangsdauer
setzen Sie den Wert auf Null weil wir keine Dauer festlegen
möchten. Übergangsdauer ist im Grunde die Dauer des Übergangs zwischen den beiden Animationen. Okay, klicken Sie erneut auf diesen Pfeil und überprüfen Sie
, ob die Endzeit abgelaufen ist. Und setzen Sie die
Übergangsdauer hier wieder auf Null. Ordnung, jetzt müssen wir
einige Bedingungen festlegen , um zu überprüfen, ob der Spieler die Pfeiltasten drückt
oder nicht. Okay, dann tu es. Wir müssen hier einen Parameter
erstellen. Lassen Sie uns einen neuen Parameter erstellen indem wir hier auf die
Plus-Taste drücken. Jetzt gibt es vier Arten von Parametern, die wir erstellen können. Wir werden hier
einen Parameter vom Datentyp Bool erstellen einen Parameter vom Datentyp Bool Okay, geben wir ihm
einen Namen, kann laufen. Das ist der Name
des Parameters. Nochmals, klicken Sie hier
auf den Pfeil, okay? Und stellen Sie hier die Bedingung ein. Wenn Can Walk wahr ist, wird eine Walking-Animation abgespielt. Und wenn Can Walk den Wert False hat, wird eine Leerlaufanimation abgespielt. Lassen Sie uns
hier eine Bedingung stellen. Kann wahr laufen. Das heißt einfach, wenn
Can Walk wahr ist, wird eine
Walking-Animation abgespielt, okay? Klicken Sie hier auf den Pfeil, noch einmal, stellen Sie
eine Bedingung ein, okay? Wenn Can Walk den Wert False hat, wird eine Animation im Leerlauf abgespielt. Jetzt müssen wir den Animator aufrufen, der das Sprite angehängt ist Um das zu tun,
deklarieren wir
hier einen Animator, den Namen des Animators. Okay, wir haben hier keine
Startfunktion. Lassen Sie uns die Startfunktion hinzufügen. Wir müssen den Animator initialisieren
. In Ordnung Sobald das Spiel
startet, ist alles gleich, um Component Animator
zu bekommen Ordnung, jetzt müssen
wir hier die
Umfrage einstellen, die wahr werden kann , wenn wir die Pfeiltaste
drücken Um das zu tun, anim dot set pool, kann
der Name des Parameters laufen und er hier auf true gesetzt Okay, auch in
diesem Zustand müssen wir
den Ball
wieder auf true setzen Satz B kann zu „Wahr“ werden. In Ordnung, lassen Sie uns hier die Bedingung
eines L deklarieren. Also, wenn der Spieler nicht
läuft oder der
Charakter nicht geht, wir das Anime-Set fest Bull kann wieder zu Wasserfällen laufen. Kann Stürze laufen. In Ordnung, speichern
wir das Drehbuch hier. Alles ist hier eingerichtet. Lass uns das Spiel starten. Und
lassen Sie uns die Ausgabe sehen. Im Moment drücke ich hier nicht
auf die Pfeiltasten, die inaktive Animation
wird abgespielt. Klicken wir hier auf oder drücken
wir auf die
rechte Pfeiltaste. Und die Laufanimation
wird abgespielt. Ordnung, sobald
ich die Taste loslasse,
wird die Animation
im Leerlauf wieder abgespielt. Gehen wir wieder nach links. Okay, die
Laufanimation beginnt. Lassen Sie mich hier die
Pfeiltaste loslassen. Ordnung, wir lassen die Hauptkamera
dem Charakter hier folgen. Es ist also sehr einfach zu machen. Wählen wir hier also die
Hauptkamera aus und machen sie zum untergeordneten Objekt für das Sprite-Spielobjekt
hier oder das Sprite Okay, also ziehe es einfach und
lege es in dein Sprite. Okay, lassen Sie uns
die Szene noch einmal abspielen. In Ordnung, die Kamera
folgt also auch dem Spieler. Okay, es hört auf. Okay, los geht's. Sieht gut aus. Ordnung, das war's also.
Vielen Dank, Leute. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
68. Importiere 3D-Charaktere in Unity und wende Laufanimation an: Hallo Freunde. Mein Name
ist Rohan Vasudev In dieser Sitzung
werden wir hier
eine Animation für drei
D-Charaktere erstellen eine Animation für drei
D-Charaktere Diese drei D-Charaktere werden
wir von unserer Website Mixamo.com von Adobe herunterladen Mixamo.com von Auch die Animation für
diesen speziellen Charakter werden
wir von Mixamo
herunterladen Ordnung, also lass uns
auf die Website gehen und anfangen, den Charakter
und die Animation dafür herunterzuladen . Hier sind wir auf
Mixamo.com In Ordnung, Sie können hier einen
der Charaktere auswählen Okay, ich werde
diesen Charakter hier wählen. Lass uns hier auf den
Download-Button klicken. Beitrag sollte Post sein. Wir haben den
Charakter von Mixamo heruntergeladen. Gehen wir nun los und holen den Charakter in den Ordner mit den
drei D-Zeichen
, den wir im
Assets-Ordner erstellt haben Lass es uns einfach hierher ziehen
und dort ablegen. Bevor wir die
Figur in die Szene einfügen, erstellen
wir einen Boden, auf dem
die Figur laufen kann. Ordnung,
gehen wir zum Spielobjekt, gehen wir zum Drei-D-Objekt und
lassen Sie uns hier eine Ebene erstellen. Okay, das Flugzeug ist nicht sichtbar. Gehen Sie einfach
hier zur Transformation und klicken Sie auf Zurücksetzen. In Ordnung, das ist gut. Okay, lassen Sie uns
hier eine weitere Ebene erstellen , damit wir einen größeren Flow
haben können. Und lass uns das Ding vorschlagen, okay, also haben wir jetzt einen
größeren Flow. Okay, lassen Sie uns versuchen,
diesen Charakter in unsere Szene zu integrieren, indem zum Beispiel hierher ziehen und dort ablegen. Okay, wir haben unseren Charakter jetzt
in der Szene, aber wir können sehen, alles klar, es gibt keine Materialien oder
Texturen auf der Figur. Um Texturen
auf den Charakter
anzuwenden, müssen
wir nur
den Charakter hier auswählen , okay. Und klicken Sie auf Materialien und dann auf
Externe Materialien verwenden, Legacy und dann auf Anwenden. Und das Material
sollte angewendet werden. Nun zum Charakter. Wir können die Materialien oder die Texturen sehen ,
die auf
den Charakter angewendet wurden. Nun, so wie es auf AMO.com war klicken Sie
hier auf den Tab Rig, Animationstyp Da es sich um einen humanoiden Charakter handelt, müssen Sie hier Humanoid auswählen Und klicken Sie hier auf die Schaltfläche
Anwenden. Gehen Sie jetzt als Nächstes hier zu Animation und überprüfen Sie hier Look Time, okay? Und klicken Sie hier auf Anwenden, aber es wurde keine
Animation darauf angewendet. Um die Animation anzuwenden, gehen
wir erneut zu AMO.com und klicken hier auf den
Animations-Tab. Und wir wollen laufen. Animation, Suche nach Spaziergängen. Okay, wählen wir das aus. Die Animation ist perfekt. Perfekt. Mutant Walking ist der Name des
Animationsclips, den wir beim Gehen auf unseren
Charakter anwenden werden beim Gehen auf unseren
Charakter anwenden Okay, klicken Sie hier auf Herunterladen. Das Format BX für Unity ist in Ordnung. In Ordnung, und das
sollte ohne Sky sein. Klicken Sie hier auf den
Download-Button. Ordnung, lassen Sie uns diesen
Animationsclip
wieder in unseren Ordner mit den drei D-Charakteren unseren Ordner mit den drei D-Charakteren einfügen, indem wir ihn einfach hierher ziehen
und dort ablegen. Lassen Sie uns das auswählen, was ein Animationsclip
ist. Okay, gehen Sie hier zum Rig und noch einmal Animationstyp, um aus diesem Modell einen Humanoiden zu
erstellen Und klicken Sie hier auf Anwenden. Gehen Sie erneut zur Registerkarte Animation, überprüfen Sie die Loop-Zeit und
beginnen Sie zu posieren. Überprüfen Sie dies anhand der
Körperausrichtung. Und klicken Sie hier auf Bewerben. Wähle hier erneut meinen Charakter aus. Jetzt müssen wir einen
Animator-Controller erstellen Okay, gehen Sie hier zu Erstellen und klicken Sie auf Animator-Controller Okay, mein Controller benennt den Animator-Controller
zu meinem Öffnen Sie einfach den
Animator-Controller und lassen Sie uns diesen Walking-Clip
hier im
Animator-Controller
verfolgen hier im
Animator-Controller Ordnung, jetzt
gehen wir hier
wieder zu meinem Charakter und wenden diesen Animator-Controller
für Lass uns die Szene hier abspielen. Ja, der Charakter läuft. Lassen Sie uns den Charakter aus der Kameraansicht
etwas zurückholen. Okay? Okay, der
Charakter läuft,
aber wir wollen, dass sich unser Charakter mit den Pfeiltasten
bewegt. In der nächsten Sitzung
werden wir das Skript zusammen mit der Charaktersteuerung auf
den
Charakter anwenden . Das war's, Leute.
Danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
69. Bewege den 3D-Charakter mit Tastatureingaben: Freunde, mein Name
ist Rohan Masrev. In der letzten Sitzung haben wir
Animationen auf diesen Charakter angewendet Animationen auf diesen Charakter In dieser Sitzung
lassen wir die Figur vorwärts laufen , wenn wir
die Pfeiltasten auf der Tastatur
drücken. Lass uns
hier meinen Charakter auswählen und das Häkchen entfernen. Wende die Wurzelbewegung an. Da wir
diesen Charakter mit den Pfeiltasten bewegen
werden, werden
wir dies grundsätzlich diesen Charakter mit den Pfeiltasten bewegen
werden, deaktivieren Wenden Sie hier die Wurzelbewegung an. Dann müssen wir
die Laufanimation modifizieren, die wir hier auf
den Charakter anwenden. Okay, lassen Sie uns die Szene durchgehen und sehen wir uns den
Unterschied an. Mal sehen, wie die
Animation aussieht. Jetzt haben wir die
angewendete Wurzelbewegung deaktiviert. In Ordnung, der Charakter
geht also an einem Ort spazieren. Es bewegt sich nicht vorwärts
, weil wir den Charakter jetzt mit
den Pfeiltasten
bewegen werden. Scrollen wir nun hier nach
unten und gehen zur Wurzeltransformationsposition y für den Walking-Animationsclip. Dies ist der
Animationsclip beim Gehen , den wir
auf den Charakter angewendet haben. Okay? Bei der
Wurzeltransformation basiert die Position Y auf Ketten auf zwei Fuß. Okay? Und klicken Sie hier auf
Bewerben, Perfekt. Das ist die Animation
, die wir in unserer Höhle haben wollen. Hier sind wir auf Mamo.com.
Ich habe bereits nach
der Leerlaufanimation gesucht und werde diese unbenannte
Leerlaufanimation auf unseren Charakter
anwenden Okay, so wird unser Charakter aussehen, wenn er inaktiv ist, wenn er nicht läuft Lass uns den Clip hier herunterladen. Vx für Unity BX. Ordnung, und ohne Skin, lassen Sie uns auf die
Download-Schaltfläche klicken
und den Animationsclip herunterladen Okay, ich habe
die inaktive Animation heruntergeladen. Ziehen wir die Animation
in den Ordner mit den drei
D-Charakteren. Klicken Sie jetzt auf meinen inaktiven
Animationsclip. Gehen Sie hier zu Rig,
Animationstyp slcumanoid, und klicken Sie auf Animation hier anwenden Überprüfe die Loop-Time, okay? Und für die
Wurzeltransformationsposition Y. Ändern Sie diese
wiederum in Fuß
und klicken Sie hier auf Anwenden. Klicken Sie auf den Animator-Controller , den wir das letzte Mal erstellt haben Und ziehen Sie so die,
meine ideale Animation hierher in den
Animator-Controller Klicken Sie mit der rechten Maustaste auf meine
ideale Animation und legen Sie diese als Standardstatus für die
Ebene Ordnung,
gehen wir
hier zum Spiel-Tab und schauen wir uns an, wie
die Animation aussieht. Okay, es sieht gut aus. Perfekt. Im
Animator-Controller Das ist der Einstiegspunkt. Das ist die Animation im Leerlauf. Wir müssen hier die
Übergänge erstellen. Klicken Sie hier mit der rechten Maustaste auf
die inaktive Animation. Und wechseln Sie
zum Gehen der Mutanten Klicken Sie hier mit der
rechten Maustaste auf die Animation zum Gehen der
Mutanten Und wechseln Sie zur
Leerlaufanimation. Okay, klicken Sie hier auf den Pfeil
und wählen Sie Endzeit. Klicken Sie hier auf diesen Pfeil
und überprüfen Sie, ob die Ausgangszeit abgelaufen ist. Lassen Sie uns hier einen
Bool-Parameter erstellen. Okay? Und nennen wir den
Parameter so, wie ich laufen kann. Lassen Sie uns hier wieder
auf den Pfeil klicken. Und lassen Sie uns den Parameter hinzufügen. Fügen wir hier eine Bedingung hinzu. Nehmen wir an, der
Wert „Can Walk“ ist wahr, Mutant, oder der Charakter
fängt an zu laufen Und wenn der Wert „Can Walk“ falsch ist, wird die Idle-Animation hier abgespielt. Beginnen wir hier mit der Deklaration einer
öffentlichen Float-Variablen. Geschwindigkeit des öffentlichen Floats. Das wird die Geschwindigkeit
des Charakters sein. Lassen Sie uns bei 2,0 F bleiben, Animator Bräunen, Schwerkraft in der Öffentlichkeit. Das ist die Schwerkraft
für den Charakter. Lass es uns bei
neun belassen, die
vertikale Geschwindigkeit im öffentlichen Float ist gleich Null Okay, außerdem werden wir hier einen
Character-Controller verwenden Der Charakter-Controller wird
im Grunde verwendet, um
den Charakter im Unity Character
Controller-Controller zu bewegen . Und dann
entspricht das innerhalb des
Startfunktionscontrollers dem Abrufen der Komponente Character Controller Okay? Und dann entspricht
Get Component Animator. Wir haben den
Charaktercontroller noch nicht
auf unseren Charakter angewendet Charaktercontroller noch nicht
auf unseren Charakter Okay, sobald wir das Skript geschrieben
haben, werden wir den
Charaktercontroller
auf unseren Charakter anwenden . Ordnung, lassen Sie uns hier
eine Funktion deklarieren , um den Charakter zu
bewegen. Nennen wir die Funktion move. Okay, also florizontal bedeutet,
Achse horizontal zu setzen . Und Float Vertical entspricht Input Get Access Vertikal . Schreiben wir eine If-Bedingung , um zu überprüfen, ob der
Controller geerdet ist In der
Zeichensteuerung gibt es eine Eigenschaft, die
überprüft, ob das Zeichen fest verankert
ist oder Nehmen wir an, wenn der
Condition Controller do fest ist, vertikale Geschwindigkeit gleich Null L vertikale Geschwindigkeit die
vertikale Geschwindigkeit gleich
Null L vertikale Geschwindigkeit
minus gleich der Schwerkraft bis zur Zeitdelta-Zeit Nach der L-Bedingung deklarieren
wir wieder einen Vektor drei, die
Schwerkraftbewegung
entspricht dem n-Vektor 30, Schwerkraftbewegung entspricht dem n-Vektor 30, Vertikalgeschwindigkeit Dann gibt es
noch einen Vektor drei , um den Spieler tatsächlich zu bewegen.
Vektor drei entspricht der
Transformation vorwärts in die
Vertikale und die Transformation nach rechts in Horizontale rechts in Wir werden jetzt den
Controller verwenden, um im Grunde die Bewegung des Spieler-Controllers zu bewegen Das ist
die Funktion innerhalb des Controllers, innerhalb des
Charakter-Controllers In der Funktion müssen wir die Parameter
übergeben, d. h. die Geschwindigkeit Ihres Spielers in
Delta T
in
die Delta T Plus-Schwerkraft Bewegung in die Zeit-Delta-Zeit. Die Schwerkraft bewegt sich in die
Zeitdelta-Zeit. Schließlich kann jeder Satzbulle
vertikal n gleich Null
oder horizontal n gleich Null laufen vertikal n gleich Null oder horizontal n gleich Nennen wir diese reibungslose Funktion hier, Insidety-Update-Funktion Speichern wir das Skript. Okay, bevor wir die Szene ausführen, müssen
wir den
Charakter-Controller
auf unseren Charakter anwenden . Klicken Sie auf Komponente hinzufügen und wählen Sie hier den
Charaktercontroller aus. Okay, wir haben also den
Charakter-Controller
auf den Charakter angewendet . Jetzt müssen wir im Grunde
die Mitte
des Charakter-Controllers
auf der Y-Achse anpassen . Okay, lassen Sie uns das auch hier ansprechen, lassen Sie uns die Höhe ändern. Erhöhen Sie die Höhe ein wenig. Fügen wir hier ein Skript hinzu
, bei dem die Figur zu
der Figur geht , bevor sie die Szene
ausführt. Lass uns die Kamera hier in meinem Charakter platzieren, sodass die Kamera dem Spieler
im Grunde folgt. Lass uns die Szene durchspielen und
schauen, wie sie aussieht. Ja, das ist in Ordnung.
Okay, sieht gut aus. Das war's, Leute. In
der nächsten Sitzung werden
wir die
Rotation sowohl auf die Kamera als auch
auf den Charakter anwenden . Wenn wir uns rückwärts bewegen wollen, können wir
die Maus hier einfach drehen Und auch der Player wird zusammen mit
der Kamera
gedreht Das war's Leute.
Danke für die Sitzung. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
70. Wende die Rotation auf die Kamera an und lasse sie dem 3D-Charakter folgen: Hallo Freunde, mein
Name ist Rohan Sue. In der letzten Sitzung haben wir eine
Animation auf diese Figur mit
drei D angewendet Animation auf diese Figur mit
drei D In dieser Sitzung werden wir die Kamera drehen. Im Grunde werden wir
dem Script
Character Walk einen
Code hinzufügen , den wir in der letzten Sitzung auf diesen
Charakter angewendet haben. Lass uns einen
Code in das
Character-Walk-Skript schreiben . Hier sind wir im Drehbuch. Lassen Sie uns noch einmal einige
Variablen deklarieren. Jetzt drehen wir die Kamera. Im Grunde genommen meine Kamera öffentlich
transformieren, Mausempfindlichkeit auf
öffentlichen Grundstücken. Wir werden
die Kamera mit einer Maus drehen. Hier ist diese Variable für die Empfindlichkeit der
Maus gleich zwei Public-Float-Up-Limit entspricht -50 und das
Public-Float-Down-Limit entspricht 50 F. Okay, wir haben hier also vier Variablen deklariert Schreiben wir
hier eine Funktion, um die Kamera,
die wir drehen, zu drehen Kamera,
die Das ist der Name der
Funktion innerhalb der Funktion. Horizontal schweben entspricht eingegebenem Punkt erhält Achse, Maus x Float vertikal
entspricht Eingabe, Y transformiert
Rotate Im Prinzip wird das
Zeichen auf der X-Achse um Null, auf der Y-Achse
horizontal bis zur
Mausempfindlichkeit
und
auf der Z-Achse wieder um Null gedreht horizontal bis zur
Mausempfindlichkeit auf der Z-Achse und
auf der Z-Achse wieder um Null Ich drehe minus vertikal zur Mausempfindlichkeit und 0,0 auf der Z-Achse. Lassen Sie uns nun
mithilfe von Vektor 3 die
aktuelle Drehung für die Kamera ermitteln. aktuelle
Rotation von Vektor drei
entspricht M lokalen Ural-Winkeln Lokale Euler-Winkel werden
hauptsächlich verwendet, um
die Drehung eines Spielobjekts
relativ zu seinem übergeordneten
Koordinatensystem festzulegen die Drehung eines Spielobjekts relativ zu seinem übergeordneten Ordnung, wenn die Rotation x größer als 180 ist, entspricht die
aktuelle Rotation x
minus 360 Jetzt entspricht
die nächste aktuelle
Umdrehung x Lampen-Matlam-Funktion Lampen-Matlam-Funktion in Unity. Im Grunde wird der Wert,
jeder Gleitkommawert oder ein beliebiger ganzzahliger
Wert zwischen einem bestimmten Bereich,
zwischen einem Minimal
- und Maximalbereich,
festgeklemmt jeder Gleitkommawert oder ein beliebiger ganzzahliger
Wert zwischen einem bestimmten Bereich,
zwischen einem Minimal
- und Maximalbereich, festgeklemmt In Ordnung, die Clam-Funktion
benötigt hier drei Parameter. Die erste ist die Variable
, die clam sein muss. Der zweite ist der Mindestwert. Und der dritte Parameter ist hier
der Maximalwert. Ordnung, wir müssen die aktuelle
Rotation X, Grenze und die untere Grenze begrenzen. Okay? Lassen Sie uns nun abschließend die lokale Drehung
für die Kamera
einstellen. Meine lokale Rotation entspricht Quaternion-Punkt-Euler Innerhalb des Eulers müssen wir die aktuelle Rotation passieren. Ordnung, lassen Sie uns
diese Rotationsfunktion jetzt in
der Aktualisierungsfunktion deklarieren diese Rotationsfunktion jetzt in
der Aktualisierungsfunktion Okay, also drehe. Lass uns das Skript jetzt speichern. Und lass uns jetzt zum
Unity-Editor gehen. In Ordnung, klicken Sie hier auf
meinen Charakter. Und für das
Character-Walk-Skript, okay, wir können
hier eine Eigenschaft sehen, die mir gehört, sie zeigt hier keine
Transformation. Also müssen wir die
Hauptkamera einfach per Drag-and-Drop in dieses perfekte Objekt ziehen. Wir können also sehen, wie sich die
Kamera hier dreht. Was ist, wenn wir uns hier rückwärts
bewegen wollen? Wir können einfach die
Kamera drehen und wieder zurückgehen. In Ordnung. Ordnung, perfekt. Sieht toll aus. Oh, okay, das ist perfekt. Alles klar, Leute,
vielen Dank. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
71. Entwerfe ein Level für das 3D-Spiel Knock the Cans: Hallo Freunde. Mein
Name ist Rohan Sev In dieser Sitzung
werden wir
ein Spiel namens Knock the Cans entwickeln ein Spiel namens Knock Der Zweck dieses Spiels wird
im Grunde darin bestehen, die Dosen
abzuklopfen Es wird also fünf Dosen geben. Also gut, und wir werden diese Dosen mit einem Ball
schlagen Lass uns mit der Erstellung
eines Spiels beginnen. Lass uns hier
zuerst Plane für das Spiel erstellen. Gehe zu Three D und
klicke hier auf Plane. Setze das Flugzeug zurück. 2000. Bringen Sie die Kamera auf der Z-Achse auf -5,435 0,43. Okay, das Gehen Sie zu Three D Object und
klicken Sie hier auf Ebene. Okay, lass es uns auf Null bringen. Behalten wir es bei 04.524 0,06 Umdrehungen auf der
X-Achse werden 270 sein Ordnung, das ist es. Lass uns hier einen Ballhalter
erstellen. Im Grunde genommen
wird ein Ballhalter ein Würfel sein. Okay, ich werde
einen Würfel erstellen. Sie können jede Art
von Vermögenswerten verwenden, die Sie möchten. Sie können Tabellen verwenden. Sie können Stühle
benutzen, was auch immer
Sie wollen. Ich werde
hier einen Würfel als Ballhalter erstellen. In Ordnung, also lass uns einen Würfel
erstellen. Skalieren wir den Würfel
auf der X-Achse auf eins. Halten Sie
es auf der Y-Achse auf 0,2 und auf der Z-Achse auf 0,3 Okay? Positionieren Sie den Würfel auf
der X-Achse auf 00,51 -4,68 Lassen Sie uns hier einen weiteren
erstellen, der halten kann, und das ist Okay, gehen wir zum Dosenhalter. Auch hier
den Dosenhalter auf
der X-Achse auf Null positionieren , 0,5 n auf der Z-Achse auf -1,8 Ich habe hier
einige Texturen heruntergeladen Lassen Sie uns
die Textur für den
Ballhalter einfach hierher ziehen und dort ablegen die Textur für den
Ballhalter einfach hierher Ordnung, hier
wird unser Ball im Grunde
in der Mitte platziert. Okay, lassen Sie uns die Textur
für den Dosenhalter hier auftragen. Lassen Sie uns hier Texturen
für den Boden auftragen. Flugzeug eins, Flugzeug zwei hier. Lassen Sie uns jetzt Dosen herstellen. Wie stellen wir Dosen her? Wir werden
im Grunde einen Zylinder für die Dosen
herstellen . In Ordnung, lassen Sie uns hier
Ihre erste Dose erstellen. Gehen Sie also zu Game Object, gehen Sie zu Three D, klicken Sie hier
auf Zylinder. Gehen wir zu Scene More
und skalieren die Dose. 20.30 0.30 0.3 Lass uns die Dose
hier platzieren Ich denke, es ist zu groß.
Lass es uns wahrscheinlich auf 0,2
herunterskalieren. Ja, 0,2 und 0,2 Okay, sieht nach unten besser aus. Okay, platzieren wir es hier. Das ist die erste Dose. Unsere Dose hat hier einen
Capsule Collider. Lassen Sie uns einen
Kapselbeschleuniger für die Dose entfernen. Und lassen Sie uns einen Maze Collider anwenden. Okay? Und klicken Sie hier auf Konvex. Fügen wir der Dose einen starren
Körper hinzu. Gehen wir jetzt hier zum
Dosenhalter. Und lassen Sie uns auch einen starren
Körper auf den Dosenhalter auftragen. Okay, lassen Sie uns die
Maske auf wahrscheinlich 500 erhöhen. Wähle hier das
Zylinder-Spielobjekt oder deine erste
Dose aus und drücke auf Taste D, um die
Dose im Grunde zu replizieren Okay, lass uns
die Dosen einfach richtig hier platzieren. Okay, ich habe alles erstellt,
dann lassen wir es für
die Hauptkamera hier etwas dunkler aussehen. Ich möchte nicht, dass eine Himmelsbox einfarbig
auswählt. Lassen Sie uns eine schwarze Farbe darauf auftragen. Für das gerichtete Licht. Ich möchte hier kein
gerichtetes Licht haben. Lass es uns dunkel machen. Und lassen Sie uns ein
Spotlicht hinzufügen. Okay, bringen wir es her. Passen wir das Spotlicht an. Fügen wir ein weiteres
Spotlicht hinzu. Ja, das sieht besser aus. Lass uns die Reichweite
ein bisschen reduzieren, bis
es hier gut aussieht. Das sieht besser aus. Ordnung, lassen Sie uns hier einen Ball
kreieren
, der hier auf
den Ballhalter gelegt wird. Wir müssen im Grunde ein
Prefabire erstellen, das erzeugt oder
instanziiert wird , wenn wir
auf den Spawn-Button klicken
, den wir Ordnung, für den Ball,
lassen Sie uns hier ein lassen Sie uns Gehen Sie zu Game Object und
klicken Sie auf Radio-Objekt und klicken Sie hier auf Speer. Ordnung, skalieren Sie den Ball
auf 0,15 auf der X-Achse, 0,15 auf der Y-Achse und 0,15 auf Auf der X-Achsenposition die Kugel auf Null auf der
Y-Achsenposition auf die Kugel 20,691 auf der Z-Achsenposition
auf Kugel zwei -4,695 In Ordnung, lassen Sie uns Okay, perfekt. Jetzt erstellen wir hier ganz links
eine Schaltfläche , um
den Ball
zu spawnen,
denn dieser Ball wird nur spawnen, wenn du hier auf
den Spawn-Button klickst Klicken Sie hier mit der rechten Maustaste auf das Spielobjekt Y und klicken Sie hier auf Okay, links unten, 55,5 auf der Y-Achse
bis 26,60 ist Behalten Sie die Breite der
Schaltfläche bei 84,5 In Ordnung, lassen Sie uns die Farbe für die Schaltfläche hier ändern ,
die dem Hintergrund
entspricht Okay, lassen Sie uns die
Textfarbe für die Schaltfläche ändern. Okay. Und ändere
den Text auf Spawn Ordnung, das ist es. Wir
haben hier ein Level geschaffen. In der nächsten Sitzung werden
wir ein Skript
erstellen, um
den Ball
zu schießen, den Ball quasi zu ziehen
und die Dosen umzuwerfen Außerdem werden wir ein Skript
erstellen, um
den Ball zu spawnen , sobald wir
den Ball auf die Dose werfen Das war's, Leute.
Danke für die Sitzung. Ich danke dir vielmals. Wir sehen uns in der nächsten Sitzung, Leute.
72. Anwende Logik, um Dosen niederzuschlagen - Teil 1: Freunde, mein Name ist Rohan Sev. In der letzten Sitzung haben wir ein Level für das Spiel
erstellt. Ordnung, in dieser
Sitzung werden wir ein Skript auf den Ball
anwenden
, damit wir den Ball werfen können. Schieß den Ball hier auf die Dosen. Aber bevor wir das tun, gehen wir
hier
zum Sphere-Spielobjekt, das unser Ball ist. Und lassen Sie uns einen
starren Körper darauf anwenden. Klicken Sie hier auf Komponente hinzufügen
und wählen Sie hier Rigid Body aus. Lass uns
einen Code schreiben. Lassen Sie uns
hier ein Skript erstellen, damit wir dieses Skript
an
das Sphere-Spielobjekt anhängen können . Und dann können wir
den Ball auf die Dosen werfen. In Ordnung, fangen wir hier an, einen Code zu
schreiben. Bevor wir das tun, müssen wir hier ein paar Variablen
deklarieren. Eigener Vektor drei, Position gedrückt halten, dann privater Vektor drei, Freigabeposition der
Maus, dann der starre Körper, um den starren Körper auf
das
Kugelspielobjekt anzuwenden , starrer Körper RB. Dann haben wir die Variable Private
Bull , mit der wir überprüfen können, ob wir den Ball
geworfen haben oder nicht. Wirf auf Vektor drei das Ziel y eins und y zwei. Okay, wir brauchen hier keine
Aktualisierungsfunktion, also entfernen wir die
Aktualisierungsfunktion innerhalb der Startfunktion, rufen
wir einen starren Körper auf, R B entspricht der
Komponente Starrkörper Hier werden wir also
zwei Funktionen innerhalb von
Einheit verwenden , bei gedrückter Maus gedrückter Maus wird
erkannt, wann wir mit
der Maustaste geklickt haben Und die zweite Funktion
ist die Mouse-Up-Funktion. Sie wird ausgelöst, wenn Sie die Maustaste
tatsächlich loslassen. In Ordnung, also lassen Sie uns bei der Mausfunktion eine
Lücke erzeugen. Drücken Sie die
Maus nach unten, weil Sie
hier
auf den Ball klicken, um ihn zu werfen. Alles klar, die Position der Maus
nach unten drücken entspricht eingegebenen Punkt-Mausposition, der Strahl eins entspricht zwei, Hauptbildschirm der
Kamera Punkt zu Position beim Drücken der Maus nach unten. Kamerabildschirm zur Funktion gibt
im Grunde einen Strahl zurück,
der von der Kamera durch
einen Bildschirmpunkt geht . Danach
deklarieren wir eine Up-Funktion. Dies wird ausgelöst, wenn
Sie die Maustaste loslassen. Ordnung, die
Freigabeposition der Maus entspricht der eingegebenen Mausposition Okay, jetzt lassen Sie die Maus los , um
den Ball erneut zu schießen zweite Strahl entspricht der Kamera, dem
Hauptbildschirm, zeigt auf die Position, in der die Maus losgelassen Wir werden ein Ergebnis aus Besetzung, Hit,
Hit
erstellen Ergebnis aus Besetzung, Hit,
Hit Was in Unity gecastet wird,
ist wie ein Laserstrahl. Im Grunde ist es wie
ein Strahl
, der von
seinem Ausgangspunkt aus beginnt, sich in die
angegebene Richtung bewegt und bis zu seiner angegebenen maximalen
Entfernung reicht. Ordnung, Cast gibt
true zurück , wenn er von
einem heruntergefallenen Objekt getroffen wird. Jetzt braucht
dieses Objekt einen Collider, dann Physik
zwei und
dann zwei und ist das Ziel der Auswurfstelle gleich dem F-Ergebnispunkt Lassen Sie uns eine weitere Funktion erstellen, um den Ball
tatsächlich in
diese bestimmte Richtung zu schießen Jetzt haben wir ein Wurfziel. Okay, lassen Sie uns hier eine
Funktion erstellen, mit der der Ball tatsächlich weggeschossen
wird, um dann
für n Vektor drei den
Wert true R B zurückzugeben Wert true R B für n Vektor Ziel
x auf die X-Achse werfen, dann das Ziel
auf die Y-Achse werfen
und das Ziel erneut auf
der Z-Achse auf 160 werfen ist in Ordnung Lassen Sie uns diese Cast-Funktion
hier innerhalb einer Up-Funktion deklarieren . Okay, wenn wir also
die Maus-Neufassung loslassen ,
wird die Shooting-Funktion hier ausgelöst. Klicke auf das Speerspielobjekt. Hier haben wir bereits Rigid Body
aufgetragen. Lassen Sie uns das Skript jetzt anwenden. Ziehe und wirf. Okay, lassen Sie uns die
Szene durchgehen und
schauen , ob wir den
Ball jetzt auf die Dosen schießen können. Ja. In Ordnung, Leute,
vielen Dank. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
73. Anwende Logik, um Dosen niederzuschlagen - Teil 2: Meine Freunde, mein Name
ist Rohan Vase. In dieser Sitzung werden
wir zwei Skripte erstellen. Eines ist das Manager-Skript, das das gesamte Spiel
verwalten wird. Und das andere ist das
Skript, mit
dem wir feststellen werden , ob die Dose zerstört
wurde oder nicht Aber bevor wir das tun, werden
wir ein Tag erstellen und dieses Tag hier an das
einfache Spielobjekt
anhängen Okay, gehen Sie also zum einfachen Objekt
und wählen Sie hier ein Tag aus und klicken Sie auf ein Tag. Dann neues Tag, nenne meine Crowd. Speichere es einfach. In Ordnung, wir haben
also unser Etikett hier
, das ist mein Boden. Schon wieder. Klicke auf ein
einfaches Spielobjekt, gehe zum Tag und wähle hier
mein Spielfeld aus. In Ordnung, okay. innerhalb des Manager-Skripts Lassen Sie uns innerhalb des Manager-Skripts zwei Variablen deklarieren. Die Anzahl der
Dosen, die öffentlich sind, entspricht Null Die
Anzahl der Zufallszahlen ist gleich Null. Lassen Sie uns nun ein leeres
Spiel Object Manager erstellen. Und lassen Sie uns
das Manager-Skript
an das leere Spielobjekt anhängen . Ordnung, Spielobjekt, erstelle ein leeres Objekt, benenne das Objekt als Manager, füge
hier die Komponente und das Manager-Skript hinzu. Fangen wir damit an, dass
die Variable bole
j gleich False ist. Dann müssen wir in
der Startfunktion das
Spielobjekt finden, an das
dieses Manager-Skript angehängt ist.
Wie machen wir das? M entspricht der Suche nach Objekttypmanager
im Update Schreiben wir eine If-Bedingung, um zu überprüfen, ob die Dose
zerstört wurde oder nicht Wir werden die Position
der Dose überprüfen. Lassen Sie uns im Grunde die F-Bedingung
schreiben. Wenn die Transformation des Spielobjekts Y kleiner als 0,5 Check gleich Falsch, Anzahl der Schläge ist gleich m, die
Anzahl der geklopften Dosen plus
eins und der Um nun die
Kollision mit dem Boden zu erkennen, schreiben
wir hier auf die Funktion
Collision Enter, void on
collision enter call call game object tag
entspricht gleich meinem Boden und überprüfen Sie, ob die Anzahl der geklopften
Dosen gleich m ist, Anzahl der geklopften Dosen plus
eine geprüfte ist gleich wahr. Klicken Sie hier auf Zylinder eins,
er kann nach unten, um die Anzahl der heruntergeworfenen Dosen zu sehen Klicken Sie
hier auf das Manager-Spielobjekt und lassen Sie uns die
Szene ausführen. Lass uns den Ball werfen. Okay, wir haben einen, den wir niederschlagen
können. Okay, lass uns das Spiel nochmal spielen. Okay, wir haben zwei Dosen abgeklopft. Jetzt funktioniert es perfekt. Aber wir können hier sehen, dass die
Anzahl der Chancen nicht steigt. Lassen Sie uns auch die
Anzahl der Zufallszahlen erhöhen. Lassen Sie uns hier eine deklarieren. Okay? Und wieder gilt: M
entspricht der Suche nach einem Objekt vom Typ Manager innerhalb der
Autoschießfunktion M, Zufallszahl entspricht M
Zufallszahl plus Okay, also vier Dosen, Anzahl der abgeklopften Dosen ist
vier und die Zufallszahl Es funktioniert. Perfekt.
Danke Leute. Danke für die Sitzung. In der nächsten Sitzung werden
wir
ein Skript schreiben, um den Ball zu spawnen Danke Leute. Wir sehen uns in der nächsten Sitzung.
Ich danke dir vielmals.
74. Prefab Creation und Instantiation im Spiel Knock the Cans: Hallo Freunde, mein Name
ist Rohan Suede. In dieser Sitzung
werden wir
den Ball mit diesem
Spawn-Button spawnen. Insgesamt hat
der Spieler
fünf Chancen, den Ball zu spawnen Ordnung, aber um den Ball zu
spawnen, müssen
wir aus dem Ball ein
Fertighaus machen Ein Prefab ist im Grunde eine
einfache Vorlage, die
verwendet werden kann, um Instanzen
dieses bestimmten Spielobjekts zu erstellen Ordnung, aber bevor wir
ein Prefab des Balls erstellen, taggen wir zuerst den Ball Okay, gehe hier zum
Speer-Spielobjekt
und klicke auf Tag und
füge hier ein neues Tag Nenne das Tag als meinen
Ball und speichere es. Okay, klicken Sie hier erneut auf das
Sphären-Spielobjekt. Gehe zum Tag und wähle hier
meinen Ball aus. Ordnung, und das Tag, mein Ball, ist jetzt
dem Sphären-Spielobjekt hinzugefügt. Okay,
danach erstellen Sie einen Ordner namens Prefabs innerhalb
des Asset-Ordners Und ziehen Sie einfach Ihr
Sphere-Spielobjekt per Drag & Drop in den Prefabs-Ordner und
das Da wir hier
ein Prefab erstellt haben, werden
wir das Sphäre-Spielobjekt deaktivieren Und das Sphäre-Spielobjekt ist
standardmäßig
in der Szene nicht sichtbar , es sei denn, wir klicken hier auf die Spawn-Schaltfläche Okay, also lass uns einen Code
schreiben, um das Sphere-Spielobjekt
oder den Ball im Spiel zu
spawnen Ordnung, ich habe hier bereits ein Skript
namens Ball Spawn
erstellt Lassen Sie uns hier ein paar
Variablen deklarieren. Manager M, Spielobjekt, Ball in der Startfunktion. Auch hier müssen wir das
Objekt vom Typ Manager
finden, das Objekt vom Typ Manager finden. Wir brauchen hier keine
Aktualisierungsfunktion. Lassen Sie uns einfach
die Aktualisierungsfunktion
anstelle der Aktualisierungsfunktion entfernen . Lassen Sie uns eine Funktion erstellen, eine benutzerdefinierte Funktion,
einen Public-Void-Spawn-Ball Schreiben wir eine If-Bedingung. Wenn das Spielobjekt
ein Objekt mit einem Tag findet, mein Ball gleich Null Dies dient dazu, zu überprüfen, ob der Ball bereits gespawnt
wurde oder Zufall zählt weniger als fünf Wir geben dem
Spieler nur fünf Chancen,
alle Dosen abzuwerfen Okay, die Anzahl der Chancen
sollte unter fünf liegen, wenn wir den Ball spawnen
wollen Um den Ball zu spawnen,
müssen wir instantiate verwenden, was eine Funktion in Unity ist Lassen Sie uns einen Ball und
die Position platzieren , an der wir das Objekt spawnen
wollen Null auf der X-Achse, 0,691 auf der Y-Achse,
-4,695 auf der Z-Achse und für die Squatanion-Identität der Rotation und Schreiben wir eine Bedingung, dass auch die Druckkugel existiert. Gehen Sie jetzt zum Drag-and-Throw-Skript. Sobald wir den
Ball hier schießen und sobald die Anzahl der Chancen um eins
erhöht oder hier um eins
erhöht wird. Lass uns das
Spielobjekt hier
zerstören, Zerstöre das Spielobjekt
nach 3 Sekunden. Lassen Sie uns hier ein leeres
Spielobjekt erstellen und das
Spielobjekt Spawn nennen Okay, erstelle leer. Lassen Sie uns dieses Objekt
als Spawn-Objekt benennen. Okay, und lassen Sie uns
den Script-Ball-Spawn
an dieses Objekt anhängen den Script-Ball-Spawn
an dieses Ball spawnen. Okay, jetzt können
wir hier kein
Spielobjekt mehr für den Ball sehen Also lass uns das Fertighaus einfach per
Drag-and-Drop hierher ziehen. Öffne hier
die Leinwand,
gehe zum Button, das
ist der Spawn-Button Im Grunde klicken Sie hier auf
dieses Plus, ziehen Sie
einfach das Spawn-Objekt Gehe zur Ball-Spawn- und
Spawnball-Funktion. Und lassen Sie uns die
Szene durchgehen und sehen ob wir den Ball
spawnen können Okay, lasst uns zuschlagen, indem wir hier
auf den Spawn-Button klicken. Ja, wir können
den Ball spawnen. Okay, der Ball existiert bereits. Okay, gehen wir
hier zum Manager und schauen uns die Anzahl der Chancen
an. Also ja, es sind zwei. Lass uns den Ball wieder spawnen. Okay. Drei, okay. Drei Dosen klopften und
vier Chancen waren weg. Können wir den Ball jetzt
spawnen? Oh, hier zeigt es, dass der
Ball bereits existiert. Zufallszahl liegt bei fünf Jahren, und unser Spiel ist tatsächlich vorbei. In der nächsten Sitzung
werden wir also ein Pop-up erstellen. Okay, wobei wir anzeigen
werden, dass das Spiel vorbei ist, sobald die Anzahl der
Chancen fünf beträgt. Okay Leute,
vielen Dank. Wir sehen uns in
der nächsten Sitzung. Ich danke euch vielmals, Leute.
75. Erstelle ein Gewinn- oder Verlustsystem im Spiel und letzte Worte: Freunde, mein Name ist Ron Masurev. In dieser Sitzung
werden wir
ein Pop-up erstellen, um zu erfahren, ob der Spieler das Spiel gewonnen
hat oder ob der
Spieler das Spiel verloren hat Rechts, klicken Sie hier auf die Leinwand, gehen Sie zu Y und klicken Sie auf Panel. Nennen wir es hier
Wind Panel. Und behalte es beim Dehnen. Dehnen. Passen wir das Panel an. Lassen Sie uns jetzt die
Farbe für das Panel hier ändern. Lassen Sie uns jetzt im Panel Text hinzufügen, richtig? Klicken Sie hier auf das Panel, gehen Sie zu Y und gehen Sie zum Text Mesio Lassen Sie uns die Größe auf 16 reduzieren. Ja, das ist in Ordnung. Lassen Sie uns hier die Farbe
für den Text ändern. Behalten wir die rote Farbe bei. Lassen Sie uns hier noch einmal die
Farbe für den Button ändern. Lassen wir den Knopf gelblich. Verlängern Sie den Button hier. Lassen Sie uns das so ändern
, dass es erneut abgespielt wird. Ändern Sie hier die Farbe für die
Schrift oder den Text. Lass es uns auf Schwarz belassen. jetzt das Häkchen im Windfeld, weil wir
es nicht zu Beginn des Spiels zeigen wollen , wir wollen es nur zeigen, wenn der
Spieler das Spiel hier gewinnt Lass uns das einfach
im Text hier überprüfen. Anstatt das Spiel gewonnen zu haben, ändere es
einfach in Spiel verloren. Behalten Sie den Text für
die Schaltfläche so bei, wie er ist. Okay, wir haben zwei Paneele erstellt, eines ist das Windpanel. Ein anderes ist das lose Panel hier. Deaktivieren Sie hier das lose Panel. Gehen wir nun zum
Manager-Skript. Und lassen Sie uns einen Code
schreiben, um diese Panels tatsächlich auf
der Grundlage der Ergebnisse
anzuzeigen,
unabhängig davon, ob der Spieler das Spiel verloren
hat oder ob der Spieler das Spiel gewonnen
hat. Lassen Sie uns hier eine
Bull-Variable deklarieren. Bol, getroffene Entscheidung
ist gleichbedeutend mit falsch. Windpaneel für öffentliches Spiel, Objekt für
öffentliches Spiel, loses Panel Lassen Sie uns nun hier eine
Routinefunktion erstellen. Tine ist im Grunde eine spezielle
Funktion, mit der
Unity jede Art von
Ausführung stoppt , bis eine
Bedingung erfüllt ist Auch hier macht es dort weiter
, wo es aufgehört hat. Zählerlast, Rendite der
Windpaneele, neues Gewicht für Sekunden, ein Windpaneel aktiv
bis zum Ende der getroffenen Entscheidung entspricht „
Wahr I Enumerator
Load Lose Panel Yield gebe neues Gewicht für Sekunden zurück, 3,5 lose Panelsatz aktiv, wahre Entscheidung ist gleich wahr innerhalb der Aktualisierungsfunktion Wenn innerhalb der Aktualisierungsfunktion die Anzahl der heruntergeworfenen Dosen
gleich fünf ist, entspricht getroffene
Entscheidung
gleich
Stürzen und die Zufallszahl ist kleiner als Stürzen und Um die Cortin-Funktion auszuführen, müssen
wir Start Curtin wir Darin können wir
unsere Funktion übergeben , nämlich
das Load Wind Panel Wenn
weniger als fünf Dosen klopfen und die
getroffene Entscheidung gleich fünf ist, entspricht die Fallzahl der Wahrscheinlichkeit gleich Dann fangen Sie an, das lose Paneel zu schneiden.
Das ist es Gehen Sie jetzt hier zum
Manager-Spielobjekt. Ziehen Sie das
Windpanel einfach per Drag & Drop hierher zum Windpanel und das lose Panel
hierher für das lose Panel. In Ordnung, das
ist also ein Wiederholungsskript. Wir brauchen hier keine Start- und
Aktualisierungsfunktionen. Lass uns
hier eine Funktion erstellen, um ein Spiel neu zu starten. Public void
Scene Manager neu starten, Szene
laden, Knock Can Level eins Das ist der Name unserer Szene. Im Grunde sind es
Klopfdosen Stufe eins. Aber wir können den Fehler hier sehen. Okay, Unity Engine-Management, wir müssen Unity Engine importieren. Führen Sie die Verwaltung durch. Wenn wir den
Szenenmanager in der Szene verwenden möchten, erweitern Sie das Windpanel hier
und klicken Sie auf die Schaltfläche
im Windpanel. Klicken Sie auf Ad Component
und Silplay, klicken Sie hier und
ziehen Sie die Schaltfläche hierher, um Silic
Restart hier erneut abzuspielen Lass uns jetzt die Szene durchspielen und schauen, wie das
Spiel Okay, du hast
das Spiel gewonnen, großartig. Also lass uns hier auf den
Replay-Button klicken. Okay, du hast das Spiel verloren. Lass uns noch einmal auf den
Replay-Button klicken und wir können das Spiel hier wieder
spielen Das war's also, Leute,
das ist das Ende des Spiels mit
Unity, Teil eins Hier in dieser Serie haben wir mit der
Unity-Installation und den
Grundlagen von C Sharp
wie Variablendeklaration,
Steuerung, Ablauf, Anweisungen,
Schleifen und Sammlungen begonnen Grundlagen von C Sharp
wie Variablendeklaration, . Darüber hinaus haben wir die
Benutzeroberfläche,
Unity-Events und Delegierte
erstellt und mehr über das
Unity-Eingabesystem gelernt. Wir haben auch etwas über die Immunität von
Physik-Engines gelernt
, zu der auch starre
Körper und Kollisionen gehören Im weiteren Verlauf
haben wir etwas über die
Animationen
Tod und Three D in Unity gelernt Animationen
Tod und Three D in Und schließlich haben wir
ein Spiel namens Knock
the Cans Down entwickelt , aber das ist noch nicht das
Ende des Tutorials Bald werde ich mir
komplexere Themen zum Thema Gaming einfallen komplexere Themen zum Thema Gaming Wearing the End, wir
werden in Unity
ein auf RPG-Shootern
basierendes Spiel entwickeln Unity
ein auf RPG-Shootern
basierendes Spiel Das war's, Leute, danke für all die Unterstützung und danke, dass
ihr mir zugehört Vielen Dank, Leute. Wir sehen uns bald wieder.
Ich danke dir vielmals.