Spiele programmieren lernen

Aus Spieleprogrammierer-Wiki
Wechseln zu: Navigation, Suche

Dieser Artikel soll dir dabei helfen einen ersten Überblick darüber zu gewinnen, was auf dich zukommt, wenn du Spiele programmieren lernen möchtest. Er richtet sich speziell an Anfänger, die noch keine Erfahrung mit der Programmierung haben. Bitte lies diesen Artikel sehr sorgfältig durch, und nimm die Tipps und Empfehlungen ernst. Sie sind nicht einfach aus der Luft gegriffen, sondern basieren auf langjähriger Erfahrung.

Inhaltsverzeichnis

Werbeanzeige

Was braucht es, um Spieleprogrammierer zu werden?

Du hast dir also ein Ziel gesetzt: Du möchtest eigene Spiele programmieren. Eines sollte dir von Anfang an klar sein: Der Weg bis zum ersten eigenen Spiel ist kein leichter. Zunächst einmal solltest du in der Lage sein, dir fremde Themenbereiche selbstständig zu erarbeiten. Du wirst sehr viel lesen müssen und nicht immer jemanden haben, der dir sagt, was du als nächstes tun sollst. Auch um englischsprachige Texte kommst du ab einem gewissen Punkt nicht mehr herum, also solltest du diese Sprache so gut beherrschen, dass du technische Anleitungen/Handbücher lesen kannst. Wenn du noch nie programmiert hast, wird der Anfang schwierig werden. Darum ist es wichtig, dass du nicht aufgibst, auch wenn es nur in kleinen Schritten voran geht.

Alle, die heute ihre eigenen Spiele programmieren, haben alle einmal an dem Punkt angefangen, an dem du nun stehst. Jedoch hast du das große Glück, dass ein schneller und günstiger Internetzugang heute eine Selbstverständlichkeit ist. Dir steht mit dem Internet eine enorme Informationssammlung zur Verfügung, die dir auf fast jede nur denkbare Frage eine Antwort liefern kann. So zum Beispiel auch dieses Wiki. Natürlich kann es nicht alle Fragen beantworten und für alle Probleme eine Lösung parat haben. Aus diesem Grund solltest du wissen, wie man eine Suchmaschine richtig benutzt, um gezielt nach Informationen zu suchen. Die meisten Fragen lassen sich durch Suchen beantworten – man muss nur wissen, wonach man suchen muss.

Als Programmierer und insbesondere als Spieleprogrammierer sollte man mit der Mathematik nicht auf dem Kriegsfuß stehen. (3D-)Grafik, Physiksimulation und künstliche Intelligenz beinhalten fast ausschließlich rein mathematische (oft geometrische) Fragestellungen, und auch außerhalb dieser Themengebiete wirst du immer wieder einfachere Formeln aufstellen und berechnen müssen. Logisches Denken und Abstraktion sind weitere Fähigkeiten, die dir bei der Spieleprogrammierung sehr nützlich sein werden. Oft musst du ein großes Problem in kleinere Teilprobleme zerlegen, die für sich genommen einfacher zu lösen sind. Viele Probleme sind auf den ersten Blick unterschiedlich, aber wenn du sie genauer betrachtest, erkennst du vielleicht eine Ähnlichkeit zu einem anderen Problem, dessen Lösung du bereits kennst. Aber keine Sorge: solche Dinge lernst du mit der Zeit, wenn du genügend Erfahrung gesammelt hast.

Der nächste wichtige Punkt bei der Entwicklung eigener Spiele ist natürlich Kreativität. Niemand möchte den eintausendsten Tetris-Klon spielen. Hier hilft es, wenn du selbst möglichst viele verschiedene Arten von Spielen spielst (das heißt: nicht nur Ego-Shooter!). Du solltest dabei mit der Zeit ein Gefühl dafür entwickeln, welche Elemente eines Spiels dazu beitragen, dass es Spaß macht. Wenn du solche Elemente in einer noch nicht zu oft gesehenen Art und Weise kombinierst und deinem Spiel etwas Persönliches gibst, was es von allen anderen Spielen abhebt und es einzigartig macht, dann hast du das Ziel erreicht. Nun bist du als Programmierer vielleicht nicht begabt im Zeichnen oder Musizieren, und trotzdem benötigt dein Spiel Grafiken, Soundeffekte und Musik. Hier bietet sich die Zusammenarbeit mit Grafikern und Musikern an, womit wir gleich beim nächsten Punkt angelangt wären: Teamfähigkeit. Insbesondere bei größeren Projekten, wo auch die Programmierung von mehr als nur einer Person umgesetzt wird, muss das Team gut funktionieren, damit am Ende des Tages ein gutes Spiel produziert werden kann (aber um daran zu denken ist es noch zu früh).

Wir hoffen, dass dich diese Einführung nicht zu sehr entmutigt hat und du immer noch deine eigenen Spiele programmieren möchtest. Also, weiter geht's!

Was ist ein realistisches Ziel?

Screenshot des Flash-Spiels "Space is Key" bei Armor Games, das nur mit der Leertaste gesteuert wird.

Unsere eigenen Erfahrungen und auch zahlreiche Diskussionen im Forum haben uns gelehrt, dass Anfänger vor allem einen Fehler begehen: nämlich sich unrealistische Ziele zu setzen. Erstens in Bezug auf die Zeit, die man benötigt, um so viel zu lernen, dass man ein eigenes Spiel auf die Beine stellen kann. Zweitens in Bezug auf die Qualität und den Umfang der Spiele, die man erwartet programmieren zu können. Dann mit der Realität konfrontiert zu werden ist mit Frustration verbunden, die dazu führen kann, dass man völlig aufgibt. Darum möchten wir dich so früh wie möglich davor warnen. Bitte nimm diese Empfehlungen ernst.

Du hast vielleicht schon eine konkrete Idee für dein Spiel. Erfahrungsgemäß ist diese erste Idee sehr aufwändig umzusetzen und übersteigt die Fähigkeiten eines Anfängers bei weitem. Typische Ideen für erste Spiele, die mit an Sicherheit grenzender Wahrscheinlichkeit fehlschlagen, beinhalten atemberaubende 3D-Grafik, riesige dynamische Welten oder (Massively) Multiplayer. Wenn deine Idee auch in diese Kategorie fällt oder du Spiele programmieren möchtest, die mit einem aktuellen Topseller-Titel vergleichbar sind, dann vergiss die Idee für die ersten Jahre. Wirklich. Solche Spiele werden von großen Teams professioneller Spieleentwickler umgesetzt, die jahrelange Erfahrung mitbringen und jeden Tag mindestens 8 Stunden mit der Entwicklung verbringen. Trotz eines großen Teams beanspruchen Spiele wie "World of Warcraft", "Half-Life 2" oder "GTA" etwa fünf Jahre Entwicklungszeit. Selbst Projekte mit kleineren Budgets sind oft zwei bis drei Jahre in Entwicklung. Umgerechnet auf einen einzigen unerfahrenen Entwickler würde dieser sein ganzes Leben an einem solchen Spiel programmieren. Und wer wird in 60 Jahren noch ein Spiel spielen, das für einen Computer aus der heutigen Zeit geschrieben wurde?

Also, einen Schritt zurück: Ein gutes Spiel muss gar nicht so aufwändig sein wie die zuvor genannten Spiele. Hast du nicht schon einmal Stunden mit kurzweiligen Flash-Spielen verbracht? Das Gute daran ist: Solche Spiele programmieren normalerweise nur sehr kleine Teams, vielleicht sogar nur ein einzelner Entwickler, und oft nur in der Freizeit. Was du dir also als erstes Zwischenziel vornehmen solltest, ist ein sehr einfach gehaltenes kleines Spiel zu programmieren, das vor allem Spaß macht. Der Spaß am Spiel ist das Wichtigste, nicht die Grafik. Wenn du dich als einzelner Entwickler mit den großen Spielestudios messen willst, wirst du immer verlieren. Also setze dir ein Ziel, das du auch erreichen kannst. Natürlich ist es jetzt schwer für dich zu beurteilen, was realistisch ist. Darum solltest du dir anschauen, wie die ersten Spielprojekte anderer Mitstreiter aussahen. Eine Suche nach "my first game" mit der Suchmaschine deiner Wahl sollte dir genügend Beispiele liefern, an denen du dich orientieren kannst. Eine weitere Möglichkeit für realistische Ziele sind Spiele, die bei Contests ("Programmierwettbewerben") mit beschränkter Zeit entstehen, wie z. B. dem Ludum Dare oder dem Devmania Overnight Contest. Geht die Entwicklung eines Spiels parallel zum Lernprozess eines Anfänger, sollte aber auch hier mit Entwicklungszeiten von mehreren Monaten gerechnet werden.

Die Wahl der Programmiersprache

Um eigene Spiele programmieren zu können, musst du selbstverständlich zunächst Programmieren lernen. Es gibt zwar auch Programme, mit denen man ein Spiel ohne großen Programmieraufwand entwickeln kann. Auf diese wollen wir jedoch hier nicht näher eingehen, da sie den Entwickler meist stark einschränken. Wer sein Spiel wirklich selbst programmiert, hat maximale Freiheit bei der Umsetzung seiner Ideen (was aber auch mit mehr Arbeit verbunden ist).

Wer sich vornimmt Programmieren zu lernen, der muss sich zuerst für eine Programmiersprache entscheiden. In dieser Sprache werden die Programme vom Programmierer geschrieben (Quellcode), bevor sie in eine für den Computer ausführbare Form übersetzt werden. Heute existiert eine schier unüberschaubare Anzahl von Programmiersprachen, und sie unterscheiden sich teilweise sehr stark voneinander. Für uns als Spieleprogrammierer ist jedoch glücklicherweise nur eine relativ kleine Gruppe von Sprachen interessant, denn nicht mit allen Programmiersprachen ist es sinnvoll (oder überhaupt möglich), Spiele zu programmieren.

Wir wollen uns die unserer Meinung nach wichtigsten dieser in Frage kommenden Sprachen etwas näher ansehen. Mit all diesen Sprachen kann man Spiele programmieren, aber alle haben ihre Eigenheiten. Damit du eine bessere Wahl treffen kannst, findest du zu jeder Sprache ein Stück Beispiel-Quellcode. Dies soll dir nur einen ersten Eindruck der jeweiligen Programmiersprache vermitteln. Es sollte dir jedoch klar sein, dass ein so kleiner Quellcode-Abschnitt nicht repräsentativ für eine ganze Sprache sein kann. Außerdem beleuchten wir jede Sprache unter folgenden Aspekten:

Komfort und Einsteigerfreundlichkeit
Die Menge an Quellcode, die man in den verschiedenen Programmiersprachen tippen muss, um gewisse Berechnungen/Algorithmen auszuführen, variiert stark. Was in der einen Sprache mit 10 Zeilen Code erledigt ist, benötigt in der anderen Sprache möglicherweise 50 Zeilen Code. Auch bieten einige Sprachen bestimmte Komfortfunktionen, die andere nicht bieten. Komfortablere Programmiersprachen erleichtern dem Programmierer die Arbeit, was aber nicht selten auch zu langsameren Programmen führt. Der Prozess, der ein Stück Quellcode in ein ausführbares Programm verwandelt, ist auch von Sprache zu Sprache unterschiedlich kompliziert und fehleranfällig.
Häufig sind die komfortableren Programmiersprachen für Einsteiger leichter zu erlernen, da mit ihnen viele "alltägliche" Aufgaben ohne viel Aufwand gelöst werden können und es weniger Fallstricke gibt, über die man stolpern kann.
Verfügbarkeit von Werkzeugen und Bibliotheken
Wer ein Spiel programmiert, der muss nicht das Rad neu erfinden. Für die wichtigsten Aufgabenbereiche wie 2D-/3D-Grafik, Audio, Netzwerk oder die Abfrage von Eingabegeräten wie Maus, Tastatur oder Joystick gibt es schon vorgefertigte Bibliotheken. Diese Bibliotheken bindet man einfach in sein Programm ein und erspart sich damit eine Menge Arbeit. Die Wahl der Programmiersprache sollte auch das Angebot solcher Bibliotheken berücksichtigen. Glücklicherweise sind einige der besonders bekannten Bibliotheken auch für mehrere Sprachen verfügbar. Auch wenn du am Anfang solche Bibliotheken noch nicht benötigen wirst, sollte dieser Aspekt nicht vernachlässigt werden. Es wäre ungünstig, würdest du eine Programmiersprache lernen und später feststellen, dass sie zur Spieleprogrammierung völlig ungeeignet ist.
Neben Bibliotheken benötigt man zum Programmieren auch gute Werkzeuge/Tools. Eines der wichtigsten Werkzeug ist die Entwicklungsumgebung. Dabei handelt es sich im Prinzip um einen Text-Editor, der speziell für die Bearbeitung von Quellcode in der entsprechenden Sprache ausgelegt ist. Eine gute Entwicklungsumgebung unterstützt den Programmierer durch Autovervollständigung beim Tippen, Anzeigen von Informationen über Objekte im Quellcode, bei der Projektverwaltung und bei der Fehlersuche (Debugging).
Effizienz
Eine schnelle Ausführung des Programms ist für viele Spiele sehr wichtig, da sie 3D-Grafik, Sound, Physik oder künstliche Intelligenz in Echtzeit berechnen müssen und dadurch einen Computer an die Grenzen seiner Leistungsfähigkeit bringen können. Für Hobby-Spieleprogrammierer spielt dieser Aspekt normalerweise eine untergeordnete Rolle, da ihre Spiele tendenziell einfacher gehalten sind. Außerdem geht mit höherer Leistungsfähigkeit einer Sprache meistens auch eine Nähe zum zugrunde liegenden Computer-System einher. Die dadurch erhöhte Komplexität kann dafür sorgen, dass Programmierfehler leichter entstehen und schwieriger gefunden werden können. Als Spieleentwickler gilt es also eine für das Vorhaben angemessene Balance zwischen Effizienz und Produktivität zu finden.

C++

Screenshot der Entwicklungsumgebung Microsoft Visual Studio 2008 mit einem C++-Spielprojekt.

In der Programmiersprache C++ (ausgesprochen "C Plus Plus") werden fast alle professionellen/kommerziellen Spiele programmiert. Der Grund dafür ist, dass C++ die Programmierung sehr schneller Programme auf einer niedrigen Ebene erlaubt. Letzteres bedeutet, dass es nicht viel "zwischen" dem Programm und der Hardware des Computers gibt. Entsprechend rudimentär und fehleranfällig ist diese Sprache in vielen Bereichen, was sie nicht gerade zur einsteigerfreundlichsten Programmiersprache macht. Mit "fehleranfällig" ist gemeint, dass man leicht etwas falsch machen kann, wenn man nicht gut aufpasst. Zurecht sagt man, dass es nur sehr wenige Menschen gibt, die diese Sprache in all ihren Details vollends verstehen und sie zu nutzen wissen. Da C++ in der Spieleprogrammierung sehr weit verbreitet ist, hat man hier jedoch die größte Auswahl an Bibliotheken. Weiterhin gibt es eine große Zahl an Werkzeugen/Entwicklungsumgebungen.

// Benötigte Bibliothek einbinden.
#include <iostream>
 
// Die folgende Funktion berechnet n!, die Fakultät von n.
int fakultaet(int n) {
    // Signalisiere einen Fehler, wenn n negativ ist.
    if(n < 0) throw std::domain_error("Fakultät für negative Zahlen ist nicht definiert!");
    
    if(n == 0) return 1;        // 0! = 1
    else return n * fakultaet(n - 1);   // Rekursion: n! = n * (n - 1)!
}
 
// Die Hauptfunktion "main":
// Hier startet das eigentliche Programm.
int main() {
    // Begrüßung
    std::cout << "Hallo Spieleprogrammierer!" << std::endl;
    std::cout << "Gib eine Zahl ein! ";
    
    // Zahl einlesen.
    int zahl;
    std::cin >> zahl;
    
    // Quadrat der Zahl ausgeben.
    std::cout << "Das Quadrat von " << zahl << " ist: " << (zahl * zahl) << std::endl;
 
    try {
        // Fakultät der Zahl ausgeben.
        std::cout << "Die Fakultät von " << zahl << " ist: " << fakultaet(zahl) << std::endl;
    }
    catch(const std::exception& e) {
        // Ein Fehler ist aufgetreten. Gib die Fehlermeldung aus.
        std::cout << "Fehler: " << e.what() << std::endl;
    }
    
    return 0;   // Ende des Programms
}

C#

Screenshot der Entwicklungsumgebung Microsoft Visual Studio 2008 mit einem C#-Projekt.

C# (ausgesprochen "C Sharp") ist mit C++ verwandt und erlaubt ein komfortableres Programmieren. Es handelt sich bei C# um eine ".NET-Sprache" (wenn du irgendwo etwas von .NET liest, dann ist damit unter Anderem auch C# gemeint). Das Angebot an Bibliotheken und Werkzeugen ist nicht so umfangreich wie das für C++, was auch daran liegt, dass die Sprache viel jünger ist. Die erreichbare Geschwindigkeit reicht zwar nicht an die von C++-Programmen heran, sollte jedoch auch für ambitioniertere Spieleprojekte kein Problem darstellen. Wenn du eine Xbox besitzt und für diese eigene Spiele programmieren möchtest, dann solltest du C# lernen. Zudem ist C# die Programmiersprache der Wahl für die Spieleentwicklungsumgebung ("Engine") Unity, die man ambitionierten Anfängern oft empfiehlt.

// Benötigte Bibliothek einbinden.
using System;
 
namespace CSharpBeispielprogramm
{
    class Program
    {
        // Die Hauptfunktion "Main":
        // Hier startet das eigentliche Programm.
        static void Main(string[] args)
        {
            // Begrüßung
            Console.WriteLine("Hallo Spieleprogrammierer!");
            Console.Write("Gib eine Zahl ein! ");
 
            // Zahl einlesen
            int zahl = int.Parse(Console.In.ReadLine());
 
            // Quadrat der Zahl ausgeben.
            Console.WriteLine("Das Quadrat von {0} ist: {1}", zahl, zahl * zahl);
 
            try
            {
                // Fakultät der Zahl ausgeben.
                Console.WriteLine("Die Fakultät von {0} ist: {1}", zahl, fakultät(zahl));
            }
            catch (Exception e)
            {
                // Ein Fehler ist aufgetreten. Gib die Fehlermeldung aus.
                Console.WriteLine("Fehler: {0}", e);
            }
        }
 
        // Die folgende Funktion berechnet n!, die Fakultät von n.
        private static int fakultät(int n)
        {
            // Signalisiere einen Fehler, wenn n negativ ist.
            if (n < 0) throw new ArgumentOutOfRangeException("n", "Darf nicht negativ sein!");
 
            if (n == 0) return 1;               // 0! = 1
            else return n * fakultät(n - 1);    // Rekursion: n! = n * (n - 1)!
        }
    }
}

Java

Screenshot der Entwicklungsumgebung Eclipse mit einem Java-Projekt.

Die schon etwas ältere Programmiersprache Java hat C# maßgeblich beeinflusst. Die beiden Sprachen sind sich daher recht ähnlich. Während Java für die Entwicklung von betrieblichen Anwendungen sehr populär geworden ist, kann man die Sprache bezüglich Spieleentwicklung für den PC eher als Außenseiter bezeichnen. Möchtest du jedoch für Android-Smartphones deine eigenen Apps oder Spiele programmieren, dann führt kaum ein Weg an Java vorbei, da Android-Apps fast ausschließlich in dieser Sprache programmiert werden.

// Benötigte Bibliothek einbinden.
import java.io.*;
 
public class JavaBeispielprogramm {
    // Die folgende Funktion berechnet n!, die Fakultät von n.
    private static int fakultät(int n) throws Exception {
        // Signalisiere einen Fehler, wenn n negativ ist.
        if(n < 0) throw new Exception("n darf nicht negativ sein!");
        
        if(n == 0) return 1;                // 0! = 1
        else return n * fakultät(n - 1);    // Rekursion: n! = n * (n - 1)!
    }
    
    // Die Hauptfunktion "main":
    // Hier startet das eigentliche Programm.
    public static void main(String[] args) throws Exception {
        // Begrüßung
        System.out.println("Hallo Spieleprogrammierer!");
        System.out.print("Gib eine Zahl ein: ");
 
        // Zahl einlesen.
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int zahl = Integer.parseInt(in.readLine());
        
        // Quadrat der Zahl ausgeben.
        System.out.println("Das Quadrat von " + zahl + " ist: " + (zahl * zahl));
        
        try {
            // Fakultät der Zahl ausgeben.
            System.out.println("Die Fakultät von " + zahl + " ist: " + fakultät(zahl));
        }
        catch(Exception e) {
            // Ein Fehler ist aufgetreten. Gib die Fehlermeldung aus.
            System.out.println("Fehler: " + e.toString());
        }
    }
}

Python

Screenshot der Entwicklungsumgebung Aptana Studio 3 mit einem Python-Projekt.
Screenshot der minimalistischen Entwicklungsumgebung IDLE für Python.

Python unterscheidet sich nicht nur äußerlich stark von den bisher gezeigten Sprachen. Ein großer Unterschied besteht darin, dass Python dynamische Typisierung und Duck-Typing verwendet. Insbesondere durch die dynamische Typisierung sind Python-Programme tendenziell langsamer als solche, die in C++, C# oder Java geschrieben sind (vermutlich kannst du mit diesen technischen Details noch nicht viel anfangen, aber falls es dich interessiert, kannst du die oben verlinkten Seiten durchlesen). Python-Programme kommen dafür jedoch mit relativ wenig Quellcode aus. Aufgrund seiner Unkompliziertheit ist Python für Anfänger als erste Programmiersprache sehr attraktiv. Werkzeuge und Bibliotheken zur Spieleprogrammierung sind in genügender Menge verfügbar.

# Die folgende Funktion berechnet n!, die Fakultät von n.
 
def fakultaet(n):
    # Signalisiere einen Fehler, wenn n negativ ist.
    if n < 0: raise ValueError("n darf nicht negativ sein!")
    elif n == 0: return 1             # 0! = 1
    else: return n * fakultaet(n - 1) # Rekursion: n! = n * (n - 1)!
 
# Hier startet das eigentliche Programm.
print("Hallo Spieleprogrammierer!") # Begrüßung
zahl = input("Gib eine Zahl ein: ") # Zahl einlesen.
 
# Quadrat der Zahl ausgeben.
print("Das Quadrat von %d ist: %d" % (zahl, zahl * zahl))
try:
    # Fakultät der Zahl ausgeben.
    print("Die Fakultät von %d ist: %d" % (zahl, fakultaet(zahl)))
except Exception as e:
    # Ein Fehler ist aufgetreten. Gib die Fehlermeldung aus.
    print("Fehler: %s" % e)

Lernen einer Programmiersprache

Zugegeben: Eigentlich hast du noch nicht genügend Informationen, um dich zu diesem Zeitpunkt für eine der vorgestellten Sprachen zu entscheiden. Trotzdem musst du eine Wahl treffen. Wie bereits gesagt: Mit all diesen Sprachen kann man Spiele programmieren. Das schlimmste, was passieren kann, ist dass dir die ausgesuchte Sprache nicht gefällt. Dann versuchst du es mit einer anderen.

Wenn du dich für eine Sprache entschieden hast, ist es an der Zeit, dass du anfängst sie zu lernen. Dieses Wiki ist allerdings nicht für diesen Zweck gedacht. Es gibt genügend Tutorials und Bücher, die sich an Programmieranfänger richten. Du findest weiter unten für jede der kurz vorgestellten Sprachen einige Lektüreempfehlungen, aufgeteilt in Bücher und Online-Tutorials. Ein Buch kostet zwar Geld, aber dafür hast du etwas Handfestes. Bei einem Buch kann man auch von einer gewissen Mindestqualität ausgehen. Außerdem könnte beim Lernen mit einem Buch die Gefahr geringer sein, dass du abbrichst, denn schließlich hast du Geld dafür bezahlt. Es liegt bei dir, ob du den Lektüreempfehlungen folgst oder dir lieber selbst etwas suchst. Aber bevor du anfängst, möchten wir dir noch ein paar Tipps mit auf den Weg geben:

Lektüre für C++

C++-Bücher

C++-Tutorials

Lektüre für C#

C#-Bücher

C#-Tutorials

Lektüre für Java

Java-Bücher

Java-Tutorials

Lektüre für Python

Python-Bücher

Python-Tutorials

Auswahl einer passenden Bibliothek

Hast du dir schon eine Programmiersprache ausgesucht und mindestens ein Buch oder Tutorial durchgearbeitet, die Inhalte vollständig verstanden und mit einigen einfachen Programmen erste Praxiserfahrungen gesammelt? Dann kann es weitergehen.

Wenn du ein Spiel mit Grafik programmieren möchtest (und davon gehen wir einmal aus), dann kommst du um den Einsatz einer zusätzlichen Bibliothek in den meisten Fällen nicht herum. C++ und seine Standardbibliothek bieten beispielsweise von Haus aus keinerlei Möglichkeiten zur Darstellung von Grafik, zum Abfragen der Tastatur (nur sehr rudimentär) oder zum Abspielen von Sound und Musik. Bei den anderen Programmiersprachen sieht es schon ein wenig besser aus, allerdings empfiehlt es sich trotzem, eine Bibliothek einzusetzen, die speziell für die Entwicklung von Spielen (oder allgemein von Multimedia-Anwendungen) konzipiert ist.

Eine kleine Übersicht

Im Folgenden haben wir einige Empfehlungen zusammengestellt, welche Bibliotheken du dir anschauen solltest. Diese sind primär für 2D-Grafik ausgelegt. An 3D-Grafik solltest du erst später denken. Alle Bibliotheken sind kostenlos verfügbar, und viele von ihnen können mit mehr als nur einer Programmiersprache genutzt werden. Die meisten sind für verschiedene Betriebssysteme verfügbar, und man kann mit jeder dieser Bibliotheken Spiele programmieren. Sie unterscheiden sich jedoch in ihrer Architektur und ihrem Abstraktionsgrad. Manche Bibliotheken bieten nur sehr grundlegende Funktionalität an, während andere bereits einfache Klassen für Spielobjekte mitbringen, auf den man aufbauen kann.

Bibliothek Sprachen Kurzbeschreibung Weiterführende Links
SFML (Simple and Fast Multimedia Library) C++, C#, Python Eine moderne objektorientierte Multimedia-Bibliothek, die eine große Menge an Features bietet und einen schnellen Einstieg ermöglicht.
SDL (Simple DirectMedia Layer) C++, C#, Java, Python Eine Bibliothek, die grundlegende Funktionalität wie Grafikausgabe, Audio, Eingabe und Netzwerk bereitstellt.
Pygame Python Pygame basiert auf SDL, bietet aber noch zusätzliche Funktionalität.
Allegro C++, C#, Python Eine robuste Bibliothek für die Spieleprogrammierung, die noch aus der MS-DOS-Zeit stammt, aber mittlerweile stark modernisiert wurde.
XNA C# XNA ist eine umfangreiche Bibliothek für C#, mit der man sowohl PC- und Windows Phone 7- als auch Xbox-Spiele programmieren kann.
HGE C++ Eine Windows-spezifische Bibliothek, mit der man relativ schnell erste Ergebnisse erzielen kann. Sie bietet auch fortgeschrittene Features wie Partikelsysteme und kommt mit einigen Tools. Die Bibliothek wird zwar scheinbar nicht mehr weiter entwickelt, funktioniert aber auch heute noch hervorragend.
Slick Java Slick stellt eine einfache Schnittstelle für die Entwicklung von 2D-Spielen mit Java bereit. Slick bietet auch fortgeschrittene Features wie Partikelsysteme und kommt mit einigen Tools.
LibGDX Java LibGDX ist eine Spielentwicklungsbibliothek für Java, mit der Spiele sowohl für Desktop- als auch für Android-Systeme erstellt werden können. Die Entwicklung von 2D-Spielen wird dabei besonders unterstützt, 3D-Spieleentwicklung ist allerdings auch möglich. LibGDX bietet ebenfalls fortgeschrittene Features wie Partikelsysteme und kommt mit einigen Tools.

Erste Schritte mit einer Bibliothek zur Spieleprogrammierung

Nachdem du dich nun in eine Programmiersprache eingearbeitet und dich für eine Bibliothek entschieden hast, solltest du den Umgang mit dieser Bibliothek üben. In der Tabelle sind jeweils weitere Links angegeben. Dort findest du die Dokumentation der jeweiligen Bibliothek und Tutorials. Mit deren Hilfe solltest du relativ schnell in der Lage sein, einfache Grafiken anzuzeigen, Eingabegeräte wie Maus, Tastatur, Joystick und Game-Controller abzufragen und Sound/Musik abzuspielen. Wenn du diese Grundlagen beherrschst, dann steht dir (technisch gesehen) nichts mehr im Weg, eigene Spiele zu programmieren.

Spiele programmieren

Wenn du es bis hier hin geschafft hast, hast du schon einen langen Weg hinter dir. Nun, da du Programmiererfahrungen gesammelt und du eine unterstützende Bibliothek an deiner Seite hast, kann der eigentliche Spaß beginnen.

Ein simples Spiel zum Aufwärmen

Noch solltest du nicht versuchen, deine ursprüngliche Spielidee umzusetzen (es sei denn, sie war wirklich sehr unkompliziert). Versuche dir stattdessen Schritt für Schritt Vorgehensweisen und Methoden anzueignen, die dir bei der Spieleprogrammierung helfen. Fange beispielsweise damit an, eine einfache Spielfigur mit der Tastatur oder der Maus über den Bildschirm zu bewegen. Wenn du es etwas anspruchsvoller willst, dann sorge dafür, dass die Bewegung sanft abklingt, nachdem die entsprechende Taste losgelassen wurde. Als Nächstes könntest du Gegner einbauen, die irgendwo erscheinen und sich durch das Spielfeld bewegen. Nun, da es mehr als nur ein Spielobjekt gibt, wirst du dir Gedanken darüber machen müssen, wie du diese Objekte in deinem Programm repräsentieren und verwalten kannst (beispielsweise mit einer Klasse für Spielobjekte und davon abgeleiteten Klassen für die verschiedenen Arten von Objekten sowie einer Liste aller vorhandenen Spielobjekte). Auch wirst du feststellen wollen, ob der Spieler von einem Gegner berührt wird, und schon kommst du mit dem Thema Kollisionserkennung in Berührung. Danach soll der Spieler vielleicht eine Waffe bekommen, um die Gegner zu beseitigen. Dazu integrierst du noch ein paar passende Sounds und einen Punktezähler, und schon ist ein erstes spielbares Spiel fertig. Über Features wie eine Bestenliste, Power-Ups, verschiedene Arten von Gegnern und Waffen könnte man ebenfalls noch nachdenken.

Solch ein Projekt (oder etwas Vergleichbares) ist zwar nicht besonders innovativ, aber als erstes eigenes kleines Spiel eignet es sich hervorragend. Der technische Anspruch ist gering, und am Ende wirst du mit Sicherheit sehr stolz auf dich und dein Spiel sein. Jeder Spieleprogrammierer erinnert sich sicherlich noch an sein erstes Spiel und an das damit verbundene gute Gefühl, etwas eigenes erschaffen zu haben. Auch wenn so ein erstes Spiel andere Spieler vermutlich "nicht gerade vom Hocker reißt" – lass dich davon nicht verunsichern. Jeder hat einmal klein angefangen, und der gewöhnliche Spieler hat gar keine Vorstellung davon, wie viel Aufwand es bedeutet, ein Spiel zu programmieren.

Eine gute Idee ist es, dein erstes Spiel der Spieleprogrammierer-Community (Forum zur Projektvorstellung) vorzustellen. Die Community-Mitglieder sind sowohl Spieler als auch Programmierer/Entwickler. Sie können dir daher sehr wertvolles Feedback geben: einerseits zum Spiel an sich (Gameplay, Grafik, Sound, Steuerung, Schwierigkeitsgrad, ...), andererseits zur programmiertechnischen Umsetzung. Damit Letzteres möglich ist, solltest du auch den Quellcode veröffentlichen. Hier solltest du dich kritikfähig zeigen, denn es ist nicht unwahrscheinlich, dass buchstäblich jede Zeile deines Codes auseinander genommen wird. Das ist jedoch völlig normal, denn Programmieren ist hauptsächlich eine Erfahrungssache. Je mehr du programmierst, desto mehr wirst du erkennen, wie du gewisse Dinge schöner, kürzer, schneller und eleganter lösen kannst. Die erfahreneren Programmierer werden darum sehr viele Stellen in deinem Code erkennen, die du besser machen könntest, und dich darauf hinweisen. Es ist wichtig, dass du diese Kritik nicht persönlich nimmst, sondern versuchst daraus etwas zu lernen, so dass du es im nächsten Spiel besser machen kannst.

Kritischer Rückblick und die nächsten Spiele

Nach dem ersten Spiel kommt das zweite. Versuche diesmal technisch etwas anspruchsvolleres umzusetzen und aus den Fehlern und Schwächen des ersten Spiels zu lernen. Schau dir dazu dein erstes Spiel und seinen Quellcode noch einmal genau an, und lies noch einmal die Kommentare, die du dazu erhalten hast.

Nachdem du eine Reihe kleinerer Spiele entwickelt hast, die im Optimalfall jeweils komplexer, spaßiger und besser umgesetzt sind als ihre Vorgänger, kannst du noch einmal darüber nachdenken, was eigentlich dein "Traumprojekt" ist, und ob du schon bereit dafür bist, es in Angriff zu nehmen. Je mehr kleinere Spiele du entwickelst, desto besser kannst du den Arbeitsaufwand abschätzen.

Wie geht es weiter?

Nun ist der Punkt erreicht, wo dieser Artikel endet. Es ist schwierig, hier noch allgemeine nützliche Hinweise zu geben. Du solltest das Wiki und das Forum benutzen, um dich über speziellere Themen zu informieren: Wie plant man ein größeres Projekt? Wie findet man weitere Programmierer, Grafiker, Audiodesigner, Musiker, ...? Wie organisiert man sich als Team? Wie kann man einen bestimmten grafischen Effekt am besten umsetzen?

Viel Erfolg!

Meine Werkzeuge
Namensräume
Varianten
Aktionen
Navigation
Werkzeuge