Transkripte
1. Einführung: Willkommen bei der Spieleentwicklung mit Lua und Love Class. Während dieser Lektionen wird
der Prozess der Erstellung von Spielen von Grund auf
mit Liebe, auch als Love 2D bezeichnet, diskutiert der Prozess der Erstellung von Spielen von Grund auf
mit Liebe, . Und wir werden unsere gesamte Programmierung in Lua machen. Die Klasse ist projektbasiert. Ziel ist es, dieses Spiel hier zu erstellen, das als Grundlage für jedes Spiel im RPG-Stil dienen könnte. Diese Art von Spiel ist eine perfekte Einführung da es Spielerbewegungen, das
Lesen von Tastatureingaben, das Hinzufügen von Sprites,
Animationen, Kollisionen mit Physik
und Leveldesign mit Kacheln beinhaltet Lesen von Tastatureingaben, das Hinzufügen von Sprites, Animationen, Kollisionen mit Physik . Während wir an diesem Projekt arbeiten, werden
wir alle grundlegenden Grundlagen der Verwendung
von Liebe besprechen , damit Sie in der Lage
sind,
eigene einzigartige Spiele zu erstellen oder darauf aufzubauen. Sie brauchen keine Vertrautheit mit Spieleentwicklung oder Liebe zu de, um an dieser Klasse teilzunehmen. Wir besprechen, wie Sie alles auf Ihrem Computer installieren und einrichten können und dann von dort aus weitermachen. Ich empfehle Ihnen jedoch,
etwas Erfahrung mit dem Programmieren zu haben . Wenn Sie zuvor andere Programmiersprachen
außer Lua verwendet haben , können
Sie die Sprache wahrscheinlich ziemlich schnell
aufgreifen . Wenn Sie jedoch ganz neu in der Programmierung sind oder einfach nur ein Gefühl für Lua bekommen möchten. Ich habe eine andere Skillshare-Klasse namens Einführung in die Lua-Programmierung, die keine Vorkenntnisse voraussetzt und dich vollständig auf diesen Liebes-2D-Kurs vorbereitet. Wann immer du bereit bist,
beginnen wir damit,
Liebe zu installieren und Dinge einzurichten, um unsere Spiele zu programmieren. Fahren Sie mit der nächsten Lektion fort.
2. Installation und Einrichten: Hallo Leute. In diesem Video gehe ich die Schritte zur Installation
des Spiel-Frameworks durch . Liebe zu de, auf deinem Computer und
zeige auch , wie du neue Projekte einrichtest und wie du sie betreibst. Die Installation von Liebe ist sehr einfach. Du gehst einfach zu d.org. Und die Download-Links befinden sich genau hier in der Mitte. Wenn Sie auf dem Mac sind, können Sie
diese Datei einfach herunterladen und die Anwendung installieren. Und wenn Sie unter Windows sind, empfehle
ich das Installationsprogramm. Sie während des Windows-Setups
sicher, dass Sie
diesen Pfad genau hier, den Zielordner, verfolgen . Das werden wir in nur einer Sekunde benutzen. Sobald die Installation abgeschlossen ist, empfehle
ich, eine Verknüpfung zu erstellen, die Sie lieben möchten, auf Ihrem Desktop. Wenn Sie auf dem Mac sind, können Sie
die Love-Anwendung einfach zu Ihrem Dokument unter Windows hinzufügen . Wir werden diesen Installationspfad
von vor einem Moment besuchen . In meinem Fall ist es hier in C Program Files, liebe. Und wenn wir uns genauer ansehen und diese Love Dot
EXE-Datei finden, finden wir direkt in diesem Ordner. Wenn Sie den Punkt-EXE-Teil nicht sehen, können
Sie zu Ansicht wechseln und dann diese Dateinamenerweiterungen
auswählen. Und das zeigt die Erweiterung jeder Datei. Also möchten wir eine Abkürzung zu diesem Love Dot EXE erstellen. Also gehe ich runter auf An den Desktop senden. Und dann werden wir sehen, dass es hier eine Abkürzung gibt. Ich werde es in Liebe umbenennen. Sobald dies fertig ist, können Sie
fortfahren und darauf doppelklicken, um zu starten. Oder wenn Sie auf dem Mac sind, führen Sie einfach die Anwendung und Sie sollten ein Fenster sehen, das
ähnlich aussieht , nur eine seltsam aussehende Animation. Je nachdem
, welche Version von Liebe du verwendest, könnte es etwas anders aussehen . Aber das ist der Bildschirm, der anzeigt, wann Liebe läuft, aber kein Spiel gefunden wird. Und wenn du so etwas siehst, bedeutet
das, dass bisher alles gut ist. Der nächste Schritt besteht darin,
einen Texteditor zu installieren , den Sie zum Codieren verwenden. Du kannst alles benutzen, womit du dich wohl fühlst. Aber ich kann Visual Studio Code nur wärmstens empfehlen, weshalb ich in diesen Videos verwende. Und es ist völlig kostenlos. Sie können es von Code Dot Visual Studio.com abrufen. Und die Download-Links sind gleich hier oben. Laden Sie einfach das richtige für Ihr Betriebssystem herunter. Nachdem Sie Visual Studio-Code heruntergeladen und installiert haben, starten Sie ihn. In diesem Programm können wir Dateien für unser Spiel
bearbeiten und erstellen. Um dies zu tun, müssen wir jedoch
ein neues Liebesprojekt erstellen . Projekte und Lieben an D haben eine sehr einfache Struktur, um eine zu erstellen. Sie erstellen einfach
irgendwo auf Ihrem Computer einen neuen Ordner . Und in meinem Fall mache ich einfach meine auf dem Desktop, damit ich
mit der rechten Maustaste klicke und „Neuer Ordner“ auswähle. Und ich nenne diesen Ordner mein Spiel. Jetzt habe ich nur einen Ordner namens mein Spiel auf dem Desktop, oder dieser Ordner kann sich irgendwo auf Ihrem Computer befinden. Dann möchte der Code
in Visual Studio diesen Ordner öffnen. Und wir können das mit File machen. Und dann Öffne den Ordner. Und ich habe meinen Ordner auf meinem Desktop erstellt und genau hier, also wähle ich diesen Ordner und wähle Ordner auswählen. Jetzt ist unser Ordner geöffnet. Wir können den Namen meines Spiels
in diesem Abschnitt und die obere linke Ecke rechts hier sehen . Jetzt, da wir hier sind, besteht der nächste Schritt darin, unsere erste Lua-Datei zu erstellen. Und wir können das mit diesem neuen Datei-Button tun. Möglicherweise müssen Sie den Mauszeiger über diesen Abschnitt bewegen, um ihn zu sehen, aber klicken Sie auf Neue Datei und wir müssen
diesen Datei-Hauptpunkt Lua benennen . Es muss genau diesen Namen haben. Und sobald Sie
die Eingabetaste drücken, wird die Datei erstellt und sie sollte diesen neuen Tab hier öffnen. Es heißt Main Dot Lu up. Es ist gerade nur eine leere Datei. Und das ist es. Dies ist die einfache Struktur, bei der alle DIY-Projekte geliebt werden,
einfach nur mit einem Ordner beginnen , eine Datei namens main
enthält, die Lua genannt wird. Natürlich werden Sie diesem Ordner mehr hinzufügen, aber wenn wir dies allein haben, können wir das Projekt durch Liebe ausführen. Es gibt mehrere Möglichkeiten, ein Projekt auszuführen. Hier habe ich meinen Projektordner, nur mein Spiel. Und wie wir gerade gesehen haben, enthält es nur diese Datei
main.py und die wir gerade erstellt haben. Und eine Möglichkeit, diesen Code auszuführen, besteht darin,
den Projektordner zu nehmen und ihn auf eine Liebesverknüpfung zu ziehen. Und wenn es erfolgreich ist, sollte es auftauchen. Ein Liebesfenster könnte unbenannt sein, und es ist nur ein großer schwarzer Bildschirm. Wenn du das siehst, bedeutet das, dass es funktioniert hat. Da unsere Datei main.py leer ist, wird ein leeres Spiel erwartet. Sobald wir dieser Datei Code hinzugefügt haben, zeigt
das Fenster an was wir für unser Spiel wählen. Als Randnotiz können Sie
Ordner per Drag & Drop von einer beliebigen Stelle auf Ihrem Computer ziehen und ablegen . Es muss nicht speziell vom Desktop stammen. Obwohl das Ziehen und Ablegen einfach ist, können
wir es noch einfacher machen, indem wir
unser Projekt über Visual Studio Code ausführen . Um dies zu tun, müssen wir nur eine Erweiterung installieren. Und die Erweiterung ist nur ein Plug-In, das
VS-Code dazu bringt, etwas Bestimmtes zu machen. Auf dieser Registerkarte Erweiterungen hier suchen
wir nach dem
spezifischen, was wir wollen, was wir wollen, was als geliebte 2D-Unterstützung bezeichnet wird. Wenn Sie also danach suchen, sollten Sie
dieses liebe Support-Plugin finden . Sie können also weitermachen und das installieren. Und sobald Sie die Schaltflächen Deaktivieren und Deinstallieren sehen, wissen
Sie, dass die Erweiterung erfolgreich installiert wurde. Von hier aus müssen wir es jedoch ein wenig konfigurieren. Mit diesem Zahnradsymbol können
wir zu den Erweiterungseinstellungen wechseln. Und dann müssen wir hier drin überprüfen, dass dieser Weg, der Liebes-2D-Pfad, korrekt ist. Früher, als Sie Love to D installieren, sind wir zu dem Pfad gegangen, auf dem es
installiert wurde , um die Verknüpfung zu erstellen. Derselbe Weg ist es, was wir hier einbeziehen müssen. Wenn Sie unter Windows sind, ist der Pfad, der genau hier angezeigt wird, nämlich C Program
Files, Love, Love, Dot EXE. Dieser Weg ist wahrscheinlich korrekt. Und wenn Sie auf dem Mac sind die Love-App für Ihre Anwendungen installiert haben, wird
der Pfad wahrscheinlich dieser Pfad sein, der auf dem Bildschirm angezeigt wird. Überprüfen Sie jedoch immer, wo Sie tatsächlich installiert haben, und legen Sie denselben Pfad hier ein. Und sobald Sie diesen Pfad angegeben haben, können
wir
diese Registerkarten schließen und testen. Und Sie können einfach zu
Ihrem Hauptpunkt-unteren Tab oben zurückkehren Ihrem Hauptpunkt-unteren Tab oben oder zum Datei-Explorer-Teil gehen und auf main.py doppelklicken. Sobald wir hier sind, können
wir das Projekt mit einem Befehl ausführen. Unter Windows lautet der Befehl Alt L, und wenn Sie auf dem Mac sind, lautet
der Befehl Command L. Mit diesem Befehl führe
ich Alt L. und es startet unser Spiel. Es hat jeden Code gebraucht, der sich in
diesem Spielordner befand und führt ihn durch Liebe aus. Genau das Gleiche ist, wenn wir den Ordner
gezogen und abgelegt haben. Dies ist jedoch viel schneller und einfacher. Achten Sie also darauf, diesen Befehl im Hinterkopf zu behalten , wenn Sie Ihr Projekt ausführen möchten. An diesem Punkt bist du
bereit, dein Spiel zu programmieren. Sie beginnen damit, Code in diese Datei main.py einzufügen. Und während Sie sich entwickeln, können
Sie Ihrem Projektordner weitere Dateien hinzufügen.
3. Spielerbewegung: Hallo Leute. In diesem Video gehe ich durch, wie man einen einfachen Spielercharakter in d verliebt, wo man sie
mit den Pfeiltasten auf dem Bildschirm bewegen kann . Sobald du fertig bist, habe ich ein brandneues Projekt bereit. Es ist nur ein Ordner namens mein Spiel und darin als Datei namens main.py. Das ist die Grundlage für jedes Liebesprojekt. Und wir können diese Datei so ausführen, wie sie ist. Und wir werden einen schwarzen Bildschirm sehen, der
erwartet wird , da unsere Datei main.py noch keinen Code enthält. Der daraus resultierende Gewinn, der nur als schwarzes Fenster läuft. Das erste, was wir mit
jedem Spiel machen sollten , ist,
die drei Hauptfunktionen einzufügen , die wir für alle Liebesprojekte
verwenden, nämlich funktionell geliebte Punktlast. Dann gelobte Funktion Dot-Update mit DT in den Klammern. Und dann Funktion geliebt Dot Draw. Und mit diesen drei Funktionen erstellen
wir unser Spielerobjekt und fügen ihm einige Steuerelemente hinzu, damit es sich bewegen kann. Eine kurze Notiz, bevor wir beginnen, findet
die Ladefunktion direkt zu Spielbeginn statt. Die Update-Funktion passiert in jedem einzelnen Frame. Es wird also als unsere Spielschleife fungieren. Und die Draw-Funktion zeigt unsere Grafiken auf dem Bildschirm an. Machen Sie sich keine Sorgen, wenn Sie sich bei all dem nicht ganz im Klaren sind. Sobald wir etwas Code haben, wird das viel sinnvoller sein. Lassen Sie uns zunächst unseren Spielertisch erstellen, der in Liebe stattfindet Dot Load. Wir werden Spieler gleich machen, geschweifte Klammern
öffnen und schließen. Denken Sie nun daran, dass sich geschweifte
Klammern in Lua eher auf Tabellen beziehen. Da wir also hier eine offene und
schließende geschweifte Klammer machen , bedeutet das, dass der Spieler ein leerer Tisch sein wird. Als Nächstes geben wir ihm ein paar Immobilien. Nehmen wir an, Spieler dot x ist gleich 0 und Spieler Punkt y gleich 0. Diese fungieren als Positionswerte. Die Spielwelt ist wie ein großes Raster, in dem die X-Achse nach links und rechts verläuft und die Y-Achse nach oben und unten geht. Unser Spieler beginnt an Position 0,
0 oder dem Ursprung des Bildschirms. Lassen Sie uns als Nächstes das Spielerobjekt verwenden, um etwas in das Spielfenster zu
zeichnen. Alle Zeichnungen finden unten
in der Love-Dot-Draw-Funktion statt . Lasst uns also hier drin einen Kreis
zeichnen, der vorerst als Spieler fungiert. Wir werden sagen, geliebte Grafik Punktkreis. Und dann haben wir in den Klammern vier verschiedene Parameter, die wir angeben müssen. Erstens ist der Modus. Wir haben zwei Möglichkeiten. Wir haben Phil oder Linie, also füllen Sie, damit unser Kreis ausgefüllt wird. Dann brauchen wir die Exposition, die Spieler dx sein wird. Dann brauchen wir die Y-Position, Spieler Punkt y und dann den Radius des Kreises. Du kannst das machen, was immer du willst. Ich mache meine 100. Um es zusammenzufassen, wird diese Zeile hier
einen Kreis an Position 0, 0 zeichnen . Der Radius des Kreises wird
100 betragen und er wird ausgefüllt. Wenn wir nun unsere Datei speichern und dann ausführen, werden
wir sehen, dass wir in der oberen linken Ecke
einen Cutoff-Kreis haben . Jetzt ist der Grund, warum es abgeschnitten ist, weil sich
der Kreis auf Position 0, 0 und 000 befindet, die obere linke Ecke unseres Spielfensters genau hier. Lassen Sie uns die Position unseres Spielers in Position ändern, sagen
wir 400, 200. Jetzt ist unsere X-Position 400 und unsere y-Position ist 200. Wenn wir jetzt speichern und laufen, befindet sich
unser Kreis vollständig
im Spielfenster und jetzt können wir ihn vollständig sehen. Genauer gesagt, der Kreis bewegte sich nach rechts, 400 Pixel zu diesem Punkt genau hier
und dann auf 100 Pixel, so dass der Mittelpunkt des Kreises auf
Position vierhundertzweihundert liegt . Und denken Sie daran, dass je höher Ihr Y-Wert ist, desto mehr gehen Sie auf dem Bildschirm. Da wir hier 200 gesagt haben, bedeutet
das, dass wir auf 100 Pixel sinken. Jetzt, da wir ein Spielerobjekt haben , das auf dem Bildschirm angezeigt wird, können
wir jetzt daran arbeiten, es in Bewegung zu bringen. Diese Logik wird in
der Love Dot-Update-Funktion stattfinden , da Lambda-Update jedes einzelne Frame ausführt. Lassen Sie uns zunächst etwas Einfaches machen. Wir machen Player Dot x entspricht Spielerpunkt x plus eins. Mit anderen Worten, jeder Frame Player dot x wird um eins steigen. Wenn wir speichern und rennen, werden
wir sehen, dass sich unser Kreis jetzt langsam nach rechts
bewegt. Insbesondere bewegt sich jedes einzelne Frame ein Pixel. Ich nenne das gerne die Illusion von Bewegung. jedem Frame wird ein wenig aktualisiert, was es so aussieht, als würde es sich bewegen. Wenn wir diese in eine Drei ändern würden, bedeutet
das, dass wir
die Exposition jetzt um drei pro Frame ändern . Und wenn wir speichern und laufen, bewegt
es sich immer noch nach rechts, aber es bewegt sich jetzt schneller, insbesondere bewegt
es sich drei Pixel in jedem Bild, also ist das dreimal so schnell. Jetzt ist es unsere Aufgabe, diese Art von Bewegung auszuführen, aber sie entspricht den Pfeiltasten, die der Spieler drückt. Sie können Tastatureingaben sehr einfach lesen, und wir können dies mit einer if-Anweisung tun. Wir werden sagen, wenn das Schottky-Board geliebt wird, ist der Punkt unten. Und dann müssen wir in den Klammern hier angeben, auf welchen Schlüssel wir suchen, nicht vorhanden ist. Und wir beginnen mit rechts, oder mit anderen Worten, der Pfeiltaste nach rechts. Dann. Und wir werden diese Zeile einrücken und am Ende der if-Anweisung ein Ende setzen. Also hier fragen wir, ob die Pfeiltaste nach rechts gedrückt wird. Und wenn ja, bewegen wir den Spieler um drei Pixel nach rechts. Und das passiert in jedem einzelnen Frame. Es sucht also ständig danach. Wenn wir jetzt speichern und rennen, bewegt sich
der Spieler nicht, aber sobald ich die Pfeiltaste nach rechts drücke, bewegt er sich. Und das wird es nur tun, wenn
ich die Pfeiltaste nach unten drücken lasse. Jetzt machen wir das Gleiche, aber für eine andere Richtung. Wir halten es einfach und beginnen mit der linken Richtung. Anstatt also um drei zu erhöhen, werden wir
jedes Mal um drei sinken. Denn je kleiner der x-Wert des Players ist, desto mehr links vom Bildschirm wird es sein, wenn wir jetzt speichern und laufen, wenn ich rechts halte, bewegt er sich nach rechts. Aber wenn ich links halte, bewegt sich der
Spieler jetzt nach links. Jetzt haben wir beide horizontalen Richtungen arbeiten. Lassen Sie uns als Nächstes den Spieler dazu bringen, sich nach unten zu bewegen. Wenn wir diesen Abschnitt erneut kopieren und ihn hier einfügen, suchen
wir nach unten nach unten. Diesmal wollen wir die
Spielerausstellung nicht aktualisieren , da wir uns vertikal bewegen wollen. Senkrecht zu bewegen bedeutet, dass wir die Y-Position
der Spieler aktualisieren müssen. Spieler dot y ist also gleich Player Dot y und wir wollen nach unten gehen. Das bedeutet also, dass wir drei hinzufügen werden. Wenn wir speichern und rennen, wenn ich gedrückt halte, bewegt sich
der Spieler nach unten. Und schließlich haben wir noch eine Richtung vor uns. Wenn wir das kopieren, wollen
wir nachsehen. Und wenn wir aufsteigen wollen, sinken
wir einfach um drei. Und damit sollten wir alle vier Richtungen links, rechts, unten und oben haben. Und es sind eigentlich mehr als nur die vier Richtungen. Wenn ich gleichzeitig die Pfeiltasten gedrückt halte, bewegen
wir uns in einer Diagonale. Und das liegt daran, dass sowohl die x- die y-Eigenschaften gleichzeitig aktualisiert werden könnten, was zu einer diagonalen Bewegung führt. Bevor wir das Video beenden
, können wir aufräumen, dass wir plus
3 in vier verschiedenen Zeilen geschrieben haben . Dies ist im Allgemeinen eine schlechte Praxis denn wenn ich
die Geschwindigkeit der Spieler ändern wollte oder wie schnell er sich bewegt, müsste
ich diese drei auf allen
vier dieser Linien ändern und das wird irgendwie nervig. Es wäre sinnvoller, wenn wir eine neue Eigenschaft für den Spieler
erstellen würden, sagen wir
mal die Punktgeschwindigkeit des Spielers, und wir setzen sie auf drei. Jetzt kann ich das nehmen und anstatt an all diesen Stellen drei zu schreiben, kann
ich die Punktgeschwindigkeit des Spielers machen. Und wann immer ich die Spielergeschwindigkeit aktualisieren möchte, muss
ich diesen Wert nur hier aktualisieren. Sagen wir, ich wollte es auf fünf erhöhen. Jetzt bewegt sich mein Spieler mit fünf Pixeln pro Frame. Wenn ich also speichere und renne, bewegen
wir uns jetzt schneller und es ist viel einfacher zu verwalten. Und eine letzte Sache, die ich erwähnen möchte, ist diese D t- oder Delta-Zeit. Sie können diesen Wert verwenden, um Ihr Spiel unabhängig von der Bildrate zum Laufen zu bringen und sich gleich zu fühlen. Ich wollte nur eine Vorwarnung darüber geben. Es ist überhaupt nicht dringend, wenn du gerade erst anfängst. Ich werde ein bisschen mehr darauf aufbauen. Im nächsten Video zeige
ich, wie man echte Sprites in das Spiel zieht, anstatt nur einen einfachen Kreis wie diesen.
4. Sprites und Hintergründe: Hallo Leute. In diesem Video zeige ich, wie Sie
Ihre Sprites oder echtes Artwork
sowie Hintergründe zu Ihrem verliebten Spiel hinzufügen Ihre Sprites oder echtes Artwork können. Um dies zu zeigen, baue ich auf den Code aus dem Player-Bewegungsvideo auf. Grundsätzlich haben wir diesen Spielertisch. Und mit seinen Eigenschaften gehen
wir zur Draw-Funktion und zeichnen einen Kreis an der Position des Spielers. Und dann haben
wir in unserer Update-Funktion diese if-Anweisungen, die den Spieler mit den Pfeiltasten
steuern. Und am Ende haben wir einen Kreis, den wir steuern und
bewegen können , wenn wir die Pfeiltasten drücken. Jetzt ist ein Flugzeugkreis mit schwarzem Hintergrund nicht allzu interessant. Wir werden also tatsächliche Kunst-Assets
oder Sprites verwenden . Stattdessen. Sie können beliebige Bilder verwenden, die Sie möchten. Sie können selbst etwas erstellen, oder ich verwende dieses einfache Elternbild
sowie diesen grasbewachsenen Hintergrundpunkt PNG. Wenn Sie dieselben Bilder wie ich verwenden möchten, können
Sie die Registerkarte Projekte und
Ressourcen unter
diesem Video aufrufen Registerkarte Projekte und
Ressourcen unter und die Ressourcen auf der rechten Seite finden. Sie können Papagei
Dot PNG und das PNG von dort herunterladen . Die anderen Ressourcen werden in späteren Unterrichtsstunden verwendet. Wenn Sie Ihre Akte haben, ist es fertig. Wir werden sie tatsächlich in unseren Projektordner
verschieben wollen. Also mach weiter und kopiere diese Dateien. Und dann erstellen wir nächstes Jahr in Ihrem eigentlichen Projektordner, main.py, einen neuen Ordner. Ich nenne es Sprites. Und in diesem Ordner fügen
wir diese beiden Bilder ein, eines für den Hintergrund und eines für den Player. Und sobald Sie dies unten haben, werden Sie feststellen, dass wir in Visual Studio Code jetzt einen Sprites-Ordner haben. Und im Inneren haben wir Hintergrund auf PNG und Eltern-Punkt PNG oder welche Namen Sie ihnen gegeben haben. Der nächste Schritt besteht darin, dass wir diese Bilder in unseren Code
aufnehmen müssen . Und wir fangen mit dem Spieler-Sprite an. Wir machen dies einfach und organisiert, indem eine beliebige Eigenschaft für den Spielertisch platzieren. Wir werden sagen, Player Dot Sprite ist gleich Love Dot Graphics, Punkt-Punkt-Punkt-Punkt-neues Bild. Und dann ist der Umfang hier der Pfad, wo wir diese Datei gespeichert haben und den wir im Sprites-Ordner Slash Papagei Punkt PNG gespeichert
haben. Und das ist unser Spieler-Sprite. Und jetzt, da wir dieses Bild in Player Dots Sprite
geladen haben , können
wir es in der Draw-Funktion verwenden. Anstatt also einen Kreis zu zeichnen, werden wir das los. Und stattdessen sagen wir Love Dot Graphics Dot Draw. Und der erste Parameter ist das, was wir fallen lassen möchten, nämlich Player Dot Sprite. Als nächstes folgt die Position Punkt x und der Spieler Punkt y. Und wenn wir es speichern und ausführen, werden
wir sehen, dass unser Spieler jetzt durch unser Sprite
repräsentiert wird . In meinem Fall ist es der Papagei. Als Nächstes werden wir den Hintergrund im selben Deal zeichnen lassen. Wir müssen dieses Bild in eine Variable laden. Also werden wir in den
Hintergrund stellen, die bei Grafiken, diesem neuen Bild, gleichwertig geliebt werden. Und der Pfad ist Sprites Slash-Hintergrund, PNG. Jetzt, da wir es im Hintergrund gespeichert haben, können
wir dies noch einmal in der Draw-Funktion verwenden. Ich werde Dot Graphics, Dot Draw in Liebe setzen. Wir sind gegangen, um den Hintergrund zu zeichnen
und werden ihn an Position 0 zeichnen. Jetzt stellt die Position, die wir für
einen dieser
Draw-Funktionsaufrufe bereitstellen , tatsächlich die obere linke Ecke
des Bildes dar , das wir zeichnen. Da unser Hintergrund ein großes Quadrat oder Rechteck ist seine Position direkt bei 000 liegt, richten
wir ihn perfekt an unser Spielfenster aus, da 00 auch die obere linke Ecke des Fensters ist. Wenn wir sparen und rennen, werden
wir sehen, dass unser Grashintergrund jetzt vorhanden ist. Aber du wirst feststellen, dass die Spieler plötzlich verschwunden sind. Hier ist das Problem. Der Spieler ist immer noch da und wird immer noch gezeichnet, aber der Hintergrund wird darüber gezogen. Also ist es für uns einfach nicht mehr sichtbar. Für das Zeichnen von Sprites ist die Reihenfolge, in der Sie sie zeichnen, wichtig. In unserem Fall haben wir das Spieler-Sprite gezeichnet, aber dann machen wir den Hintergrund danach, was dazu führt, dass der Hintergrund oben platziert wird. Wenn Sie das beheben möchten, müssen
wir diese Bestellung nur umschalten. Wenn wir zuerst den Hintergrund zeichnen, bedeutet das, dass der Hintergrund gezeichnet wird und dann das Spieler-Sprite darüber gezogen wird. Wenn wir also jetzt speichern und rennen, werden
wir sehen, wie unser Spieler-Sprite
über unseren grasbewachsenen Hintergrund gezogen wird. Und das deckt die Grundlagen des Zeichnens von Sprites ab. Von hier aus möchte ich dieses Vogelspray in einen Menschen mit laufenden Animationen verwandeln ,
was ziemlich einfach ist, wenn wir eine Open-Source-Software
verwenden. Wir werden im nächsten Video darüber sprechen.
5. Animationen: Hallo Leute. In diesem Video zeige ich, wie du deinem Spielercharakter
Animationen hinzufügst , wo er gegenübersteht und
in jede Richtung geht , in die du dich bewegst. Ich werde diese Sprites verwenden, die durch width the love erstellt wurden und zur Verfügung gestellt wurden, um das Spiel art.org zu öffnen. Sie können diesen Dateiplayer-Blatt-Punkt PNG
von der Registerkarte Projekte und Ressourcen unten herunterladen . Oder es steht Ihnen frei, jedes andere Sprite-Blatt zu verwenden , das Sie verwenden möchten. Wenn Sie sich dieses Bild kurz ansehen, werden
Sie sehen, dass es vier Reihen gibt, die
jeweils eine andere Richtung darstellen. Unser Ziel ist es, jeden einzelnen Frame aus
einer bestimmten Zeile zu verwenden , um die Animation zu erstellen. Wenn jedes Bild schnell hintereinander gespielt wurde, wird
es die Illusion vermitteln, dass der Spieler läuft. Sobald Sie Ihr Projekt fertig haben, erstellen Sie einen Sprites-Ordner neben Ihrer main.py, falls Sie noch keinen haben. Und drinnen, mach weiter und füge diesen Spielerblattpunkt PNG ein. Sobald das wieder in Visual Studio Code erledigt ist, sollten
Sie sehen, dass Sie in Ihrem
Sprites-Ordner einen Spieler haben, den sie PNG punktet, was bedeutet, dass alles bereit ist. Wir müssen diese Datei nur in unseren Code aufnehmen, was wir genauso tun können wie jedes andere Sprite. Ich werde es zu einer Eigenschaft des Spieler-Objekts machen, und ich nenne es Player Sprite Sheet ist gleich, dass diese Grafik, dieses neue Bild, geliebt wird. Und dann brauchen wir den Pfad, der der Sprites-Ordner ist. Und der Name der Datei ist Player Strichblatt-Punkt PNG. Nachdem dies importiert wurde, möchte ich daran arbeiten, dies in eine Animation zu verwandeln. Dies wird mit
einer Open-Source-Software erreicht . Insbesondere werden wir
dieses Produkt hier namens Animate verwenden . Obwohl dieses Repo jetzt ein paar Jahre alt ist, ist
es immer noch sehr zuverlässig und eignet hervorragend für die Implementierung von verliebten Animationen in D.
Es gab ein paar Möglichkeiten, diesen Code in Ihr Projekt aufzunehmen. Wenn Sie Git installiert haben, können Sie zu diesem Code-Dropdown gehen, dieses HTTPS
kopieren und dann einen Git-Klon erstellen. Oder die andere Möglichkeit, dies zu tun, besteht darin, die Zip herunterzuladen. Und sobald dieser Zip heruntergeladen wurde, können
Sie es extrahieren. Und dann finden wir hier einen animierten Punkt lou eine Datei. Du wirst das kopieren wollen. Und zurück in unserem Projektordner erstellen
wir einen neuen Ordner, ich nenne ihn Bibliotheken. Und in diesem Ordner fügen
wir diesen animierten Punkt Lua ein. Sobald Sie das haben, fügen Sie es ein und Sie können es hier
sehen, möchten Sie dies in unseren Code importieren. Ich werde das ganz oben auf der Love Dot Load machen. Und wir werden sagen, dass animate equals Bibliotheken erfordern, was der Ordner ist, den wir gerade erstellt haben. Und dann ist der Name der Datei animiert. Nun animiert all das, dass kleiner Code in dieser globalen Variablen namens animate gespeichert
ist. An dieser Stelle können wir mit der Erstellung unserer Animationen beginnen. Der erste Schritt besteht darin, ein Raster zu erstellen, das
der Bibliothek hilft ,
Ihre Tabellenkalkulation in ihre einzelnen Bilder aufzuteilen . Sie können auf der animierten GitHub Seite weitere Informationen zu all diesen Dingen finden. Beginnen wir also damit, ein Raster für das Spielerobjekt zu erstellen. Ich nenne es Player Dot Grid gleich animieren neues Raster. Und in diesen Klammern
gibt es mehrere Parameter, die wir definieren müssen im Vergleich zur Breite und Höhe jedes einzelnen Rahmens. Und in unserem Fall ist jeder Rahmen 12 Pixel breit und 18 Pixel hoch. Wenn Sie sich die von uns verwendete Tabelle genau ansehen, werden
Sie feststellen, dass jeder einzelne Frame eine kleine Lücke
hat. Aber wenn wir diese Lücke einschließen, ist
jedes Bild 12 mal 18. Nachdem wir diese Dimension neu definiert
haben, müssen wir die Breite und
Höhe der vollständigen Tabellenkalkulation angeben , die wir sehr leicht erhalten können. Wir sagen Spieler-Punkt-Tabellenkalkulation. Und dann können wir Doppelpunkt sagen, Breite bekommen. Diese Zeile hier wird also die Breite unseres Spritesheets
bekommen. Und in ähnlicher Weise
möchten wir die Höhe für den nächsten Parameter, Spielerpunkte, Spritesheet, Anruf und Höhe ermitteln. Das ist also das Ganze, was wir brauchen, um unser Raster zu definieren. Wir haben die Breite und Höhe unserer einzelnen Rahmen sowie die Breite und Höhe des vollen Sprite-Blattes. Und am Ende gibt uns das unser Raster. Mit diesem Raster weiß
unser Code, wie wir unsere Tabellenkalkulation in die einzelnen Bilder aufteilen können. Und damit können wir unsere Animationen erstellen. Also werden wir all diese Animationen
in einer neuen Tabelle speichern . Eigentlich nenne ich es
Player-Punkt-Animationen gleich einer neuen leeren Tabelle. Und fangen wir mit dieser einen einfachen Animation an. Wir werden Spieler-Punkt-Animationen punktdown machen. Dies wird die erste Animation sein. Dann setzen wir die Abwärtsrichtung um. Und um eine Animation zu erstellen, animieren
wir Punkt-neue Animationen. Und in diesen Klammern müssen wir definieren, welche Frames aus diesem Spritesheet wir aufnehmen möchten. Und das machen wir mit dem Raster. Also sagen wir Spieler dieses Raster. Und dann müssen
wir in diesen Klammern definieren, welche Zeilen und Spalten wir einbeziehen möchten. Der erste Parameter hier sind die Spalten, die wir einbeziehen möchten, nämlich die Spalten eins bis vier. Weil wir vier Frames haben, die von links nach rechts verlaufen. Wir sagen also eins bis vier in einfachen Anführungszeichen genau so. Dann setzen wir ein Komma ein. Und danach möchten
wir definieren, aus welcher Zeile wir das kommen wollen, was in unserem Fall die Abwärtsrichtung von Zeile eins kommt. Also legen wir einfach einen hier hin. Und nachdem wir
unsere Spielerrad-Informationen definiert haben, setzen wir Komma ein. Der nächste Parameter ist die Zeit in Sekunden zwischen jedem Frame. Auch hier werden unsere Frames schnell hintereinander nacheinander spielen ,
aber wir mussten herausfinden, wie schnell wir wollen, dass sie gehen. Ich sage etwas wie 0.2 und du kannst das kleiner oder größer anpassen. Dies bedeutet, dass sich der Rahmen für unsere Animation um zwei Sekunden
ändert, was ziemlich schnell ist, aber Sie werden sehen, dass es
wirklich natürlich aussieht , wenn wir die Animation wiedergeben. Das ist also alles, was wir brauchen, um unsere Animation zu definieren, und sie wird in diesen Player-Punkt-Animationen abgespeichert. Also werde ich das tatsächlich kopieren und jetzt müssen wir diese Animation
aktualisieren und die Animation zeichnen. Also werde
ich im Update nach all diesem Code ins Spiel bringen, dass die Animation ein
Punkt-Down-Doppelpunkt-Update ist . Und dieses Update erfordert, dass wir DT weitergeben. Und wieder kommt d t von hier. In Liebe zum Update geben wir diesen Umfang einfach in unser Animationsupdate
weiter. Und nachdem das aktualisiert wurde, können
wir hier runter gehen und ich
werde unsere Kreisauslosung los. Oder Sie können auch
jede andere Zeichnung loswerden , die Sie neben dem Hintergrund
machen. Und ich mache Spieler-Punkt-Animationen,
Punkt-Down-Doppelpunkt-Draw . Und der erste Parameter hier ist die Tabelle, mit der wir diese Animation zeichnen,
bei der es sich um ein Spieler-Punkt-Spritesheet handelt. Danach ist die Position, wir diese Animation zeichnen möchten
, nämlich Player Dot x
und Player Dot y. Wir sollten die Animation abspielen sehen. Also lasst uns diese Datei speichern und anfangen. Und ein Problem, aber Sie werden sofort
feststellen, dass diese Animation viel zu klein
ist, da ich mit einigen Retro-Grafiken gearbeitet habe Dieses Sprite ist eigentlich nur 12 Pixel mal 800 Pixel, was sehr klein ist, aber wir können es ein wenig vergrößern. Also lasst uns weitermachen und in dieser Animation ist Draw. Es gibt einige zusätzliche Parameter, die den
regulären sehr ähnlich sind, die unsere Grafik zum Zeichnen der Funktion geliebt hat. Der nächste Parameter hier ist das optionale Rotationsfeld. Wir wollen das Bild nicht drehen. Lassen Sie uns also Null machen,
was bedeutet, dass Sie die Rotation nicht ändern. Und dann nach Null als unser Maßstab-X-Faktor. Also können wir so etwas wie 10 einsetzen. Und das bedeutet, dass der Umfang unserer Animation um das Zehnfache erhöht wird. Und wenn Sie einen Wert für Skala x angeben, bedeutet, dass Skala y diesen Wert ebenfalls annehmen
wird da wir nichts dafür angegeben haben. Damit sollten wir also erwarten, dass unser Sprite zehnmal größer ist, oder ich sollte unsere Animation sagen. Also lasst uns weitermachen und anfangen. Und da ist es. Es ist viel größer, aber ein bemerkenswertes Problem ist, dass es verschwommen ist. Wir können verhindern, dass unsere Skalierung die Bilder
verwischen lässt, wenn wir nach oben gehen. Und das machen wir gleich nach unserem Animate-Import. Wir werden die Grafikpunkt-Set-Standardfilter lieben. Und die Werte hier sind am nächsten, am nächsten. Mit dieser Linie wird
es also so gemacht, dass beim Vergrößern unserer Grafiken keine Unschärfe entsteht. Es nimmt einfach die Pixel und skaliert sie. Und jetzt, wenn ich anfange, sehen
wir, wie unsere Animation funktioniert und sie sieht ziemlich gut aus. Und da es an die x- und y-Werte des Spielers gebunden ist, können
wir uns normal bewegen, aber jetzt besteht unsere nächste Aufgabe darin,
die anderen Richtungen zum Laufen zu bringen , die wir unten haben, aber keine der anderen. Lasst uns also weitermachen und diese umsetzen. Wir werden sie auf eine sehr ähnliche Weise machen wie wir es getan haben. Ich kopiere tatsächlich die ganze Zeile hier. Und wir werden den nächsten machen. Wir sagen „links“. Jetzt befindet sich die linke Richtung in der zweiten Reihe. Ich ändere diesen in Reihe zwei. Als Nächstes haben wir gerade, genau in Reihe drei. Und dann haben wir endlich auf und oben in Reihe vier. Jetzt sind alle diese Animationen sehr ähnlich. Sie finden einfach in verschiedenen Reihen statt. Jetzt kommt die Herausforderung zwischen den Animationen zu
wechseln. Denn im Moment wird unsere Animation gezeichnet und aktualisiert, indem Player-Punkt-Animationen
für hier und hier manuell ausgewählt werden. In Wirklichkeit wissen wir
nicht, was wir nach Animationen suchen sollen, die wir verwenden möchten. Wir können dies mit einer neuen Immobilie verfolgen. Ich nenne es player.com. Und wir setzen es auf eine Animation ein, sagen
wir, Player-Punkt-Animationen Punkt übrig. Also jetzt enthält unser Spieler diese Eigenschaft Spieler für Animationen, die übrig sind. Damit können wir die Animation unserer Spieler verfolgen. Anstatt also manuell zu aktualisieren, sind die Animationen ausgefallen. Wir sind stattdessen laut Update Player Dot Enum. Und das gleiche gilt für unsere Auslosung. Wir werden nur den Spieler Dot A & M Draw machen. Auf diese Weise werden wir unabhängig von der Animation ,
die wir diesem Wert zugewiesen
haben , die wir sehen werden. Im Moment haben wir Player zu Animationen, die ihm zugewiesen sind. Wenn wir also speichern und rennen, sehen
wir, dass die nach links gerichtete Richtung jetzt die Animation ist, die wir hier sehen. An dieser Stelle möchten wir nur die
Animation der Spieler so ändern, dass sie jeder Richtung entspricht, in die sie sich bewegen. Dies kann durch Hinzufügen zu
unseren Bewegungssteuerelementen und der Update-Funktion erfolgen . Zum Beispiel halten wir
hier die Pfeiltaste nach rechts gedrückt. Das bedeutet, dass wir wahrscheinlich die Animation
als Spielerpunkt, Animationspunkt ändern möchten , oder? Also es genau hier drin. Ich kann weitermachen und das machen. Ich sage, Spieler dot nm entspricht Spieler-Animationen Punkt, oder? Und in ähnlicher Weise können wir genau
das Gleiche in allen vier dieser Richtungen tun. Dieser ist also übrig, nächste ist ausgefallen. Und schließlich ist dieser letzte auf. also Wenn ich also speichere und renne, ,
wenn ich diese Richtung geändert habe wird
die Spieler-Animation aktualisiert,
wenn ich diese Richtung geändert habe. Es funktioniert ziemlich gut. Das einzige verbleibende Problem hier ist, dass der Spieler auch nach dem Anhalten weiter an
Ort und Stelle läuft . Und idealerweise würden sie Animation auch anhalten und in eine Standposition wechseln. Im Wesentlichen möchten wir das Bild
des Spielers in diesen stehenden Rahmen ändern , wenn keine Pfeiltasten nach unten gedrückt werden. Sie werden feststellen, dass dieser stehende Rahmen
das zweite Bild und jede dieser Zeilen ist. Wenn also keine Pfeiltasten gedrückt
werden, zwingt die Animation, bei diesem zweiten Frame zu bleiben. Dies wird erneut in unserem Update-Abschnitt passieren, wir müssen prüfen, ob diesem Frame
keine Pfeiltasten gedrückt wurden. Wir werden dies also mit einer sehr einfachen lokalen Variablen verfolgen. Am Anfang des Frames wird eine lokale Bewegung erstellt. Und wir setzen das auf „false“. Dann wollen wir ändern, dass dies zu wahr wird. Wenn eine der Pfeiltasten in diesem Rahmen gedrückt wurde. Und wir können das noch einmal tun, genau in dieser IF-Aussage, wir können einfach sagen, dass es sich bewegt, gleich wahr ist. Denn wenn die Pfeiltaste nach rechts gedrückt wird, bedeutet
das, dass wir uns bewegen. Also müssen wir diesen Wert ändern. Und ich kopiere einfach diese Zeile und füge sie in alle vier if-Aussagen für jede der vier Richtungen ein. Am Ende unserer Update-Methode werden
wir also wissen, dass das Verschieben
entweder falsch sein wird , wenn nope-Pfeiltasten gedrückt wurden, oder wahr, wenn einer von ihnen es ausdrückt. Und wenn keiner von ihnen nach unten gedrückt wird, und mal sehen. Wenn sich bewegt, ist gleich falsch. Dann möchten
wir an dieser Stelle in dieser if-Anweisung die Animation der Spieler in den zweiten Frame ändern , in dem sie einfach still stehen. Und das wird mit player.com gemacht. Und es gibt einen Doppelpunkt zur Frame-Funktion. Und der Rahmen, zu dem wir gehen wollen, ist Frame Nummer zwei, das ist Standbild. Wenn wir jetzt speichern und rennen, steht
der Spieler still. Sobald ich mich bewege, beginnt er
wieder in alle vier Richtungen zu laufen . Und wenn ich aufhöre, wechseln sie wieder zum Stillstand. Und das funktioniert für alle vier Richtungen.
6. Level-Design und Kacheln: Hallo Leute. In diesem Video zeige ich die Grundlagen der Verwendung von Tiled, ein fantastischer Level-Editor, der ein
Muss für Spiel-Frameworks wie Love 2D ist , der keinen eingebauten Editor hat, den Vorgang des Hinzufügens eines Stylesheet, Entwerfen einer Map und Importieren unseres Levels in ein Liebes-2D-Spiel. Zuerst möchten Sie eine Kachel festlegen, die Sie dafür verwenden können. Dies ist nur ein großes Bild mit einer Reihe
einzelner Stücke, die wir verwenden
werden , um unser Level zu gestalten. Sie können diesen Kachel-Set-Punkt PNG
von der Registerkarte Projekte und Ressourcen unten herunterladen . Sobald du es fertig hast, halte ich meine Sachen
gerne organisiert. Also erstelle
ich in meinem Spielprojektordner einen neuen Ordner und nenne ihn Maps. Und dann füge
ich direkt in diesem Maps-Ordner dieses Kachel-Punkt-PNG-Bild ein. Als Nächstes müssen Sie gekachelt herunterladen. Beachten Sie, dass dies ein Name Ihres eigenen Preis-Tools ist. Obwohl Sie es
kostenlos herunterladen können , wenn Sie es nützlich finden, empfehle
ich dringend, etwas Geld zu zahlen , um den Entwickler zu unterstützen. Sobald Sie die Installation gekachelt haben, starten Sie es. Und wir können eine neue Map erstellen, indem wir zu Neue
, neue Map abrufen. Und in diesem Fenster, tut mir leid, es ist ein bisschen kleiner. Dieser Text skaliert hier nicht gut, aber die oberen Teile hier oben können alle ihre Standardwerte beibehalten, die orthogonaler CSV sind, und aufschreiben. Als nächstes folgt die Map-Größe. Wir können wählen, wie viele Kacheln breit und hoch unsere Karte sein wird. Ich denke, diese Standardeinstellung, 30 mal 30, ist hier okay. Und schließlich müssen wir unsere Fliesengröße angeben, die der Größe jeder einzelnen Kachel entspricht. Dies hängt davon ab, welches Kachelset Sie verwenden. Aber mit meiner ist jede Kachel 64 Pixel breit und 64 Pixel hoch. Und dann klicken wir auf Speichern unter um zu Ihrem Spielprojektordner zu navigieren. Und ich speichere das im Maps-Ordner. Und Alice rufen Sie einfach diese Testkarte auf und klicken Sie auf Speichern. Sobald das gespeichert ist, sollte der gekachelte Editor auftauchen
, wo wir unser Level entwerfen werden. Zuerst müssen wir jedoch unser Kachelset importieren. Dies geschieht unten rechts
mit diesem neuen Kachelset-Button. Zuerst müssen wir ihm
noch einmal einen Namen geben , tut mir leid, das ist klein. Ich nenne diese Testkacheln und stelle dann sicher, dass du die Einbettung in Map aktiviert hast. Dann brauchen wir einen Toot, unsere Quelle, die wir, wenn wir surfen, zurück zu
unserem Maps-Ordner navigieren und unsere Kacheln, dieses Bild, finden. Geben Sie dann noch einmal unsere Fliesenbreite und -höhe an, die in unserem Fall 64 mal 64 beträgt, und dann Rand und Abstand. Sie können diese Werte anpassen, wenn es Lücken zwischen oder um die Kacheln gibt. Aber in meinem Fall sind
alle Kacheln direkt
nebeneinander und ohne Lücken dazwischen. Der Abstand wird also 0 betragen und es gibt keinen Rand um den Rand des Kachelsatzes. Die Marge wird also auch 0 betragen. Und was ist der andere konfiguriert? Machen Sie weiter und klicken Sie auf, Okay. Und unten rechts solltest du sehen, wie dein Kachel-Setup auftaucht. Jetzt können Sie an dieser Stelle
auf eine dieser einzelnen Kacheln klicken auf eine dieser einzelnen Kacheln und sie verwenden, um Teile Ihrer Karte zu zeichnen. Und du kannst damit dein Level gestalten. Ich beginne damit,
eine Grundlinie dieses Grasbildes einzuführen . Und ich werde dieses Farbfüllwerkzeug benutzen, um rundum Gras
hineinzulegen. Dann kann ich von hier aus einzelne Kacheln auswählen und dem Stempelwerkzeug für den Rest des Levels wie
meine individuellen Pfade zeichnen . Eine Sache, die Sie beim Entwerfen vielleicht bemerken ist, dass wenn Sie beispielsweise versuchen,
einen dieser Bäume herzustellen und
ihn hier zu platzieren, das Gras darunter löscht. Und das liegt daran, dass die umgebenden Teile der Fliese transparent sind. Es ersetzt also das Gras um
ihn herum durch dieselbe Transparenz. Wir können das umgehen, indem wir eine neue Ebene erstellen. Im Moment arbeiten wir an dieser Kachelschicht 1. Nun, wir können eine neue Kachelebene erstellen und ich nenne sie Bäume. Wenn ich jetzt zurück zu
dieser Heckluft gehe und diese Fliese durch krass ersetze. Sobald ich zurück zu den Bäumen gehe, fliesen Luft. Jetzt wird jedes Mal, wenn ich es setze, auf diese neue Ebene gelegt. Also das Zeug auf Kacheln, jeder wird nicht ersetzt. Dies behebt dieses Problem. Und während wir dabei sind, könnte ich
diesen Namen genauso gut durch etwas wie Boden ersetzen . Und von hier aus geht es nur darum, dein Level zu gestalten. Gehen Sie also fort
und gestalten Sie Ihr Level nach Ihren Wünschen. Ich halte das vorerst sehr einfach, aber wann immer Sie mit Ihrer Karte fertig sind, aber wann immer Sie mit Ihrer Karte fertig sind, können
Sie das Projekt speichern und dann zu
Dateiexport gehen . Jetzt werden wir unser Projekt exportieren. Navigieren Sie dann zu Ihrem Spielprojektordner. Und wieder werde ich
diese Exportabneigung in unseren Maps-Ordner legen . Und du wirst unten sehen, dass wir es als Lua-Datei
speichern. Ich nenne es Testkarte. Das ist also sehr praktisch, da Liebe heute
Lua verwendet , was den
Konvertierungsprozess ziemlich einfach macht . Also mach weiter und spare. Und unsere Map exportiert sie jetzt als Lua-Datei. Um diese Karte in unser Liebesprojekt zu bringen,
müssen Sie nun eine Open-Source-Software verwenden. Sie können diese URL verwenden, um die GitHub-Seite
für die einfache Implementierung der Bibliothek zu erreichen . Diese Bibliothek liest diese ausgenutzte Karte und hilft dabei, alle diese Kacheln im Spiel zurückzuziehen. Um diesen Code zu erhalten, können Sie dieses Repo entweder klonen, wenn Sie wissen, wie das geht, oder wenn Sie nicht wissen, wie das geht, können
Sie zum Code gehen und wir laden einfach die ZIP-Datei herunter. Sobald es heruntergeladen wurde, möchten
Sie
die ZIP-Datei extrahieren und dann in diese Ordner navigieren. Und was wir wirklich wollen, ist dieser STI-Ordner. Sti steht für einfache geflieste Implementierung. Natürlich. Kopieren Sie nun diesen Ordner und gehen Sie dann zurück zu unserem Spielprojektordner. Ich behalte meinen gesamten Open Source-Code
gerne Ordner einer Bibliothek, aber du kannst ihn nach Belieben organisieren. Ich füge einfach diesen STI-Ordner ein. Und sobald Sie diesen STI-Ordner bereit haben, können
wir ihn mit Love Dot Load in unseren Code aufnehmen. Aber an der Spitze der Liebe, die ich
in STI einsetzen werde , gleich verlangen werde. Und dann werde
ich in diesen einfachen Anführungszeichen den Pfad zu diesem Ordner legen
, der Bibliotheken Slash STI war. Und das importiert
den gesamten STI-Code in diese STI-Variable. Und danach können
wir unsere Map erstellen oder in
das Spiel laden , indem wir sie in einer Variablen speichern. Ich nenne es Spielkarte gleich STI, Klammern. Und in diesen Klammern müssen wir den Pfad in
einfachen Anführungszeichen zu unserer exportierten Map-Datei angeben , die sich im Maps-Ordner befand, Slashtest IMAP-Punkt Lua. Da unsere Map als Lua-Datei exportiert wurde. Und jetzt, da diese Map in die Spielkarte geladen ist, müssen Sie sie nur noch zeichnen. Also hier unten und Draw Funktion, werden
wir jeden anderen
Hintergrund loswerden , den wir zeichnen. Und stattdessen mache ich Spielkarte, Doppelpunkt, Zeichnen. Und das war's. Eine sehr kleine Anmerkung ist wenn Sie das Beispielprojekt verwenden, werde
ich diese Skala
des Spielers auf sechs im Gegensatz zu 10 ändern , nur damit es zu den Kacheln ein bisschen besser passt. Aber wann immer Sie bereit sind, speichern Sie
das Projekt und führen Sie es aus. Und es hat funktioniert. Wir haben unsere Kacheln an Ort und Stelle und wir können das Spiel wie gewohnt spielen. Dies umfasst die Grundlagen der Verwendung von Kachelkarten und dem Importieren von Maps in Ihre Love 2D-Projekte. Ein bemerkenswertes Problem ist jedoch, dass wir
in dieser oberen linken Ecke unseres Spiel-Levels feststecken . Es gibt also keine Möglichkeit, den Rest davon zu sehen. Im nächsten Video fügen wir eine Kamera hinzu, die
dem Player folgt , mit der wir den gesamten Raum
erkunden können.
7. Kamera: Hallo Leute. In diesem Video zeige ich, wie Sie Ihren Liebes-2D-Spielen
eine Kamera hinzufügen , damit sie dem Spieler folgt und Sie mehr von Ihren Levels erkunden können. Alles, was Sie brauchen, um mit einem Projekt zu beginnen , bei dem Sie etwas haben, dem die Kamera folgen
soll. In meinem Fall habe ich dieses Spielerobjekt und Spieler dot x und Spieler dot y repräsentieren die Position des Spielers. Wenn ich das Spiel so ausführe wie es
ist, sieht es derzeit so aus. Aber natürlich gibt es keine Kamera, also kann ich den ganzen Raum nicht wirklich erkunden. Gleiche gilt für viele Aufgaben. Wir können eine Kamera sehr einfach hinzufügen indem wir eine Open-Source-Software verwenden. Gehen Sie zu dieser URL, um auf die GitHub-Seite für Buckel zu gelangen, die für Hilfe oder
Dienstprogramme für einen massiven Fortschritt steht . Hump ist eine Sammlung verschiedener Tools, darunter diese camera.capture-Datei. Klonen Sie dieses Repo. Oder wenn Sie sich nicht sicher sind, wie
Sie das machen sollen, können Sie mit dem
Code fortfahren und diesen dann als Zip herunterladen. Dann möchten Sie diese ZIP-Datei einfach extrahieren. Und dann finden wir im Ordner einfach diese camera.capture-Datei. Machen Sie weiter und kopieren Sie das. Und dann zurück in unserem Spielprojektordner, im Ordner der Bibliothek füge
ich eine Datei
in diesen Kamerapunkt ein. Wenn Sie derzeit keinen Ordner einer Bibliothek haben, können
Sie direkt neben
Ihrem Hauptpunkt Lua einen erstellen und ihn Bibliotheken nennen. Sobald das hinzugefügt wurde, kehren Sie zu Ihrem Code
zurück und wir werden diesen Kamera-Code in Love Dot Load importieren lassen. Ich werde einfach Kamera gleich benötigen. Und innerhalb der einfachen Anführungszeichen mache
ich den Pfad zur camera.capture-Datei, bei der die Slash-Kamera der Bibliotheken handelt. Jetzt wird die camera.capture-Datei in diese Kamera-Variable
geladen, und wir können damit ein tatsächliches Kameraobjekt erstellen. Ich nenne diese Cam gleich Kamera. Wenn Sie dies als Funktion aufrufen,
generiert im Wesentlichen ein Kameraobjekt und wird innerhalb von CAM gespeichert. Wann immer wir also mit der Kamera arbeiten wollen, wird diese Cam-Variable aufrufen. Jetzt, da dies geschaffen wurde, können
wir unsere Zeichnungsabschnitte so ändern, dass alles durch das Objektiv dieser Kamera betrachtet wird. Wir tun dies zu Beginn des Kieferabschnitts. Wir werden Cam Colon anhängen und dann werden wir alles andere einrücken. Und dann, nachdem alles gezeichnet ist, wird Cam Colon lösen. So kann Markierungen
an dem Punkt angebracht werden, an dem wir anfangen,
Dinge aus der Perspektive der Kamera zu zeichnen . Und CAM Detach ist der Punkt, an dem wir aufgehört haben, durch die Kamera zu schauen. In diesem Fall wird alles aus der Perspektive der Kamera
gezogen. Wenn Sie nun eine gekachelte Map mit einer
einfachen Kachelimplementierung zeichnen , wie ich es hier mache. Wir können
diese Game Map Colon Drauf Notation eigentlich nicht mehr verwenden . Dies steht leider ein wenig in Konflikt mit einer Kamera. Was wir also tun müssen, ist,
jeden Layer unserer Kachelkarte einzeln zu zeichnen . Wenn du dir meine gekachelte Map kurz ansiehst, habe ich zwei Ebenen. Ich habe Boden und habe Bäume. Wir müssen also jede dieser Ebenen einzeln zeichnen. Und ich kann das tun, indem ich
diese Spielkarte Colon Kiefer loswerde . Und stattdessen mache ich Spielkarten-Doppelpunkt-Zeichnungsebene. Und innerhalb der Klammern müssen wir angeben, die Ebene, die
wir zeichnen möchten , zuerst die Bodenebene zeichnet. Das bekommen wir also mit einer Spielkarte, Punktebenen. Und dann müssen wir in eckigen Klammern den Zeichenfolgennamen unserer Ebene
angeben, der gemahlen ist. Und derselbe Deal, ich kopiere das und wir werden das Gleiche machen, aber für Bäume. An dieser Stelle werden also alle
unsere Spielkarten-Layer gezeichnet, sowie der Spieler, der
in die Perspektive der Kamera gezeichnet wird . Wenn wir jetzt speichern und laufen würden, das Spiel wahrscheinlich nicht anders aussehen. Und das liegt daran, dass unsere Kamera im Moment bewegungslos
ist. Wir müssen es ändern, damit es immer folgt. Der Spieler wird dies in
unserem Code in den Update-Abschnitten tun. Also in geliebtem Update, wahrscheinlich am Ende des Love Dot Update. Nach all dem werde ich einfach den CAM-Dolon einsetzen. Schauen Sie sich an, wir setzen es auf Position Spieler Punkt x und Player dot y. So wird jedes Bild
die Kameraposition so verschieben , dass sie
überall dort übereinstimmt , wo sich der Spieler befindet. Wenn wir jetzt sparen und rennen, funktioniert es. Die Kamera folgt jetzt dem Player. Er könnte jedoch ein bisschen Offset-Problem bemerken. Der Spieler ist etwas außerhalb der Mitte, er ist ein bisschen unten und rechts zu viel. Und das liegt daran, dass die Kamera derzeit Player Dot x und Player Dot y folgt, die im Moment
die obere linke Ecke unseres Spielerbildes darstellen . Standardmäßig werden alle Animationen und alle Sprites an ihrem linken oberen Punkt gezeichnet. Und in diesem Fall
würden wir es vorziehen, von
der Mitte des Bildes aus zu zeichnen , damit unsere Kamera mit allem zentriert ist. Zurück in unserem Code gehen
wir dorthin, wo wir
den Spieler ziehen , der genau hier ist. Wir zeichnen unsere Animation. Und wir müssen diese Offset-Variablen aktualisieren. Also hier haben wir unsere Rotation, dann haben wir unsere Skala x. Und dann ist Skala x die Skala y, die als Null gesetzt wird. Aber nach der Skala ist y 0 x und 0 y, was wir angeben möchten. Für OX wollen wir die halbe Breite des Sprites, was 6 ist, da die Breite 12 beträgt. Für den Offset, warum wir die Hälfte der Höhe wollen, ist
die Höhe 18, also setzen wir neun ein. also jetzt speichern und laufen, Wenn wir also jetzt speichern und laufen, werden
wir sehen, dass unsere Kamera jetzt zentriert ist und sich der Spieler direkt in
der Mitte unserer Kameraaufnahme befindet . Das Letzte, was Sie ansprechen können, und dies ist völlig optional, aber Sie können verhindern, dass die Kamera diesen schwarzen
Off-Screen-Hintergrund zeigt , der über den Standort unserer Karte hinausgeht.
Alles, was wir tun müssen, ist die Kamera bewegt sich, wenn sie zu weit und nahe der Grenze
reicht. Beginnen wir damit, zuerst die linke Grenze zu adressieren. In unserer Update-Funktion gleich nachdem wir uns unsere Kamera angeschaut
haben, werden wir
gleich nachdem wir uns unsere Kamera angeschaut
haben, eine if-Anweisung machen, bei der wir die Breite und Höhe des Bildschirms
überprüfen. Lassen Sie uns zuerst die Breite des Bildschirms ermitteln und wir speichern ihn in einer lokalen W-Variablen. Und wir bekommen die Breite, indem wir geliebte starbe
Grafiken machen und Papa Breite bekommen, und das wird die Breite unseres Spielfensters bekommen. Dann machen wir lokale h gleich geliebt Ag Graphics dot GetHeight. Und das wird die Höhe unseres Spielfensters bekommen. Wenn wir es jetzt tun müssen, überprüfen Sie die Position der Kamera und vergleichen Sie sie mit dieser Breite. Also werden wir eine if-Aussage machen. Wir werden sagen, ob Cam Dot x oder die x-Position
unserer Kamera weniger als die halbe Breite beträgt, was bedeutet, dass wir gerade am Rand sind, aber nicht weiter gehen wollen. Dann. Wir wollen nur den Cam Dot EXE auf die halbe Breite umstellen. Die halbe Breite bringt die Kamera gerade weit genug vom Bildschirmrand
entfernt , so dass
sie diesen schwarzen Hintergrund nicht anzeigt. Und wenn wir jetzt sparen und rennen, wenn ich zu weit nach links gehe, werden
wir sehen, dass die Kameras anhalten sobald wir diese Grenze erreichen. Es zeigt diesen schwarzen Hintergrund nirgends auf der linken Seite des Bildschirms an. Machen wir das Gleiche für die obere Grenze. Wir machen das auf eine sehr ähnliche Weise. Ich kopiere das einfach. Und anstatt Campbell x zu überprüfen, werden
wir an
beiden Stellen Kim Dot y überprüfen und auch h. Dieses Mal überprüfen
wir die Höhe unseres Spielfensters. Wenn wir jetzt sparen und rennen, werden
wir sehen, dass wir diese obere Grenze
nicht mehr passieren können . Es zeigt nicht den schwarzen Umriss. Dann werden die rechten und unteren Ränder etwas schwieriger, weil wir die Breite
und Höhe unseres Hintergrunds ermitteln müssen . Also hier nach all dem Zeug bekomme
ich eine, eine andere lokale Variable. Ich nenne es lokale Karte W, wie in der Breite in Pixeln unserer Spielkarte. Dies geschieht mit der Punktbreite der Spielkarte mal nmap-Punktkachelbreite. Und was das darstellt, ist die Anzahl der Kacheln breit. Unsere K-Map ist, das repräsentiert, wie viele Pixel breit eine Kachel in unserer K-Map ist. Wie Sie bereits erwähnt haben, ist dieser Teil nur möglich, wenn Sie eine gekachelte Map verwenden. Wenn Sie einen regulären Hintergrund verwenden, dann sind dies nur die Hintergründe bei denen keine dieser Berechnung hier ist. Wir machen das Gleiche für die Kartenhöhe. Map h entspricht Spielkarte Punkthöhe mal Spielkarte, Papa, Gezeitenhöhe. Jetzt haben wir die Breite und Höhe unserer Map in Pixeln. Und ich zeige dir den endgültigen Code. Wenn wir die Map-Höhe kartiert haben, wir diese, um zu berechnen, wo Cam und Cam, warum sollten sie gehen, wenn sie
die rechte und untere Grenze erreichen ? Für den rechten Rand setzen wir ihn gleich der Breite unserer Karte, die genau hier diese Variable ist, abzüglich der Hälfte unserer Spielfensterbreite. Und das bringt uns direkt an die Grenze , wo es nichts außerhalb des Bildschirms zeigt. Gleiche Idee mit der Cam. Warum bekommen wir die Höhe unserer Map? Ganz unten subtrahieren
wir die Hälfte der Höhe unseres Spielfensters, wodurch die Kamera direkt an die Grenze gebracht wird, wo sie keinen dieser schwarzen Hintergrund zeigt. Wenn wir jetzt sparen und rennen, wenn ich nach unten rechts gehe, hält
es an der rechten Grenze und es hält auch an der unteren Grenze an. An dieser Stelle kann unsere Kamera also überhaupt
nicht aus dem Bildschirm gehen. Eine letzte Sache, die ich für
die Kamera demonstrieren möchte , ist, ob Sie
ein HUD haben möchten oder etwas, das gerade vor der Kamera
erscheint. Sie tun dies, indem Sie etwas außerhalb der Dose trennen. Testen wir das zum Beispiel einfach mit einem Love Die Graphics Dot Print. Und ich drucke hallo. Und dies wird an Position 10, 10 gedruckt. Obwohl es sehr klein ist, kann
man dieses kleine Hallo sehen. Und die obere linke Ecke, und sie bleibt dort, egal wohin die Kamera geht, weil sie außerhalb der Kameraperspektive
gezeichnet wird , sie verhält sich wie ein HUD. In der nächsten Lektion werden wir die Grundlagen der Physik besprechen, mit
denen wir
vertraut sein müssen , bevor wir tatsächliche Kollisionen in diesem Spiel implementieren
können.
8. Physik: Hallo Leute. In diesem Video werde ich die Grundlagen der
Verwendung von Physik in Love 2D behandeln und wie wir schnell Collider erstellen
können, die
miteinander interagieren und optional auf die Schwerkraft reagieren. Sie brauchen nichts, um mit
diesem Love 2D-Projekt zu beginnen .
Wir werden sogar ein brandneues
machen, Wir werden sogar ein brandneues
machen wenn Sie den vorherigen Lektionen folgen.
Dieses Video bietet einige zusätzliche Informationen, die wir benötigen um zu decken, bevor Sie damit fortfahren. Für die Physik gibt es
dafür ein Modul, das direkt in die Liebe integriert ist, und es ist sehr mächtig. Leider bedeutet das, dass es auch kompliziert ist. Aber es gibt Open-Source-Bibliotheken , die das Arbeiten mit der Physik erheblich erleichtern. Am beliebtesten ist das Windfeld. Wenn Field eine Reihe von
wirklich einfach zu bedienenden Tools zur Verfügung stellt wirklich einfach zu bedienenden Tools zur , die den Einstieg viel
schneller machen und Ihr Code einfacher zu schreiben ist. Ich persönlich benutze die Bibliothek für alle meine Spiele, obwohl sie kürzlich archiviert wurde, ist
sie
mit den neuesten Versionen der Liebe immer noch absolut zuverlässig . Und es macht wirklich einen großen Unterschied. Um diesen Code in Ihr Projekt aufzunehmen, können
Sie das Repo entweder klonen, wenn Sie wissen, wie das geht, oder Sie können mit dem Code fortfahren und die Postleitzahl herunterladen. Dann möchten Sie nur den Ordner extrahieren. Und dann wollen wir
diesen Windfeld-Ordner finden , der sich direkt neben dem Read Me befindet. Kopieren Sie dies
und navigieren Sie dann zu Ihrem Spielprojektordner. In meinem Fall verwende ich für diese Demonstration ein brandneues Projekt. Es ist nur eine main.py Datei. Ich erstelle einen neuen Ordner. Ich nenne es Bibliotheken. Da lege ich meinen
Open Source Code immer in den Ordner einer Bibliothek. Ich gehe hier rein und füge dann
in den Windfeld-Ordner ein. Jetzt mach weiter und öffne deinen Hauptpunkt Lua. Und für diese Demonstration
fange ich mit einer leeren Datei an. Um zu beginnen, habe ich immer
die Funktionen zum Laden Update und Zeichnen eingefügt , wie ich es hier getan habe. Und das erste, was wir tun werden, ist den Windfeld-Ordner zu
importieren , den wir gerade in unsere Bibliotheken kopiert haben. Also machen wir das mit WWF gleich require. Und dann werden
wir in diesen Anführungszeichen den Pfad zu dem Ordner machen, Bibliotheken Slash Windfeld
war. Denken Sie daran, dass wir
einen ganzen Windfeld-Ordner importieren und dieser in diese WWF-Variable eingefügt
wird. Und das ist importiert, wir
können damit anfangen, mit der Physik zu arbeiten. Der erste Schritt zur Arbeit mit Loves Physik besteht darin, eine Welt zu erschaffen. Jemand sollte sagen, dass World gleich WWF Dot New World ist. Eine Welt ist einfach ein Raum, in dem Physik-Objekte existieren, und wir nutzen die Welt, um unsere Objekte tatsächlich zu erschaffen. Erstellen wir zum Beispiel ein Spielerobjekt. Der Spieler ist gleich dem weltweiten Doppelpunkt. Und wir machen es zu einem Rechteck. Wir sagen „neuer Rechteck Collider“. Dann diese Klammern außer ein paar Parametern. Die erste ist
die Position , an der unser Spieler beginnen soll. Also setze ich sie auf Position 354 x und dann 100 für Y. Dann wollen wir die Breite und Höhe unseres Rechtecks. Ich schaffe es mit AT und Höhe 80. Jetzt ist unser Spieler ein Rechteck Collider und wird in dieser Spielervariablen
gespeichert. Und wenn ich Collider sage, beziehe
ich mich auf ein Physik-Objekt , das in unserer Welt existiert. Ein Teil dessen, was wenn Feld tut, ist Collider so einfach zu arbeiten sind. Normalerweise müssen
Sie mit der standardmäßigen geliebten Physikbibliothek einen Fixture
und eine Form definieren und dann alles separat verfolgen. Ein Collider aus dem Windfeld
ist jedoch eine Kombination aller drei an einem Ort, was es so viel einfacher macht. Bevor wir das Spiel speichern und ausführen, sollten
wir zwei schnelle Dinge hinzufügen. Zuerst möchten wir das World-Colon-Update hinzufügen. Dadurch wird sichergestellt, dass die Welt
aktualisiert wird und die gesamte Physik aktualisiert wird. Dann werde ich in Unentschieden die Welt-Doppelpunktauslosung einführen. Was World Colon
Draw jetzt macht, ist, dass es die Formen aller Collider in unserer Welt zeichnet. Also gehe ich weiter und rette und renne. Und da ist es, dieses Rechteckobjekt hier ist unser Player Collider. Es macht allerdings nichts. Eine Sache, die wir tun könnten, ist dieser Welt etwas Schwerkraft zu
verleihen. Diese neue Welt-Funktion hier
akzeptiert tatsächlich ein paar optionale Parameter, von denen
die ersten beiden die Schwerkraftdefinition sind. Also wenn ich 0 mache, versuchen wir es mit 100. Dies wäre die Schwerkraft, die nach unten geht. Dies ist der x-Wert für das, was unsere Schwerkraft ist, und dies ist der Y-Wert. Da wir also nur einen positiven Wert für y haben, bedeutet
positiv, nach unten zu gehen. Alle unsere physikalischen Objekte
müssen also von einer Schwerkraft nach unten betroffen sein. Wenn wir also jetzt sparen und rennen, werden
wir sehen, dass unser Spieler Collider jetzt nach unten fällt. Es fiel jedoch ziemlich langsam. Was wir also tun könnten, ist diese 100 auf 500 zu erhöhen. Dies macht die Schwerkraft intensiver. Daher fällt unser Spieler schneller. Nicht alle Objekte müssen jedoch von der Schwerkraft betroffen sein. Lassen Sie uns dies demonstrieren, indem wir
eine Plattform schaffen , auf der unser Spieler landen kann. Wir nennen es Boden, und wir werden Welt-Doppelpunkt machen, neues Rechteck-Durcheinander. Und seine Position. Ich lege es auf einhundert. Vierhundert ist seine Position. Und dann beträgt die Breite 600 und die Höhe wird 100 betragen. Wenn wir also jetzt sparen und rennen würden, sehen
wir unseren Boden, aber er folgt auch mit der Schwerkraft. Um den Boden weniger anfällig für
Schwerkraft zu machen oder die Schwerkraft insgesamt zu ignorieren, müssen
wir seinen Typ ändern. Wir können den Ground Colon Typ auf statisch setzen. Wenn wir also jetzt speichern und rennen, ist
unser Boden statisch,
was bedeutet, dass er nicht von der
Schwerkraft beeinflusst wird und der Spieler darauf landet. Und gerade habe ich erwähnt, dass es
Kräfte gibt , die man auf Collider anwenden kann. Lassen Sie uns unseren Spieler mit einem Impuls zum Springen bringen. Also nach all dem Zeug werde
ich eine Funktion einsetzen, die unsere Taste geliebt hat. Und hier werden wir prüfen ob die Taste gleich AP ist,
was bedeutet, dass wir die Pfeiltaste nach oben drücken und dann unseren Impuls anwenden. Wir werden sagen, dass Spieler Doppelpunkt einen linearen Impuls anwenden. Und der Impuls, den wir anwenden werden, ist 0. Und versuchen wir es mit negativen 5000. Jetzt ist ein linearer Impuls nur eine schnelle Kraft, die auf den Collider drückt. In diesem Fall haben wir
einen negativen Y-Wert angewendet , der auf den Spieler angewendet wurde. Da sich dieser negative 5000 in der y-Position befindet
, wird der Spieler den Spieler
nach oben schieben , da das Negative steigt. Wenn wir sparen und rennen. Wenn ich die Pfeiltaste nach oben drücke, springt
der Spieler ein wenig weil wir diesen linearen Impuls anwenden. Es gibt viele andere Aktionen Sie auf einen Collider anwenden können. Lassen Sie uns den Spieler dazu bringen, sich nach links und rechts zu bewegen,
indem wir diesmal eine Kraft im Gegensatz zu einem Impuls anwenden. Also machen wir dies in unserer Update-Funktion, und dann binden wir dies an die Pfeiltasten,
um zu sagen , dass der Tastaturpunkt ausgefallen ist und wir sagen links. Wenn also die linke Pfeiltaste gedrückt
wird, wenden wir eine Kraft an, wird sagen, dass Spieler Doppelpunkt Kraft anwenden. Und diesmal machen wir negative 5000 in der x-Position. Es wird uns also nach links bewegen. Und dann werden wir noch sagen, wenn wir unsere Tastatur lieben, ist das richtig. Und in diesem Fall werden
wir das Gleiche tun. Wenden Sie Kraft an, aber wir werden positive 5000 machen, was uns nach rechts bewegen wird. Und das sollte genug sein, wenn wir speichern und rennen, wo ich, wenn ich nach links drücke, mich nach links bewege, und wenn ich rechts drücke, bewege ich mich nach rechts, schiebe
irgendwie am Boden entlang. Was jedoch bei Kräften zu beachten
ist, ist, dass die immer weiter stapeln und intensiver werden. Warum beschleunigt der Spieler so stark, wenn er sich nach links und rechts bewegt. Wenn Sie dies einschränken möchten, können Sie nur eine Kraft anwenden, wenn der Spieler sich nicht bereits mit maximaler Geschwindigkeit bewegt. Wir können das schließen. Also werden wir diese Kraft hier nur anwenden wenn der Spieler sie braucht, um die maximale Geschwindigkeit zu erreichen. Sonst wollen wir es nicht anwenden, sonst wird es zu schnell gehen. Um den Spielern die tatsächliche Geschwindigkeit wie es in diesem Frame ist, können
wir lokale PX machen, PY entspricht dem Doppelpunkt des Spielers und die lineare Geschwindigkeit. Und diese Funktion hier wird die Geschwindigkeit
der Spieler erfassen und ihren x-Wert in p x und ihren Y-Wert in PY setzen. Jetzt können wir den P x-Wert
hier überprüfen , um festzustellen, ob wir diese Kraft tatsächlich anwenden wollen . Also hier in dieser Zeile werde ich sagen, und px ist größer als negativ 300. Also machen wir es so, dass negative 300 die Höchstgeschwindigkeit ist, die wir erreichen können. Wir werden die Truppe also nur anwenden, wenn wir unter diesem Schwellenwert liegen. Das Gleiche für das Recht. Wir werden sagen, und P x ist weniger als positiv 300. Also negative 300 für die linke Richtung, bewegt sich nach links und positiv für die rechte Richtung. Um die Dinge etwas bissiger zu machen, ändere
ich diesen 5000 hier auf 8000. Das wird uns ein bisschen schneller beschleunigen lassen. Wenn ich also jetzt speichere und renne, wenn ich links halte, bin ich nach links gegangen, und wenn ich rechts halte, bewege ich mich nach rechts. Aber du wirst feststellen, dass ich am Ende nicht
zu schnell gehe wie zuvor. Insgesamt
könnte dieses Spiel, das wir gerade erstellt haben , der Beginn eines vollständigen Platforming-Projekts sein. Und wir konnten es ziemlich schnell einrichten. Die GitHub-Seite für Windfeld bietet jede
Menge hilfreicher Informationen über die Arbeit mit der Physik. Ich empfehle dringend, es durchzulesen. Für das nächste Video nehme ich die hier diskutierten Konzepte auf und wende sie auf das Top-Down-Spiel aus den vorherigen Videos an.
9. Kollisionen: Hallo Leute. In diesem Video zeige ich, wie Sie Ihrem
Liebes-2D-Spiel
Wände und Kollisionen hinzufügen Ihrem
Liebes-2D-Spiel
Wände und Kollisionen können, damit Ihr Charakter nicht einfach durch Wände gehen kann. Darüber hinaus zeige ich, wie Sie
diese Wände im Spiel von Ihrer Kachel zu Map erzeugen können. Um zu beginnen, müssen wir das When Feld verwenden, über
das ich in einem früheren Video gesprochen habe. Diese ersten Schritte werden mit diesem Video identisch sein. Und zuerst gehst du auf die GitHub-Seite und klont sie entweder in dein Projekt oder du kannst es als Zip herunterladen. Dann möchten Sie diese Zip-Datei natürlich extrahieren. Und dann gehen wir hier rein und schnappen uns diesen Windfeld-Ordner. Es ist direkt neben dieser README-Datei. Ich kopiere das. Und zurück in unserem Spielprojektordner gehe
ich in den Ordner unserer Bibliothek und füge diesen Windfeld-Ordner hier ein. Sobald dieser Ordner fertig ist, müssen
wir ihn in unseren Code aufnehmen. Also an der Spitze werde ich WWF gleich benötigen hinzufügen. Und dann ist der Pfad Bibliotheken Slash Windfeld. Denken Sie daran, dass dadurch
der gesamte Windfeld-Ordner in diese WWF-Variable geladen wird. Jetzt können wir diese Variable verwenden, um unsere Welt zu erschaffen, wird sagen, dass World gleich WWF und dieser neuen Welt ist. Und dann ist
dies für die Schwerkraft-Parameter ein Top-Down-RPG-Stil-Spiele. Also werden wir kein Gravity 0 Komma 0 haben. Wir müssen auch die Welt aktualisieren, also unten und unsere Update-Funktion. Und wir werden das nach
unserem Spielerbewegungscode setzen . Also wahrscheinlich genau hier. Und wir werden World-Colon-Update sagen. Und dann müssen wir DT einfach so weitergeben. Und dann endlich runter und zeichne vorübergehend, werden
wir die Welt zeichnen. Also werden wir World Colon Draw sagen. Dies wird es uns ermöglichen, die Collider zu sehen, die wir schaffen. Aber am Ende werden wir dies wahrscheinlich entfernen
wollen, da wir nicht alle
diese Segelflugzeuge und das Endprodukt sehen wollen . Wissen Sie auch, dass wir es in unsere Kamera zeichnen ,
damit es im Objektiv der Kamera erscheint. Jetzt, da dies vorhanden ist, müssen wir unserem Spieler einen Collider
oder im Wesentlichen ein Physik-Objekt
geben, das es
ermöglicht, mit Wänden zu kollidieren. also oben zurück, wo wir unseren Spieler definieren. Ich gebe ihm auch einen Collider. Spieler Dot Collider ist also gleich dem Weltkolon, und dann machen wir es zu einem BSG-Rechteck. Also neuer BSG Rechteck Collider. Jetzt ähnelt ein BSG-Rechteck einem normalen Rechteck sehr, aber seine Ecken sind etwas nachgegeben. Es ist eher eine Oktagonform, die meiner Erfahrung nach ein
bisschen besser für Spielerfiguren funktioniert . Für die Parameter
ist der erste die X- und Y-Positionen. Also für x mache ich 400, und für y mache ich 250. Dann brauchen wir die Größe, die Breite und Höhe dieses BSG-Rechtecks mit Ich mache 40 und Höhe ich mache 80. Und dann gibt es noch einen weiteren Parameter, der bestimmt, wie weit diese Ecken eingegraben sind. Um dies zu demonstrieren, schaffe ich es 14, um anzufangen. Und dann wird eine weitere Sache, die ich mit
diesem Collider machen werde, nicht dazu bringen, etwas zu drehen, da ein Player-Punkt-Collider-Doppelpunkt die feste Rotation auf true setzt. Dies verhindert also, dass sich der Collider dreht. Jetzt wo dies vorhanden ist, werde
ich speichern und rennen. Und wir können sehen, dass unser Durcheinander genau hier ist. Und Sie können sehen, was ich damit meine, dass die Ecken eingegraben sind, also ist es wie ein normales Rechteck, aber diese Ecken sind schräg, also ist es eher eine ovale Form, technisch gesehen ist es ein Achteck. Aber Sie werden feststellen, dass der Collider derzeit nicht bewegt, er bleibt einfach an Ort und Stelle. Was wir jetzt eigentlich wollen, ist die Position des Spielers hier immer mit dieser Colliders-Position übereinstimmt. Um dabei zu helfen, werden wir, nachdem wir die Welt aktualisiert haben,
auch den Player dot x
gleich dem Player Dot Collider, Doppelpunkt GetX, setzen . Und das Gleiche mit dem weißen Spieler Punkt y ist gleich Spieler Dot Collider Colon bekommen y. Jetzt
wird die Position des Spielers immer mit dem Collider übereinstimmen. Wir sparen und laufen jetzt, wir sind gleichmäßig aufeinander abgestimmt, obwohl die Größe wahrscheinlich ein wenig angepasst werden
muss. Also lasst uns das zuerst machen. Ich scrolle zurück zu dem Ort
, an dem wir den Collider für den Spieler erstellt haben. Ich werde die Breite erhöhen, sagen
wir auf 50. Und wir werden diese 100 machen. Und ich kann diese 14 auch ändern, damit es weniger konkav ist. Ich ändere es in etwa zehn. Probieren wir das also mal aus. Das ist viel besser. Es ist viel näher, die Spielerparameter oder die Spielergröße anzupassen. Sie werden aber jetzt feststellen, dass wir uns nicht mehr bewegen können. Und das liegt daran, dass wir die Position
des Spielers immer in die Colliders-Position sperren . Und da sich der Collider nicht bewegt, können
wir uns auch nicht bewegen. Um dies zu beheben, werden
wir den
gesamten Bewegungscode, den wir für den Spieler gemacht haben, überarbeiten , aber ihn so ändern, dass er stattdessen den Collider
anspricht. All dieser Code passiert also im Update für diese, wenn Anweisungen, die nach
der Tastatureingabe suchen und wie wir uns normal
bewegen, die Exposition ändern. Stattdessen werden wir
die Geschwindigkeit des Colliders ändern . Um dabei zu helfen,
erstelle ich einige neue lokale Variablen. Ich sage local vx und setze das auf 0 und lokales VY und setze das auf 0. Diese werden also die Geschwindigkeit in x-Richtung und
die Y-Richtung unseres Colliders darstellen . Anstatt Plato dot x zu aktualisieren, stellen
wir stattdessen vx auf Spielergeschwindigkeit ein. Und das Gleiche mit all diesen anderen wird vx ändern. Entspricht der Punktgeschwindigkeit des Spielers. Aber da wir nach links gehen, wollen
wir, dass dies negativ ist. Also multiplizieren wir gespielte Geschwindigkeit mal negativ 1. Und dann werden
wir hier unten nach oben und unten VY aktualisieren. Vy entspricht Wiedergabegeschwindigkeit für Down, und dann ist v y gleich Spieler dieser Geschwindigkeit. Aber da wir aufsteigen, müssen wir dies mit einem negativen
multiplizieren. Und nach allem, was getan ist, werden
unsere VX- und VY-Werte werden
unsere VX- und VY-Werte
aktualisiert, damit sie mit der Tastatureingabe übereinstimmen. Wir können also einfach sagen, Player Dot Collider, Doppelpunkt setzt die lineare Geschwindigkeit. Und diese lineare Geschwindigkeitsfunktion nimmt zwei Parameter
ein, einen für die X-Geschwindigkeit und einen für die Y-Geschwindigkeit. So können wir v x für das x und dann v y für das y übergeben. Egal, welche Tastatureingabe wir eingegeben haben, es wird mit diesen beiden Parametern übereinstimmen und die lineare Geschwindigkeit unseres Colliders
aktualisieren. Wenn wir das also jetzt sparen und ausprobieren, wenn ich einige Richtungen halte, können
wir sehen, dass ich mich irgendwie bewege, aber ich bewege mich sehr langsam. Und das liegt daran, dass wir diese Werte
auf die Punktgeschwindigkeit des Spielers aktualisieren . Und wenn wir wieder nach oben scrollen, werden
wir wahrscheinlich feststellen, dass der Spieler mit dieser Geschwindigkeit sehr niedrig ist. Es sind nur fünf. Wir brauchen etwas näher an 300. Das ist eine angemessenere Geschwindigkeit. Wenn wir also jetzt speichern und rennen, bewegt sich
der Spieler genauer,
wenn ich mich bewege , bewegt sich der Collider. Und es passt
zu jedem Spieler mit x und Spieler, der y ist. Also bewegt sich unser Spielercharakter damit. Und mit dieser Änderung sollten Sie
keinen Unterschied darüber bemerken, wie sich der Spieler zu kontrollieren fühlt. Jetzt besteht der nächste Schritt darin,
einige Wände einzulegen , mit denen der Spieler kollidieren kann. Seitdem kann ich gerade durch
diese Bäume und die Gebäude und so laufen . Lassen Sie uns einen sehr einfachen Collider einsetzen, um es zu demonstrieren. Am unteren Rand unserer geliebten Dot-Load-Funktion werde
ich einen neuen Wandcollider einsetzen. Ich nenne es lokale Wand gleich World Colon, neuer Rechteck Collider. Whoops, neuer Rechteck Collider, kein BSG-Rechteck. Mit diesem neuen Rechteck Collider müssen
wir ihm eine Position geben, die an
Position einhundertzweihundert ausgegeben wird . Und dann für eine Breite, weiß ich nicht, mache
ich eine Breite von 120 und dann eine Höhe von 300. Da das an Ort und Stelle ist, sollten wir sehen, dass wenn wir dort speichern und rennen dieses große Rechteck hier ist unsere Wand. Aber du wirst feststellen, dass wenn wir hineingehen, die Mauer einfach umfällt. Ich hoffe, Sie können sehen, dass es irgendwie verblasst ist, aber die Mauer fällt um, weil unsere
beiden Collider dynamisch sind. Stattdessen müssen wir unseren Wandwand-Doppelpunkt den Typ auf statisch einstellen. Statisch bedeutet, dass es nicht
von Kollisionen betroffen ist und sich nicht entfernen wird. Wenn wir also jetzt sparen und rennen, wenn ich gegen die Wand renne, bleibt
die Wand genau an Ort und Stelle und der Charakter hörte auch auf, wenn wir hineingehen. Übrigens sieht es so aus, als ob die Grenze
unseres Colliders nicht genau mit dem Sprite des Spielers übereinstimmt. Wenn Sie möchten, können Sie
die Breite vergrößern , um genauer zu sein. Aber meiner Meinung nach ist es gut genug, nahe genug zu sein. Wie auch immer, wir haben unsere Wand funktioniert und es stoppt den Spieler. Was wir jetzt tun wollen, ist es so zu schaffen, dass wir diese Wände aus Fliesen
erzeugen können . Denken Sie daran, dass Sie dazu eine
einfache Implementierung für Ihr Projekt einrichten müssen . Also mach weiter und schau dir
dieses Video in der Ecke an , um auf den neuesten Stand zu kommen. So was für unsere Map verbunden ist, werden
wir zunächst hierher gehen und eine neue Objektebene
erstellen. Und wir werden es Mauern nennen. Jetzt, da dieser Wand-Layer erstellt wurde und wir sie ausgewählt haben, können
wir diese Werkzeuge hier oben für Objekte verwenden. Also klicke ich auf dieses Rechteckwerkzeug
und zeichne
einige Objekte über die
Stellen, und zeichne einige Objekte über an denen ich möchte, dass es eine Wand geben soll. Also habe ich zwei Objekte gezeichnet. Und wenn Sie diesen violetten Selektor hier oben verwenden, können
Sie diese bearbeiten, Sie können
sie verschieben und ihre Größe ändern. Aber ich habe zwei Objekte eingezeichnet. Ein weiterer Tipp, wenn es nicht wie für mich am Raster
rastet, können
Sie zum Einrasten der Ansicht
gehen und dann
hier Ihre Option zum Einrasten auswählen , wenn Sie
es genauer machen oder erstellen müssen schnappen Sie sich an das Raster. Wenn diese beiden Objekte eingezeichnet sind, speichere
ich die Karte. Aber dann gehe auch zum Dateiexport als. Und dann vergewissern Sie sich, dass Sie
es an den richtigen Ort exportieren . In meinem Fall ist es in meinem Spielordner, Maps, und dann ist es diese Testkarte. Geh zu einer Datei. Ich werde darüber hinaus sparen. Und das macht unsere Karte exportiert. Jedes Mal, wenn Sie Änderungen an Ihrer Karte vornehmen, müssen
Sie sicherstellen, dass Sie speichern und exportieren, andernfalls werden diese Änderungen nicht im Spiel angezeigt. Jetzt müssen wir While-Collider erstellen, die mit den Objekten übereinstimmen, für die wir gefliest eingezeichnet haben. Also werden wir ein paar Dinge dafür tun. Das erste, was ich mache, ist eine WALS-Tabelle zu erstellen. Dies wird also jedes
Wandobjekt enthalten , das wir erstellen. Als nächstes brauchen wir eine if-Aussage. Wir werden sagen, ob
Spiele-Map-Punktebenen mit eckigen Klammern und sagen Wände. Was diese if-Anweisung tut, ist zu
überprüfen , ob wir einen Layer namens Walls haben. Sonst machen wir nichts anderes. Wenn wir also einen Spielkarten-Layer namens Walls
haben, werden wir
alle Objekte in dieser Ebene durchlaufen . Und das machen wir mit einer for-Schleife. Wir sagen für ich komma paarweise. Und dann geben wir in den Klammern hier die
Spielkarte für Layer an. Das Gleiche wie zuvor, Wände. Aber dann sagen wir Punktobjekte. Das bringt uns also jedes Objekt in der Wandschicht. Und dann sagen wir tun und enden. In dieser for-Schleife werden
wir tatsächlich unsere Wandobjekte erzeugen. Und wir können diesen Code tatsächlich
hier nehmen und nutzen. Also fügen wir das
hier ein und formatieren es ein wenig. Jetzt. Im Moment codieren wir diese wie
einhundertzweihundert Sachen als Parameter. Stattdessen wollen wir das Objekt direkt
hier von gekachelt nehmen und diese Werte dafür verwenden. Also sage ich obj dot x und obj dot y für den x- und y-Wert. Und das Gleiche mit Breite und Höhe. Breite und Obsp-Punkthöhe. Und heb dir das auf. Egal welche Wand wir erstellen, sie nimmt diese Werte direkt von dem Objekt, das wir gefliest gezeichnet haben. Und noch eine letzte Sache, die wir
dieses soeben
erstellte Wandobjekt in unseren Wandtisch einfügen möchten dieses soeben
erstellte Wandobjekt . Also sage ich Tisch, füge Wände ein,
Wand, wodurch unser Wandobjekt in Wände gesteckt wird. Dies hilft uns, alles, was wir erschaffen, im Auge zu behalten. Um zu klären, warum das funktioniert, wir sehen, dass es eine Eigenschaft x, y,
width and height, die
wir hier links sehen können,
wenn ich eines dieser Objekte auswähle dass es eine Eigenschaft x, y,
width and height, die
wir hier links sehen können,
wenn ich eines , die wir hier links sehen können. Und das sind die genauen Eigenschaften, auf die wir zugreifen, wenn wir diese Wand erstellen. Lass uns weitermachen und sparen und rennen. Und wir können den weißen Umriss irgendwie sehen. Aber wenn ich hier in
diese Häuser gehe , in denen ich diese Objekte gezeichnet habe, können
wir sie nicht mehr durchlaufen. Und das ist das Gleiche bei diesem hier oben. Wo auch immer wir ein Objekt gefliest gezeichnet haben, da
sitzt jetzt ein Gesetz , das wir nicht mehr durchlaufen können. Und sobald Sie die restlichen Objekte in Kacheln einzeichnen, müssen
wir die Welt nicht mehr zeichnen, da alles auf das Level selbst genau ist. Wenn wir das also entfernen,
werden wir die Collider nicht mehr sehen, was genau das ist, was wir wollen. Wenn wir jetzt speichern und rennen, sieht
alles wieder normal aus, aber der Spieler hat eine Hitbox und jede
dieser Wände kann nicht mehr durchgehen. Also scheint alles vorhanden zu sein. Und das deckt alles ab. Wir haben jetzt eine sehr solide Grundlage für ein RPG-Spiel.
10. Wir kommen zum Ende: Das schließt den Hauptinhalt dieser Klasse ab. Wie alle Skillshare-Klassen
besteht die Möglichkeit, ein Klassenprojekt einzureichen. Ich möchte wirklich, dass jeder, der an
diesem Kurs teilnimmt , so kreativ wie möglich ist. Das Klassenprojekt besteht also einfach darin, alles zu machen, was Sie mögen. Dies kann beinhalten, dem Spiel, das
wir in den Videos erstellt haben, etwas Neues hinzuzufügen oder etwas Neues zu starten. Was auch immer Sie tun, ich
ermutige Sie dringend , die Dinge
zuerst einfach zu halten und dann zu komplizierteren Dingen aufzubauen. Mein erstes Spiel mit Liebe war ein sehr einfacher Breakout-Klon. Und jedes Spiel danach, basierend auf der Komplexität, ist
dies eine großartige Möglichkeit, zu lernen und zu üben, und ich ermutige meine Schüler immer, dasselbe zu tun. Eigenständig zu arbeiten kann jedoch eine Herausforderung sein. Es gibt also ein paar Tipps, die ich gerne teilen möchte. Erstens ist es, das Love 2D-Wiki zu verwenden. Diese Seite skizziert alles, was Sie über Love 2D und all seine Funktionen
benötigen könnten . Jede Funktion und Fähigkeit wird hier ausführlich beschrieben. Und es zu finden ist ziemlich einfach. Wenn ich zum Beispiel die Parameter
für Liebe demografische Punktzeichnung vergessen habe, kann ich einfach online für Liebe 2D googeln,
liebte unsere Grafiken, die ich zeichne. Und die Seite aus dem Wiki wird sofort auftauchen. Ich überprüfe ständig Dinge auf dieser Seite, wenn ich an meinen eigenen Spielen arbeite. Wenn Sie dann spezifische Fragen zu irgendetwas haben, schauen Sie sich
unbedingt die Love 2D-Foren an. Die Community hier ist sehr aktiv und die Leute sind immer bereit zu helfen, wenn man an etwas feststeckt. Eine weitere hilfreiche Sache ist es,
einige Open-Source-Liebesprojekte
online zu finden einige Open-Source-Liebesprojekte und zu prüfen, wie sie bestimmte Funktionen
codiert haben, um Ihnen den Einstieg zu erleichtern. Ich habe eine großartige Ressource auf meiner GitHub-Seite, die ein vollständiges Open-Source-Liebes-2D-Spiel ist. Sie können es herunterladen und lokal ausführen, um es zu spielen. Und dann steht Ihnen der gesamte Quellcode zur Verfügung, von dem Sie Ihre eigenen Spiele durchsuchen, von denen Sie
lernen und direkt verwenden können. Wenn Sie also mit Liebe an etwas arbeiten, gehen Sie
definitiv zur Registerkarte Projekte und
Ressourcen und klicken Sie auf die Schaltfläche Projekt erstellen, laden Sie einige Screenshots hoch und beschreiben Sie, woran Sie arbeiten. Ich freue mich sehr zu sehen , was sich die Leute einfallen lassen. Versuchen Sie jedoch zunächst noch einmal, es
einfach zu halten und arbeiten Sie sich nach oben. Einfach anzufangen ist der Schlüssel, um sich damit vertraut zu machen. Und ich würde sagen, dass wir diesen Kurs abschließen werden. Vielen Dank, dass Sie dieses Material durchgemacht haben. Wenn Sie dies noch nicht getan haben, hinterlassen
Sie bitte eine Bewertung und wenn Ihnen der Kurs
gefallen hat, empfehlen Sie ihn bitte. Ich schätze die Unterstützung von hier aus sehr. Zögern Sie nicht, mich bei Fragen zu Lua, Liebe oder allgemeinen Programmierprogrammen zu kontaktieren. Ich bin immer bereit zu helfen, wie ich kann mit all dem Gesagten, ich glaube, das deckt alles ab. Nochmals vielen Dank für meinen Unterricht und ich freue mich darauf, Sie im nächsten zu sehen.