Computerspiele programmieren (mit Bildern)

2024 Autor: Robert Blare | [email protected]. Zuletzt bearbeitet: 2023-12-17 07:23

Sie haben eine Idee für ein Computerspiel und möchten diese umsetzen? Oder haben Sie sich schon einmal gefragt, wie Computerspiele geschrieben werden? In diesem wikiHow zeigen wir dir, wie du drei grundlegende Computerspiele in Python schreibst. Sie benötigen ein grundlegendes Verständnis von Python und allgemeinen Programmierkonzepten, um Ihr erstes Spiel zu entwickeln.

Schritte

Teil 1 von 3: Erstellen eines textbasierten Spiels

Schritt 1. Wählen Sie eine Programmiersprache

Alle Programmiersprachen sind unterschiedlich, Sie müssen sich also entscheiden, welche Sie zum Schreiben Ihres Spiels verwenden möchten. Jede wichtige Programmiersprache unterstützt Texteingabe, Textausgabe und if-Konstruktionen (die wichtigsten Dinge, die Sie für ein einfaches textbasiertes Spiel benötigen), also erkunden Sie die Optionen und entscheiden Sie, mit welcher Sie sich am wohlsten fühlen und sich dem Lernen widmen. Hier sind einige Faktoren zu berücksichtigen:

Wofür wird die Sprache am häufigsten verwendet?

Einige Programmiersprachen wie JavaScript sind für das Web konzipiert, während andere wie Python, C oder C++ für die Ausführung von Computerprogrammen konzipiert sind. Streben Sie für Ihr Spiel eine Sprache mit einem breiteren Anwendungsbereich an, z. B. Python, C, C++ oder JavaScript.
Wie schwer ist es zu lernen?

Obwohl das Schreiben eines Programms nach einiger Übung in einer normalen Programmiersprache (d. Java und C erfordern zum Beispiel, dass Sie tiefere Programmierkonzepte verstehen als etwas wie Python, das für seine zugänglichere und unkompliziertere Syntax bekannt ist.
Wo kann ich es verwenden?

Sie möchten wahrscheinlich, dass alle Benutzer auf verschiedenen Systemen wie Linux, Mac oder Windows Ihr Spiel spielen können. Sie sollten also keine Sprache verwenden, die nur auf wenigen Systemen unterstützt wird, wie Visual Basic, das nur unter Windows unterstützt wird.

In diesem Artikel wird Python für die Beispiele eines textbasierten Spiels verwendet, aber Sie können nachschlagen, wie die Konzepte in jeder anderen Programmiersprache umgesetzt werden.

Schritt 2. Bereiten Sie Ihren Computer vor

Die beiden Hauptkomponenten, die Sie benötigen, sind ein Texteditor, in dem Sie Ihren Code schreiben, und ein Compiler, mit dem Sie ihn in ein Spiel verwandeln. Wenn Sie dem Beispiel in diesem Artikel folgen möchten, sollten Sie Python installieren und lernen, wie man Programme ausführt. Wenn Sie möchten, können Sie eine IDE (Integraded Desktop Environment) einrichten, die Bearbeiten, Kompilieren und Debuggen in einem einzigen Programm vereint. Die IDE von Python heißt IDLE. Sie können aber auch einfach jeden Texteditor verwenden, der Nur-Text unterstützt, wie Notepad für Windows, TextEdit für macOS oder Vim für Linux.

Schritt 3. Schreiben Sie einen Code, um den Spieler zu begrüßen

Der Spieler möchte wissen, was los ist und was er zu tun hat, also sollten Sie etwas Text für ihn drucken.

Dies geschieht mit der Funktion print() in Python. Um es auszuprobieren, öffnen Sie eine neue Datei mit der Erweiterung.py, geben Sie den folgenden Code ein, speichern und führen Sie sie aus:
```
print("Willkommen beim Zahlenrätselspiel!") print("Geben Sie eine ganze Zahl zwischen 1 und 1000 ein:")
```

Schritt 4. Generieren Sie eine Zufallszahl

Lassen Sie uns ein textbasiertes Spiel erstellen, das den Spieler auffordert, die richtige Zahl zu erraten. Das erste, was wir tun müssen, ist zu Beginn des Spiels eine Zufallszahl zu generieren, damit der Spieler nicht immer dieselbe Zahl errät. Da die Zahl während des gesamten Programms gleich bleibt, sollten Sie die Zufallszahl in einer Variablen speichern.

Python hat keine eingebaute Zufallszahlenfunktion, aber eine Standardbibliothek (das bedeutet, dass der Benutzer nichts zusätzliches installieren muss), die dies tut. Gehen Sie also zum Anfang Ihres Codes (vor den print()-Funktionen) und geben Sie die Zeile import random ein.
Verwenden Sie die Zufallsfunktion. Es heißt randint(), befindet sich in der soeben importierten Zufallsbibliothek und nimmt den minimalen und maximalen Wert, den die Zahl haben kann, als Argument. Gehen Sie also zurück zum Ende Ihres Codes und geben Sie folgende Zeile ein:
```
rightNum = random.randint(0, 1000)
```

Schritt 5. Holen Sie sich Eingaben vom Player

In einem Spiel möchte der Spieler etwas tun oder mit etwas interagieren. In einem textbasierten Spiel ist dies durch die Eingabe von Text möglich. Da wir nun eine Zufallszahl haben, sollten unsere nächsten Codezeilen den Spieler auffordern, seine beste Schätzung einzugeben.

Da der von Ihnen eingegebene Code die Anweisung zur Eingabe einer Zahl an den Spieler ausgibt, sollte er auch die eingegebene Zahl lesen. Dies geschieht mit input() in Python 3 und raw_input() in Python 2. Sie sollten in Python 3 schreiben, da Python 2 bald veraltet sein wird. Fügen Sie Ihrem Code die folgende Zeile hinzu, um die Eingabe des Spielers in einer Variablen namens number zu speichern:
```
userNum = input()
```

Schritt 6. Wandeln Sie die Eingabe des Players in einen verwendbaren Datentyp um

Der Spieler hat eine Nummer eingegeben – was nun?

Machen Sie die Eingabe des Spielers zu einer Zahl. Das mag verwirrend klingen, weil sie gerade eine Zahl eingegeben haben. Aber es gibt einen guten Grund: Python geht davon aus, dass alle Eingaben Text oder ein "String" sind, wie er in der Programmierung genannt wird. Dieser Text enthält die Nummer, die Sie erhalten möchten. Python hat eine Funktion, die einen String, der nur eine Zahl enthält, in die darin enthaltene Zahl umwandelt. Typ:
```
userNum = int(userNum)
```

Schritt 7. Vergleichen Sie die Nummer des Spielers mit der richtigen Nummer

Sobald der Spieler seine Nummer eingibt, müssen Sie sie mit der zufällig generierten vergleichen. Wenn die Zahlen nicht identisch sind, kann Ihr Spiel den Spieler dazu bringen, eine andere Zahl auszuprobieren. Wenn die Zahlen übereinstimmen, können Sie dem Spieler mitteilen, dass er richtig geraten hat, und das Programm beenden. Dies geschieht mit folgendem Code:

while userNum != rightNum: userNum = int(input())

Schritt 8. Geben Sie dem Spieler Feedback

Während Sie ihre Eingaben bereits verarbeitet haben, wird der Spieler dies nicht sehen. Sie müssen dem Spieler die Ergebnisse tatsächlich ausdrucken, damit er versteht, was passiert.

Sicherlich könnten Sie dem Spieler einfach sagen, ob seine Nummer richtig oder falsch ist. Aber bei diesem Ansatz muss der Spieler im schlimmsten Fall vielleicht 1000 Mal raten, was sehr langweilig wäre.
Sagen Sie dem Spieler also, ob seine Zahl zu klein oder zu groß ist. Dies wird ihre Anzahl von Vermutungen erheblich reduzieren. Wenn der Spieler zum Beispiel zuerst 500 errät und das Spiel antwortet "Too big. Try again", gibt es nur 500 mögliche Zahlen anstelle von 1000. Dies geschieht mit if-Konstruktionen, also ersetzen Sie den print("Falsch. Versuchen Sie es erneut.") mit einem.
Beachten Sie, dass die Prüfung, ob zwei Zahlen gleich sind, mit == erfolgt, nicht mit =. = weist der Variablen links davon den Wert rechts davon zu!

if userNum < rightNum: print("Zu klein. Versuchen Sie es erneut:") if userNum > rightNum: print("Zu groß. Versuchen Sie es erneut:")

Schritt 9. Testen Sie Ihren Code

Als Programmierer sollten Sie sich vergewissern, dass Ihr Code funktioniert, bevor Sie ihn als fertig betrachten.

Achten Sie beim Programmieren in Python darauf, dass die Einrückungen korrekt sind. Ihr Code sollte so aussehen:

import random print("Willkommen beim Zahlenrätselspiel!") print("Geben Sie eine ganze Zahl zwischen 1 und 1000 ein:") rightNum = random.randint(0, 1000) userNum = input() userNum = int(userNum) while userNum != rightNum: if userNum < rightNum: print("Zu klein. Versuchen Sie es erneut:") if userNum > rightNum: print("Zu groß. Versuchen Sie es erneut:") userNum = int(input()) print("Sie haben es erraten korrekt.")

Schritt 10. Bestätigen Sie die Eingabe

Der Spieler sollte nicht in der Lage sein, Ihr Spiel zu unterbrechen, indem er einfach das Falsche eingibt. "Bestätigen der Eingabe" bedeutet, sicherzustellen, dass der Spieler die richtige Eingabe gemacht hat, bevor er sie verarbeitet.

Öffnen Sie das Spiel erneut und versuchen Sie, etwas einzugeben, das keine Zahl ist. Das Spiel wird mit einem ValueError beendet. Um dies zu vermeiden, können Sie eine Möglichkeit implementieren, um zu überprüfen, ob die Eingabe eine Zahl war.
Definieren Sie eine Funktion. Da das Validieren der Eingabe ziemlich lang ist und Sie es mehrmals tun müssen, sollten Sie eine Funktion definieren. Es nimmt keine Argumente an und gibt eine Zahl zurück. Schreiben Sie zuerst def numInput(): oben in Ihren Code, direkt unter dem Importrandom.
Holen Sie sich einmal die Eingabe des Spielers. Verwenden Sie die Funktion input() und weisen Sie das Ergebnis der Variablen inp zu.
Wenn die Eingabe des Spielers keine Zahl ist, bitten Sie ihn, eine Zahl einzugeben. Um zu überprüfen, ob ein String eine Zahl ist, verwenden Sie die isdigit()-Funktionen, die nur eine ganze Zahl zulässt, sodass Sie dies nicht separat überprüfen müssen.
Wenn die Eingabe eine Zahl ist, konvertieren Sie sie von einer Zeichenfolge in eine Zahl und geben Sie das Ergebnis zurück. Verwenden Sie die Funktion int(), um den String in eine ganze Zahl umzuwandeln. Dadurch wird die Konvertierung im Hauptcode überflüssig und Sie sollten sie dort entfernen.
Ersetzen Sie alle Aufrufe von input() im Hauptcode durch Aufrufe von numInput().
Der Code der Funktion numInput() sieht so aus:

def numInput(): inp = input() while not inp.isdigit(): print("Sie wurden aufgefordert, eine ganze Zahl einzugeben! Geben Sie eine ganze Zahl ein:") inp = input() return int(inp)

Schritt 11. Testen Sie das Spiel erneut

Geben Sie absichtlich die falschen Dinge ein, um zu sehen, was passiert, und beheben Sie dann auftretende Fehler.

Versuchen Sie, Text einzugeben, wenn das Programm Sie nach einer Zahl fragt. Anstatt mit einer Fehlermeldung zu beenden, wird das Programm Sie jetzt erneut nach einer Nummer fragen

Schritt 12. Schlagen Sie vor, das Spiel neu zu starten, wenn es fertig ist

Auf diese Weise könnte der Spieler Ihr Spiel länger spielen, ohne es ständig neu starten zu müssen.

Fügen Sie den gesamten Code außer dem Import und der Funktionsdefinition in eine while-Schleife ein. Setzen Sie True als Bedingung: Dies ist immer wahr, sodass die Schleife für immer fortgesetzt wird.
Fragen Sie den Spieler, ob er noch einmal spielen möchte, nachdem er die Zahl richtig erraten hat. Verwenden Sie die Funktion print().
Wenn sie mit "Nein" antworten, brechen Sie aus dem Blick aus. Wenn sie etwas anderes beantworten, fahren Sie fort. Das Ausbrechen einer Schleife erfolgt mit der break-Anweisung.
Verschieben Sie das "Willkommen beim Zahlenrätselspiel" außerhalb der while-Schleife. Der Spieler möchte wahrscheinlich nicht jedes Mal begrüßt werden, wenn er das Spiel spielt. Verschieben Sie die Anweisung print("Willkommen beim Zahlenrätselspiel!" über das while True:, damit sie nur einmal gedruckt wird, wenn der Benutzer das erste Spiel startet.

Schritt 13. Testen Sie das Spiel

Sie müssen Ihr Spiel jedes Mal testen, wenn Sie eine neue Funktion implementieren.

Stellen Sie sicher, dass Sie mindestens einmal sowohl mit „Ja“als auch mit „Nein“antworten, um sicherzustellen, dass beide Optionen funktionieren. So sollte Ihr Code aussehen:

import random def numInput(): inp = input() while not inp.isdigit(): print("Sie wurden aufgefordert, eine ganze Zahl einzugeben! Geben Sie eine ganze Zahl ein:") inp = input() return int(inp) print ("Willkommen beim Zahlenrätselspiel!") while True: print("Geben Sie eine ganze Zahl zwischen 1 und 1000 ein:") rightNum = random.randint(0, 1000) userNum = numInput() while userNum != rightNum: if userNum < rightNum: print("Zu klein. Versuchen Sie es erneut:") if userNum > rightNum: print("Zu groß. Versuchen Sie es erneut:") userNum = numInput() print("Sie haben richtig geraten.") print("Haben Sie? Willst du wieder spielen? Gib No ein, um zu beenden.") if input() == "No": break

Schritt 14. Schreiben Sie andere textbasierte Spiele

Wie wäre es, als nächstes ein Textabenteuer zu schreiben? Oder ein Quizspiel? Seien Sie kreativ.

Spitze: Manchmal ist es hilfreich, in der Dokumentation nachzuschauen, wenn Sie sich nicht sicher sind, wie etwas gemacht wird oder wie eine Funktion verwendet wird. Die Dokumentation zu Python 3 finden Sie unter https://docs.python.org/3/. Manchmal führt auch die Suche nach dem, was Sie im Internet tun möchten, zu guten Ergebnissen.

Teil 2 von 3: Erstellen eines Spiels mit 2D-Grafik

Schritt 1. Wählen Sie eine Grafikbibliothek

Das Erstellen von Grafiken ist sehr kompliziert, und die meisten Programmiersprachen (einschließlich Python, C++, C, JavaScript) bieten nur minimale oder gar keine Unterstützung für Grafiken im Kern oder den Standardbibliotheken. Sie müssen also eine externe Bibliothek verwenden, um Grafiken erstellen zu können, zum Beispiel Pygame für Python.

Selbst bei einer Grafikbibliothek müssen Sie sich um Dinge wie die Anzeige eines Menüs kümmern, wie Sie überprüfen können, was der Spieler angeklickt hat, wie Sie die Kacheln anzeigen und so weiter. Wenn Sie sich lieber auf die Entwicklung des eigentlichen Spiels konzentrieren möchten, können Sie eine Spiele-Engine-Bibliothek wie Unity verwenden, die diese Dinge einfach implementiert

In diesem Artikel wird Python mit Cocos2D verwendet, um zu zeigen, wie ein einfacher 2D-Plattformer erstellt wird. Einige der genannten Konzepte sind in anderen Spiel-Engines möglicherweise nicht vorhanden. Weitere Informationen finden Sie in deren Dokumentation.

Schritt 2. Installieren Sie die von Ihnen gewählte Grafikbibliothek

Cocos2D für Python ist einfach zu installieren. Sie können es von https://python.cocos2d.org/index.html abrufen oder indem Sie sudo pip3 install cocos2d ausführen, wenn Sie Linux verwenden.

Schritt 3. Erstellen Sie ein neues Verzeichnis für Ihr Spiel und Ihre Medien

Sie werden Dinge wie Bilder und Sounds in Ihrem Spiel verwenden. Bewahren Sie diese Dinge im selben Verzeichnis wie das Programm auf. Dieses Verzeichnis sollte nichts anderes enthalten, damit Sie leicht sehen können, welche Assets Sie im Spiel haben.

Schritt 4. Erstellen Sie eine neue Codedatei im neuen Verzeichnis

Nennen Sie es main, mit der Dateierweiterung für Ihre Programmiersprache. Wenn Sie ein großes und komplexes Programm schreiben, bei dem es sinnvoll ist, mehrere Programmdateien zu haben, wird Ihnen dies angezeigt, welche die Hauptdatei ist.

In diesem Beispiel erstellen wir eine Datei namens main.py, die unseren gesamten Code enthält

Schritt 5. Erstellen Sie das Spielfenster

Dies ist die Grundvoraussetzung für ein Spiel mit Grafik.

Importieren Sie die erforderlichen cocos2d-Untermodule: cocos.director, cocos.scene und cocos.layer. Dies geschieht mit from subModuleName import *, wobei sub-Module name das Submodul ist, das Sie importieren möchten. Der Unterschied zwischen from … import * und import … besteht darin, dass Sie den Modulnamen nicht vor alles setzen müssen, was Sie aus diesem Modul mit ersterem verwenden.
Definieren Sie eine Unterklasse MainMenuBgr des ColorLayer. Dies bedeutet im Grunde, dass sich jeder von Ihnen erstellte Hauptmenühintergrund mit einigen von Ihnen vorgenommenen Änderungen wie eine Farbebene verhält.
Starten Sie den Cocos-Regisseur. Dadurch erhalten Sie ein neues Fenster. Wenn Sie keine Beschriftung festlegen, hat das Fenster dieselbe Beschriftung wie der Dateiname (main.py), was nicht professionell aussieht. Erlauben Sie die Größenänderung des Fensters mit, indem Sie Größenveränderung auf True setzen.
Definieren Sie eine Funktion showMainMenu. Sie sollten den Code zum Anzeigen des Hauptmenüs in eine Funktion einfügen, da Sie so durch erneuten Aufruf der Funktion einfach zum Hauptmenü zurückkehren können.
Erstellen Sie eine Szene. Die Szene besteht vorerst aus einer Ebene, die ein Objekt der von Ihnen definierten MainMenuBgr-Klasse ist.
Führen Sie diese Szene im Fenster aus.

from cocos.director import * from cocos.scene import * from cocos.layer import * class MainMenuBgr(ColorLayer): def _init_(self): super(MainMenu, self)._init_(0, 200, 255, 255) def showMainMenu(): menuSc = Scene(MainMenuBgr())director.run(menuSc)director.init(caption="IcyPlat - ein einfacher Plattformer", resizable=True) showMainMenu()

Schritt 6. Fügen Sie dem Fenster ein Hauptmenü hinzu

Neben dem eigentlichen Spiel müssen Sie neben anderen Elementen, die Sie später hinzufügen können, ein Menü hinzufügen, mit dem der Spieler das Fenster schließen kann.

Importieren Sie cocos.menu (wieder mit der from-Anweisung) und pyglet.app (diesmal mit Import).
Definieren Sie MainMenu als Unterklasse von Menu.
Legen Sie die Ausrichtung des Hauptmenüs fest. Die vertikale und horizontale Ausrichtung müssen Sie separat einstellen.
Erstellen Sie eine Liste mit Menüpunkten und fügen Sie sie dem Menü hinzu. Sie sollten mindestens die Menüpunkte "Spiel starten" und "Beenden" haben. Jeder Menüpunkt sollte in Klammern stehen. Jedes Element muss über ein Label und eine Callback-Funktion verfügen, die bestimmt, was passiert, wenn der Player darauf klickt. Verwenden Sie für den Punkt "Spiel starten" die Funktion startGame (Sie werden es bald schreiben), für den Punkt "Beenden" verwenden Sie "pyglet.app.exit" (bereits vorhanden). Erstellen Sie das eigentliche Menü, indem Sie self.create_menu(menuItems) aufrufen.
Definiere startGame(). Geben Sie für den Moment einfach Pass in die Definition ein, Sie werden das ersetzen, wenn Sie das eigentliche Spiel schreiben.
Gehen Sie zu der Stelle in Ihrem Code, an der Sie die menuSc-Szene erstellt haben, und fügen Sie ein MainMenu-Objekt hinzu.

Ihr gesamter Code sollte nun wie folgt aussehen:

aus cocos.director importieren * aus cocos.menu importieren * aus cocos.scene importieren * aus cocos.layer importieren * importieren pyglet.app-Klasse MainMenuBgr(ColorLayer): def _init_(self): super(MainMenuBgr, self)._init_(0, 200, 255, 255) class MainMenu(Menu): def _init_(self): super(MainMenu, self)._init_("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Spiel starten ", startGame)), (MenuItem("Quit", pyglet.app.exit))] self.create_menu(menuItems) def startGame(): pass def showMainMenu(): menuSc = Scene(MainMenuBgr()) menuSc.add(MainMenu())director.run(menuSc)director.init(caption="IcyPlat - ein einfacher Plattformer", resizable=True) showMainMenu()

Schritt 7. Testen Sie Ihren Code

Testen Sie den Code frühzeitig, solange er noch kurz und relativ einfach ist. So können Sie eventuelle Fehler in der Grundstruktur erkennen und korrigieren, bevor es zu kompliziert wird.

Der Code aus der Anleitung sollte ein Fenster mit der Überschrift "IcyPlat - ein einfacher Plattformer" öffnen. Der Hintergrund ist hellblau und Sie können die Größe des Fensters ändern. Wenn Sie im Menü auf "Spiel starten" klicken, sollte (noch) nichts passieren. Wenn Sie auf "Beenden" klicken, wird das Fenster geschlossen

Schritt 8. Erstellen Sie ein Sprite

Ein Sprite ist ein "Spielobjekt" oder ein zweidimensionales Bild. Sprites können In-Game-Objekte, Symbole, Hintergrunddekorationen, Charaktere und alles andere sein, was Sie mit einem Bild im Spiel darstellen können. Wir beginnen damit, ein Sprite für einen Charakter zu erstellen, mit dem der Spieler interagieren kann.

Importieren Sie das Untermodul cocos.sprite mit dem from-import-expression.
Suchen Sie ein Bild, um das Sprite darzustellen. Sie können ein Sprite nicht anzeigen, wenn Sie kein Bild dafür haben. Sie können eins zeichnen oder aus dem Internet beziehen (achten Sie jedoch auf die Lizenzen, wenn Sie planen, Ihr Spiel zu veröffentlichen). Gehen Sie für dieses Beispiel zu https://opengameart.org/content/tux-classic-hero-style und speichern Sie das PNG-Bild der laufenden Pinguine auf Ihrem Computer. Schneiden Sie dann einen der laufenden Pinguine aus, da Sie im Moment nur einen brauchen.
Erstellen Sie eine Ebene als neues Objekt der ScrollableLayer-Klasse. Erstellen Sie dann das Sprite als Sprite-Objekt und legen Sie seine Position auf (8, 250) fest. Als Referenz befindet sich der Punkt (0, 0) in der unteren linken Ecke. Das ist ziemlich hoch, aber es stellt sicher, dass der Pinguin nicht im Eis stecken bleibt.
Füge das Sprite zur Ebene des Sprites hinzu.
Erstellen Sie eine neue Szene aus der Ebene des Sprites und führen Sie sie aus.

def startGame(): figLayer = ScrollableLayer() fig = Sprite('pingu.png') fig.position = (75, 100) figLayer.add(fig) # gameSc = Scene(figLayer) Director.run(gameSc)

Führen Sie den Code aus. Sie sollten eine kleine Pinguinfigur (oder was auch immer Sie gezeichnet haben) auf schwarzem Hintergrund sehen, nachdem Sie geklickt haben Spiel starten.

Schritt 9. Träumen Sie Ihre Landschaft

In den meisten Spielen sollten Ihre Sprites nicht einfach im Nichts schweben. Sie sollten eigentlich auf einer Oberfläche stehen, mit etwas um sie herum. In 2D-Spielen geschieht dies oft mit einem Kachelset und einer Kachelkarte. Das Kachelset sagt im Grunde, welche Art von Oberflächenquadraten und Hintergrundquadraten existieren und wie sie aussehen.

Erstellen Sie einen Kachelsatz. Das Spielsteinset für dieses Spiel ist sehr einfach: ein Spielstein für Eis und ein Spielstein für Himmel. Die in diesem Beispiel verwendete Eiskachel stammt von hier, unter CC-BY-SA 3.0.
Erstellen Sie ein Kachelset-Bild. Das ist ein Bild aller Kacheln, die alle die gleiche Größe haben müssen (bearbeiten Sie sie, wenn sie es nicht sind) und die Größe haben, die Sie im Spiel sehen möchten, nebeneinander. Speichern Sie Ihr Bild als icyTiles.png.
Erstellen Sie die Kachelsatzbeschreibung. Das ist eine XML-Datei. Die XML-Datei enthält Informationen darüber, wie groß die Kacheln im Kachelsatzbild sind, welches Bild verwendet werden soll und wo welche Kachel dort zu finden ist. Erstellen Sie eine XML-Datei namens icyTiles.xml mit dem folgenden Code:
```
     
```

Schritt 10. Erstellen Sie eine Kachelkarte für Ihre Landschaft

Eine Kachelkarte ist eine Karte, die definiert, welche Kachel sich an welcher Position in Ihrem Level befindet. Im Beispiel sollten Sie eine Funktion zum Generieren von Kachelkarten definieren, da das Entwerfen von Kachelkarten von Hand sehr mühsam ist. Ein fortgeschritteneres Spiel verfügt normalerweise über eine Art Level-Editor, aber um sich mit der 2D-Spielentwicklung vertraut zu machen, kann ein Algorithmus ausreichend gute Level bereitstellen.

Finden Sie heraus, wie viele Zeilen und Spalten benötigt werden. Teilen Sie dazu die Bildschirmgröße sowohl horizontal (Spalten) als auch vertikal (Zeilen) durch die Kachelgröße. Runden Sie die Zahl nach oben; Sie benötigen dafür eine Funktion des Math-Moduls, also fügen Sie von Math Import Ceil zu den Importen oben in Ihrem Code hinzu.
Öffnen Sie eine Datei zum Schreiben. Dadurch wird der gesamte vorherige Inhalt der Datei gelöscht. Wählen Sie also einen Namen, den noch keine Datei im Verzeichnis hat, wie zum Beispiel levelMap.xml.
Schreiben Sie die öffnenden Tags in die Datei.
Generieren Sie eine Kachelkarte gemäß dem Algorithmus. Sie verwenden den Code im folgenden Code oder können selbst einen erstellen. Stellen Sie sicher, dass Sie die randint-Funktion aus dem Modul random importieren: Sie ist erforderlich, damit der folgende Code funktioniert, und was auch immer Sie sich einfallen lassen, benötigt wahrscheinlich auch zufällige Ganzzahlen. Stellen Sie außerdem sicher, dass Sie Himmels- und Eiskacheln in verschiedenen Schichten platzieren: Eis ist fest, Himmel nicht.
Schreiben Sie die schließenden Tags in die Datei und schließen Sie die Datei.

def generateTilemap(): colAmount = ceil(800 / 16)*3 # (Bildschirmbreite / Kachelgröße) * 3 rowAmount = ceil(600 / 16) # Bildschirmhöhe / Kachelgröße tileFile = open("levelMap.xml", " w") tileFile.write('\n\n\n') iceHeight = randint(1, 10) für i in range(0, colAmount): tileFile.write('') makeHole = False if randint(0, 50) == 10 und i != 0: # Löcher am Spawnpunkt nicht zulassen makeHole = True für j in range(0, rowAmount): if makeHole: tileFile.write('\n') else: if j <= iceHeight: tileFile.write('\n') else: tileFile.write('\n') iceHeight = randint(iceHeight-5, iceHeight+5) if iceHeight < 0: # Begrenzung der Kacheln davor, zu niedrig zu werden iceHeight = randint(1, 5) if iceHeight > rowAmount: # Begrenzung der Kacheln davor, zu hoch zu werden iceHeight = randint(int(rowAmount/2)-5, int(rowAmount/2)+5) tileFile.write('\n') tileFile.write ('\n\n') für i im Bereich(0, colAmount): tileFile.write('') für j im Bereich(0, rowAmount): tileFile.write('\n') tileFile.write('\ n') tileFile.write('\n\n') tileFile.close()

Schritt 11. Zeigen Sie die Kachelkarte an

Importiere alles von cocos.tiles und gehe dann in die startGame-Funktion dafür.

Generieren Sie zu Beginn Ihrer startGame-Funktion eine Kachelkarte mit der dafür definierten Funktion.
Erstellen Sie einen neuen Scroll-Manager. Tun Sie dies direkt unter der Zeile, in der Sie das Sprite zu seiner Ebene hinzufügen.
Erstellen Sie einen neuen Layer mit den Kacheln, der aus der Kachel-Map levelMap.xml geladen wird, die von der Funktion "generateTilemap" generiert wurde.
Fügen Sie die nicht-feste Ebene, die feste Ebene und die Sprite-Ebene genau in dieser Reihenfolge zum Scroll-Manager hinzu. Sie können eine Z-Position hinzufügen, wenn Sie möchten.
Anstatt die Szene aus der Sprite-Ebene zu erstellen, erstellen Sie sie aus dem Scroll-Manager.

Ihre startGame-Funktion sollte nun so aussehen:

def startGame(): generateTilemap() # fig = Sprite('pingu.png') fig.position = (8, 500) figLayer = ScrollableLayer() figLayer.add(fig) # tileLayer = load('levelMap.xml') solidTiles = tileLayer['solid'] nsoliTiles = tileLayer['not_solid'] # scrMang = ScrollingManager() scrMang.add(nsoliTiles, z=-1) scrMang.add(solidTiles, z=0) scrMang.add(figLayer, z =1) #gameSc = Scene(scrMang) Director.run(gameSc)

Schritt 12. Testen Sie Ihren Code

Sie sollten Ihren Code häufig testen, um sicherzustellen, dass die neuen Funktionen, die Sie implementiert haben, auch wirklich funktionieren.

Der Code im Beispiel sollte nun eine eisige Landschaft hinter dem Pinguin zeigen. Wenn der Pinguin so aussieht, als würde er weit über dem Eis schweben, haben Sie nichts falsch gemacht und es wird im nächsten Schritt behoben

Schritt 13. Fügen Sie die Steuerelemente hinzu

Der Spieler hat in einem 2D-Spiel viel mehr Möglichkeiten, mit dem Programm zu interagieren als in einem textbasierten Spiel. Eine übliche Methode beinhaltet das Verschieben ihrer Figur, wenn die richtige Taste gedrückt wird.

Importieren Sie alles aus cocos.mapcolliders und aus cocos.actions. Importieren Sie auch den Schlüssel aus pyglet.window.
"Deklarieren" Sie einige globale Variablen. Globale Variablen werden von Funktionen gemeinsam genutzt. Sie können in Python keine Variablen deklarieren, aber Sie müssen sagen, dass eine globale Variable im Hauptcode vorhanden ist, bevor Sie sie verwenden. Sie können als Wert 0 zuweisen, da eine Funktion später den richtigen Wert zuweist. Fügen Sie also unter den Importausdrücken hinzu:
```
# Globale Variablen "deklarieren" keyboard = 0 scrMang = 0
```

Passen Sie Ihre startGame-Funktion an:

Angenommen, Sie verwenden die globalen Variablen keyboard und scrMang. Dazu schreiben Sie globale Tastatur, scrMang oben in die Funktion.
Lassen Sie das Fenster auf Tastaturereignisse hören.
Weisen Sie die Figur an, basierend auf einem PlatformerController zu handeln. Sie werden diesen PlatformerController bald implementieren.
Erstellen Sie einen Kartencollider, um Kollisionen zwischen den festen Kacheln und der Figur zu behandeln.

def startGame(): globale Tastatur, scrManggenereTilemap() # fig = Sprite('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer() figLayer.add(fig) # tileLayer = load('levelMap.xml') solidTiles = tileLayer['solid'] nsoliTiles = tileLayer['not_solid'] # keyboard = key. KeyStateHandler() Director.window.push_handlers(keyboard) # fig.do(PlatformerController()) mapcollider = RectMapCollider(velocity_on_bump ='slide') fig.collision_handler = make_collision_handler(mapcollider, solidTiles) # scrMang = ScrollingManager() scrMang.add(nsoliTiles, z=-1) scrMang.add(solidTiles, z=0) scrMang.add(figLayer, z= 1) #gameSc = Scene(scrMang) Director.run(gameSc)

Erstellen Sie einen Platformer-Controller. Dies ist, was die Figur entsprechend Ihren Tastendrücken bewegt.
- Definieren Sie den Platformer-Controller als Unterklasse von Action.
- Definieren Sie die Bewegungsgeschwindigkeit, die Sprunggeschwindigkeit und die Schwerkraft.
- Definieren Sie die Startfunktion. Diese Funktion wird einmal aufgerufen, wenn der Platformer-Controller mit der Figur verbunden ist. Er sollte seine Geschwindigkeit sowohl in x- als auch in y-Richtung auf 0 setzen.
- Definieren Sie die Schrittfunktion. Es wird wiederholt, während die Szene läuft.
- Weisen Sie die step-Funktion an, die globalen Variablen keyboard und scrMang zu verwenden.
- Rufen Sie die Geschwindigkeit ab und ändern Sie sie. Speichern Sie die x- und die y-Geschwindigkeit in separaten Variablen. Setzen Sie die x-Geschwindigkeit entweder auf 1 oder -1 (je nachdem, ob die linke oder rechte Taste gedrückt wurde) multipliziert mit der Bewegungsgeschwindigkeit. Addieren Sie die Schwerkraft zur y-Geschwindigkeit. Multiplizieren Sie es mit der Ausfallzeit, damit es auf langsameren Geräten genauso funktioniert. Wenn die Leertaste gedrückt wird und die Figur auf dem Boden steht, springen Sie, indem Sie die y-Geschwindigkeit auf die Sprunggeschwindigkeit ändern.
- Berechnen Sie, wohin sich die Figur bewegen soll. Lassen Sie dann den Kollisionshandler diese Position anpassen, wenn sie sich innerhalb einer festen Kachel befindet. Verschieben Sie abschließend die Figur an die neue angepasste Position.
- Setzen Sie den Fokus des Scroll-Managers auf die Figur. Dies bewirkt, dass sich die Kamera in einer vernünftigen Weise bewegt, wenn sich die Figur bewegt.
```
Klasse PlatformerController(Action): globale Tastatur, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start(self): self.target.velocity = (0, 0) def step(self, dt): globale Tastatur, scroller if dt > 0.1: # tue nichts während der Downtime to big return vx, vy = self.target.velocity vx = (keyboard[key. RIGHT] - keyboard[key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on_ground and keyboard[key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect() new = last.copy() new.x += dx new.y += dy self.target.velocity = self.target.collision_handler(last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus(*new.center)
```

Schritt 14. Testen Sie Ihren Code

Wenn Sie dem Beispiel gefolgt sind, sollten Sie den Pinguin nun mit den Pfeiltasten bewegen und mit der Leertaste springen können. Außerdem sollte der Pinguin jetzt herunterfallen, anstatt über dem Boden zu schweben.

Schritt 15. Erstellen Sie ein Ende für das Spiel

Sogar Spiele, die endlos weitergehen können, sollten die Möglichkeit haben, zu verlieren. Da das Level, das Sie im Beispiel mit einer Funktion erstellt haben, ein Ende hat, müssen Sie es auch ermöglichen, zu gewinnen, indem Sie dieses Ende erreichen. Sonst würde der Spieler dort nur auf den Eisblöcken herumspringen, was langweilig werden würde.

Rufen Sie im Platformer-Controller nach dem Fokussatz die x- und y-Position der Figur ab. Wenn die y-Position kleiner als 0 ist, rufen Sie die Funktion finishGame() (Sie werden sie später schreiben) mit "Game Over" als Argument auf. Wenn die x-Position größer als die Bildschirmgröße multipliziert mit 3 ist (das hatten Sie zuvor als Levelgröße eingestellt).
```
posX, posY = self.target.position if posY < 0: finishGame("Game Over") return if posX > 800*3: # Levelgröße finishGame("Level Completed") return
```
Definieren Sie eine Klasse finishMenu. Es sollte wie die von Ihnen zuvor definierte Hauptmenüklasse sein, aber anstelle eines leeren Strings als Titel sollte ein variabler Text verwendet werden, den die Funktion _init_ als Argument verwendet. Die Menüpunkte sollten jetzt mit "Erneut versuchen" und "Beenden" beschriftet sein, aber die Funktionen, die sie aufrufen, bleiben gleich.
```
Klasse FinishMenu(Menu): def _init_(self, text): super(FinishMenu, self)._init_(text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Try again", startGame)), (MenuItem("Beenden", pyglet.app.exit))] self.create_menu(menuItems)
```
Definieren Sie die Funktion finishGame(). Es sollte Text als Argument annehmen. Es sollte eine Szene aus dem Hauptmenühintergrund machen, ein FinishMenu mit dem Textargument, das an dieses Menü übergeben wird. Dann sollte diese Szene ausgeführt werden.
```
def finishGame(text): menuSc = Scene(MainMenuBgr()) menuSc.add(FinishMenu(text)) Director.run(menuSc)
```

Schritt 16. Guthaben hinzufügen

Hier erhalten Sie Anerkennung für Ihren großartigen Code sowie für alle anderen, die Ihnen auf diesem Weg geholfen haben. Wenn Sie ein Bild von einer anderen Website (mit Genehmigung) verwendet haben, weisen Sie dieses Bild unbedingt seinem Ersteller zu.

Erstellen Sie eine Datei CREDITS und geben Sie dort alle Ihre Credits ein, wie folgt:

Pinguin: Kelvin Shadewing, unter CC0 Eisblock: Michał Banas digit1024 auf opengameart.org unter CC-BY-SA 3.0

Gehen Sie zurück zu Ihrem Python-Code und importieren Sie Label aus cocos.text.

Definieren Sie eine Unterklasse Credits of Layer. Lesen Sie in der Funktion _init_ die CREDITS-Datei und machen Sie aus jeder Zeile darin eine Textbeschriftung an der richtigen Position.

class Credits(Layer): def _init_(self): super(Credits, self)._init_() credFile = open("CREDITS", "r") creds = credFile.read() creds = creds.split("\n ") für i in range(0, len(creds)): credLabel = Label(creds, font_size=32,anker_x="left", Anker_y="top") credLabel.position = 25, 500-(i +1)*40 self.add(credLabel)

Gehen Sie zu Ihrer Hauptmenüklasse und fügen Sie einen Menüpunkt mit der Bezeichnung "Credits" hinzu, der beim Anklicken die Funktion showCredits aufruft.
Definieren Sie eine Unterklasse BackToMainMenuButton von Menu. Machen Sie dies zu einem Menü mit einem Element mit der Bezeichnung "Zurück", das die Funktion showMainMenu aufruft. Dieses "Menü", das eher einer Schaltfläche gleicht, sollte vertikal nach unten und horizontal nach oben ausgerichtet sein.
```
class BackToMainMenuButton(Menu): def _init_(self): super(BackToMainMenuButton, self)._init_("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem("Back", showMainMenu))] self. create_menu(menuItems)
```
Definieren Sie die Funktion showCredits. Es sollte eine Szene aus einem MainMenuBgr-Layer und einem Credits-Layer machen und diese Szene ausführen.
```
def showCredits(): credSc = Scene(MainMenuBgr()) credSc.add(Credits()) credSc.add(BackToMainMenuButton()) Director.run(credSc)
```

Schritt 17. Überprüfen Sie Ihren Code

Wenn Sie denken, dass Sie Ihren Code fertig gestellt haben, sollten Sie ihn noch einmal durchsehen. Auf diese Weise können Sie feststellen, ob etwas optimiert werden kann oder ob Sie unnötige Zeilen vergessen haben, zu löschen. Wenn Sie dem Beispiel gefolgt sind, sollte Ihr gesamter Code jetzt wie folgt aussehen:

aus cocos.director importieren * aus cocos.menu importieren * aus cocos.scene importieren * aus cocos.layer importieren * aus cocos.sprite importieren * aus cocos.tiles importieren * aus cocos.mapcolliders importieren * aus cocos.actions importieren * aus cocos.text import Label import pyglet.app from pyglet.window import key from math import ceil from random import randint # "deklarieren" globale Variablen keyboard = 0 scrMang = 0 class MainMenuBgr(ColorLayer): def _init_(self): super(MainMenuBgr, self)._init_(0, 200, 255, 255) class MainMenu(Menu): def _init_(self): super(MainMenu, self)._init_("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Start Game", startGame)), (MenuItem("Credits", showCredits)), (MenuItem("Quit", pyglet.app.exit))] self.create_menu(menuItems) class Credits(Layer): def _init_(self): super(Credits, self)._init_() credFile = open("CREDITS", "r") creds = credFile.read() creds = creds.split("\n") for i in range (0, len(creds)): credLabel = Label(creds, font_size=32, Anchor_x="left", Anchor_y="top") credLabel.position = 25, 500-(i+1)*40 self.add(credLabel) class BackToMainMenuButton(Menu): def _init_(self): super (BackToMainMenuButton, self)._init_("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem("Back", showMainMenu))] self.create_menu(menuItems) class FinishMenu(Menu): def _init_(self, text): super(FinishMenu, self)._init_(text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Erneut versuchen", startGame)), (MenuItem("Quit", pyglet. app.exit))] self.create_menu(menuItems) Klasse PlatformerController(Action): globale Tastatur, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start(self): self.target.velocity = (0, 0) def step(self, dt): globale Tastatur, Scroller wenn dt > 0.1: # nichts tun während der Ausfallzeit zu groß return vx, vy = self.target.velocity vx = (keyboard[key. RIGHT] - keyboard [Taste. LINKS]) * self. MOVE_SPEED vy += self. GRAVITY * dt wenn self.on _ground und keyboard[key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect() new = last.copy() new.x += dx new.y + = dy self.target.velocity = self.target.collision_handler(last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus(* new.center) posX, posY = self.target.position if posY < 0: finishGame("Game Over") return if posX > 800*3: # Levelgröße finishGame("Level Completed") return def finishGame(text): menuSc = Scene(MainMenuBgr()) menuSc.add(FinishMenu(text))director.run(menuSc) def showCredits(): credSc = Scene(MainMenuBgr()) credSc.add(Credits()) credSc.add(BackToMainMenuButton())director.run(credSc) def generateTilemap(): colAmount = ceil(800 / 16)*3 # (Bildschirmbreite / Kachelgröße) * 3 rowAmount = ceil(600 / 16) # Bildschirmhöhe / Kachelgröße tileFile = open ("levelMap.xml", "w") tileFile.write('\n\n\n') iceHeight = randint(1, 10) für i im Bereich(0, colAmount): tileFile.write('') makeHole = Falsch, wenn rand int(0, 50) == 10 und i != 0: # Löcher am Spawnpunkt nicht zulassen makeHole = True für j in range(0, rowAmount): if makeHole: tileFile.write('\n') else: if j <= iceHeight: tileFile.write('\n') else: tileFile.write('\n') iceHeight = randint(iceHeight-5, iceHeight+5) if iceHeight < 0: # Beschränke, dass die Kacheln mitgehen low iceHeight = randint(1, 5) if iceHeight > rowAmount: # Begrenzung der Kacheln davor, zu hoch zu werden iceHeight = randint(int(rowAmount/2)-5, int(rowAmount/2)+5) tileFile.write('\n ') tileFile.write('\n\n') für i im Bereich(0, colAmount): tileFile.write('') für j im Bereich(0, rowAmount): tileFile.write('\n') tileFile.write('\n') tileFile.write('\n\n') tileFile.close() def startGame(): globale Tastatur, scrManggeneriereTilemap() # fig = Sprite('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer() figLayer.add(fig) # tileLayer = load('levelMap.xml') solidTiles = tileLayer['solid'] nsoliTiles = tileLayer['not_solid'] # keyboard = key. KeyStateHandler ()director.window.push_handlers(keybo ard) # fig.do(PlatformerController()) mapcollider = RectMapCollider(velocity_on_bump='slide') fig.collision_handler = make_collision_handler(mapcollider, solidTiles) # scrMang = ScrollingManager() scrMang.add(nsoliTilesMang.-1) scr add(solidTiles, z=0) scrMang.add(figLayer, z=1) # gameSc = Scene(scrMang) Director.run(gameSc) def showMainMenu(): menuSc = Scene(MainMenuBgr()) menuSc.add(MainMenu())director.run(menuSc) window =director.init(caption="IcyPlat - ein einfacher Plattformer", resizable=True) showMainMenu()

Das sind insgesamt 168 Zeilen und 152 Zeilen, wenn Sie nur den Code zählen. Das scheint viel zu sein, aber für ein so komplexes Spiel ist dies tatsächlich eine kleine Menge.

Schritt 18. Fertig

Teste nun das Spiel. Wenn Sie etwas programmieren, müssen Sie immer dann überprüfen, ob es funktioniert, wenn Sie etwas Neues implementiert haben. Vielleicht möchten Sie auch das Spiel, das Sie geschrieben haben, einige Zeit spielen.

Teil 3 von 3: Ein Spiel veröffentlichen

Schritt 1. Notieren Sie die Abhängigkeiten

Jeder, der einen anderen Computer verwendet, hat nicht die gleiche Software und Bibliotheken installiert wie Sie. Sie müssen also sicherstellen, dass jeder, der Ihr Spiel installiert, genau weiß, was er zum Ausführen benötigt. Sie müssen nicht alle Abhängigkeiten aller Abhängigkeiten aller Abhängigkeiten usw. aufschreiben, aber Sie sollten zumindest die Abhängigkeiten Ihrer Pakete und deren Abhängigkeiten schreiben.

Schritt 2. Stellen Sie sicher, dass Sie berechtigt sind, alle Medien zu verwenden

Dies gilt für alle Grafiken, einschließlich 3D-Modelle, Musik, Dialoge, Musik, Bibliotheken und Frameworks, die Sie für Ihr Spiel verwendet haben. Alles, was Sie nicht selbst geschrieben haben.

Oftmals gibt es einige Bedingungen, wie die Nennung des Autors oder die Freigabe von Änderungen der Medien unter derselben Lizenz. Manchmal können Sie Grafiken verwenden, ohne die Ersteller zu nennen, solange Sie das Spiel nicht in Rechnung stellen. Wenn Sie den Autor erwähnen müssen, tun Sie dies an einer gut sichtbaren Stelle, z. B. auf einem "Credits"-Reiter in Ihrem Spiel.
Es gibt auch Medien, bei denen das Urheberrecht beansprucht wird und keine Lizenz angegeben ist, manchmal mit einem Text wie "Alle Rechte vorbehalten". Wenn dies der Fall ist, müssen Sie die ausdrückliche Erlaubnis des Autors einholen, bevor Sie es in Ihr Spiel aufnehmen.
Bibliotheken werden in der Regel unter Lizenzen veröffentlicht, die es ihnen ermöglichen, als Bibliothek verwendet zu werden. Eine bemerkenswerte Ausnahme ist die GPL ohne Verknüpfungsausnahme: Eine solche Lizenz erlaubt nur die Verwendung in einem Programm mit bestimmten Lizenzen. Und Sie sollten immer zumindest die grundlegenden Punkte der Lizenz lesen, um sicherzustellen, dass alles, was Sie mit den Medien oder der Bibliothek tun, erlaubt ist.

Warnung: Wenn Sie Medien oder Bibliotheken in einem von Ihnen veröffentlichten Spiel auf eine Weise verwenden, die die Lizenz nicht zulässt, können Sie in ernsthafte rechtliche Schwierigkeiten geraten. Fragen Sie also entweder den Autor oder vermeiden Sie das Medium ganz, wenn Sie sich nicht sicher sind, ob Ihre Verwendung erlaubt ist.

Schritt 3. Legen Sie fest, unter welchen Bedingungen Sie Ihr Spiel veröffentlichen möchten

Wirst du dein Spiel verkaufen? Möchten Sie anderen erlauben, Ihre Bilder und Ideen zu verwenden? Während Sie bei den Medien, die Sie in Ihrem Projekt verwenden, vorsichtig sein müssen, können Sie normalerweise entscheiden, wie Sie anderen die Nutzung Ihres Spiels ermöglichen möchten. Sie können eine Creative Commons CC0-Lizenz verwenden, um Ihr Spiel gemeinfrei zu veröffentlichen. Um die Verbreitung und Modifikation unter bestimmten Bedingungen zuzulassen und gleichzeitig einige Rechte zu behalten, versuchen Sie es mit der Gnu General Public License (GPL) oder der Berkeley Software Distribution (BSD)-Lizenz. Oder Sie könnten Ihre Software proprietär machen, was bedeutet, dass niemand sie ohne Ihre Erlaubnis verbreiten oder ändern darf.

Obwohl es möglich ist, mit dem Verkauf von Spielen Geld zu verdienen, ist es unwahrscheinlich, dass die Leute Ihr erstes Spiel kaufen, das normalerweise nur wenige Funktionen und nichts Besonderes hat. Auch wenn ein kostenloses Programm nicht funktioniert, werden die Leute, die es heruntergeladen haben, einfach enttäuscht sein. Wenn sie jedoch dafür bezahlt haben, fordern sie ihr Geld zurück, was sowohl für Sie als auch für die Benutzer weitere Probleme verursacht. Erwägen Sie also, Ihre ersten Programme kostenlos zur Verfügung zu stellen

Schritt 4. Entscheiden Sie, wie Sie Ihr Spiel veröffentlichen möchten

Jede Methode hat einige Vor- und Nachteile, sodass Sie selbst entscheiden müssen.

Veröffentlichung auf einer Website:

Wenn Sie eine Website haben, können Sie Ihr Spiel hochladen, um es zum Download zur Verfügung zu stellen. Stellen Sie sicher, dass Sie klare Anweisungen zur Installation der Software sowie zu allen erforderlichen Abhängigkeiten bereitstellen. Der Nachteil dabei ist, dass die Spieler Abhängigkeiten manuell installieren müssen, was für manche Leute schwierig sein könnte.
Erstellen eines Pakets für einen Paketmanager:

Es gibt verschiedene Paketmanager wie apt, Yum und Homebrew, die es Benutzern leicht machen, Apps in Linux- und Linux-basierten Umgebungen zu installieren. Sie alle haben unterschiedliche Paketformate. Das Gute an Paketen ist, dass sie automatisch alle Abhängigkeiten installieren (wenn Sie sie richtig konfigurieren). Der Spieler muss also nur Ihr Paket installieren und kann dann das Spiel spielen. Das Problem ist, dass es viele verschiedene Paketmanager auf verschiedenen Plattformen gibt, so dass Sie etwas Arbeit in die Bereitstellung von Paketen für die gängigsten investieren müssen.

Schritt 5. Lenken Sie die Aufmerksamkeit auf Ihr Programm

Erwägen Sie, Ihr Programm in ein großes Paket-Repository hochzuladen, wie es Ubuntu und Debian pflegen, um eine einfache Installation zu ermöglichen. Posten Sie auch in entsprechenden Foren, wie dem Projektbereich von GameDev oder einem Teil von tigSource. Aber seien Sie nicht enttäuscht, wenn Ihre ersten Spiele nicht berühmt werden. Wenn Sie eine Idee haben, die vielen Leuten gefällt, kann Ihr Spiel bekannt werden.

Tipps

Seien Sie geduldig und lernbereit. Programmieren kann manchmal frustrierend sein!
Wenn Sie sich fragen, wie etwas in einem anderen Spiel gemacht wird und das Spiel Open Source ist, können Sie sich den Quellcode ansehen.
Versuchen Sie bei der Suche nach Medien, Inhalte zu finden, die gemeinfrei sind. Suchen Sie nach Bildern und Musik von „Creative Commons“oder „Public Domain“und verwenden Sie Websites wie https://opengameart.org oder
Kopieren Sie keine größeren Codestücke, ohne die Lizenz zu überprüfen. Es ist oft verboten, und wenn nicht, ist in der Regel eine Namensnennung erforderlich.
Machen Sie keinen Spam oder posten Sie an unangemessenen Orten, wenn Sie für Ihr Spiel werben. Dies führt wahrscheinlich dazu, dass Sie von der Seite gesperrt werden, ist einfach ärgerlich und schadet Ihrem Ruf.