Hallo Leute,
Es ist schon etwas überfällig, eigentlich wollte ich schon vor einige Zeit einige Tutorials zum Thema XNA schreiben, wurde allerdings durch viele verschiedene Gründe davon abgehalten, u.a Krankheit, Faulheit usw.
Aber das hat nun ein Ende, hier ist der erste Teil meiner Tutorialserie, die ursprünglich mal als Videotutorialserie im Konzept war, jetzt aber doch als Texttutorial veröffentlicht wird.
Genug der langen Rede, fangen wir an.
Was ist XNA?

Bei XNA (XNA's Not Acronymed, zu deutsch: XNA ist keine Abkürzung) handelt es sich um ein Spieleframework aus dem Hause Microsoft.
Mittels XNA lassen sich einfach und unkompliziert Spiele für Windows und XBox360 erstellen, seit Version 4 des Frameworks (erschien am 16. September 2010) wird auch das neue WindowsPhone 7 unterstützt. Spiele für Windows zu entwickeln ist kostenlos, während man bei der XBox360 Mitglied im so genannten XNA Creators Club sein muss. (Mitgliedschaftsgebühren: 49$ für 4 Monate, 99$ für 12 Monate)
Das Framework übernimmt dabei grundlegende Aufgaben, die ein Spieleentwickler normalerweise erledigen muss, u.a das initialisieren (vorbereiten) des GraphicsDevice (in der Regel die Grafikkarte oder ein anderes Ausgabegerät) und das Aufrufen der Update-/Draw-Methode des Spiels (mehr zu diesen Methoden später).
Allein das Vorbereiten des GraphicsDevice beansprucht normalerweise schon an die 100 Zeilen Code, wenn man sein Spiel direkt in C++ und DirectX schreibt.
Was die Wahl der Programmiersprache sowie der Grafikschnittstelle angeht, so wird von Microsoft auf die .NET Sprache C# gesetzt und als Grafikschnittstelle kommt DirectX in Version 9 zum Einsatz.
Dies macht die Spieleentwicklung auch für Anfänger und Programmierneulinge ziemlich einfach, da C# leicht zu erlernen ist und dennoch Leistung bietet.
Was wird benötigt, um Spiele mit XNA zu erstellen?

Um Spiele mit dem XNA Framework unter Windows zu erstellen, werden folgende Dinge benötigt:

• Mindestens eine DirectX 9.0c fähige Grafikkarte mit mindestens Pixel Shader Model 2.0
  
• Visual Studio 2010 oder Visual C# 2010 Express (im Falle der Version 4, die in dieser Tutorialserie verwendet wird)
  
• XNA GameStudio 4.0 (Hier erhältlich)
  
• Mindestens Windows XP
  
• C#-Grundkenntnisse
  

Für die Entwicklung von XBox360-Spielen wird zustäzlich noch benötigt:

• Eine XBox360 mit installierter Festplatte
  
• Eie Mitgliedschaft im XNA Creator Club (Preise siehe oben)
  

Für die Entwicklung von WindowsPhone 7 Spielen wird zusätzlich noch benötigt:

• Mindestens eine DirectX 10 fähige Grafikkarte
  
• Ein WindowsPhone 7
  
• Die WindowsPhone 7 Developer Tools (Hier erhältlich, inklusive XNA Gamestudio 4.0 und deutschem Sprachpaket)
  
• Mindestens Windows Vista SP2 (Windows XP wird nicht unterstützt aufgrund DirectX 10)
  

Zum spielen von Spielen, die mit dem XNA Framework erstellt wurden, wird das XNA Framework Redistributable benötigt (Hier erhältlich, entfällt, wenn das XNA GameStudio 4.0 installiert ist)
Damit sollte erstmal alles abgehakt sein, die Installation und Einrichtung ist selbsterklärend, auf die werde ich nicht auch noch eingehen.
Sobald alles installiert ist, startet Visual Studio 2010 und geht einen Punkt weiter.
Die ersten Schritte:

Als erstes geht auf Datei -> Neu -> Projekt.


In dem nun auftauchenden Dialog geht es links auf XNA Game Studio 4.0 und danach im großen Bereich des Fensters auf Windows-Spiel (4.0). (Bitte beachtet die viele Projektvorlagen nicht, solltet ihr die Expressversion von Visual Studio nutzen, so fehlen die Meisten, ich habe Visual Studio Professional)
Vergebt nun noch einen Namen für das Projekt, ich benutze in diesem Tutorial den Namen XNATutorial.




Nach dem Klick auf OK dauert es, je nach Rechengeschwindigkeit eures Computers, einige Sekunden, bis alle erforderlichen Daten angelegt und geladen wurden.
Danach sollte es in etwa so aussehen:


Was ihr an Code vor euch findet, ist alles, was ihr benötigt, um theoretisch ein Spiel entstehen zu lassen.
Drückt nun auf F5 und wartet, bis alles fertig ist.
Danach sollte so ein Fenster erscheinen:


Dieses Fenster ist euer Spiel. Wie ihr seht, ist der vorgenerierte Code schon eigenständig lauffähig, im Hintergrund hat XNA bereits das GraphicsDevice initialisiert und ruft nun fleißig die entsprechende Update- und Draw-Methode eures Spiels auf. (Zu den Methoden gleich mehr)
Schließt das Fenster nun durch einen Klick auf das X rechts oben in der Ecke.
Bevor wir nun weitergehen, möchte ich erst einmal die Dinge erklären, die euch schon vorliegen.
Im Codefenster haben wir zuerst alle wichtigen Namespaces, auch die von XNA, sowie 5 Methoden inkl. Kommentar zur Erklärung: Initialize, LoadContent, UnloadContent, Update und Draw.
Nachfolgend werde ich auf alle Methoden eingehen und ihren Zweck erläutern, auch wenn dies in Kurzform schon durch die Kommentare geschehen ist:


Initialize - Diese Methode wird nach dem Konstruktor (in meinem Fall "public XNATutorial") aufgerufen.
In dieser Methode werden normalerweise die einzelnen Objekte und Variablen nach ihrer Initialisierung im Konstruktor (oder hier in Initialize) mit Standardwerten gefüllt, die gebraucht werden.
Außerdem kann in Initialize alles vorbereitet werden, was in einem der nächsten Schritte gebraucht wird.


LoadContent - In dieser Methode werden sämtliche Inhalte des Spiels geladen, z.B. Texturen, Sprites, 3D-Models, Musik, Sounds, externe Bibliotheken usw.
Sie wird einmal bei Spielstart aufgerufen und ist der Platz, um alle Inhalte zu laden, die zu Anfang gebraucht werden.
Weitere Inhalte lassen sich dennoch auch nachträglich noch laden, empfehlenswert ist es aber, die Inhalte soweit alle hier zu laden, wenn möglich, in Bezug auf Speicherverbrauch und Leistung.
Diese Methode ist eine kleine Ausnahme, meine obige Aussage, sie wird nur bei Spielstart aufgerufen, stimmt zwar, allerdings geschieht dies auch mal während des Spiels, u.a wenn das GraphicsDevice verloren gegangen ist (z.B. weil zwischendurch eine andere Anwendung im Vollbildmodus lief oder so). In diesem Fall muss der Content neu geladen werden, weshalb diese Methode nochmals aufgerufen wird.
Auf das Laden von Content gehe ich später nochmals ein.


UnloadContent - Das Gegenstück zu LoadContent, hier wird sämtlicher Content, der nicht mittels Content-Pipeline geladen wurde, entladen. (Die Content-Pipeline werde ich später erklären)
Hier müssen also alle geladenen Klassenbibliotheken usw wieder entladen werden, indem man die entsprechenden Objekte freigibt.
Dieser Schritt ist besonders auf der XBox360 und dem WindowsPhone 7 notwendig, da diese, im Gegensatz zu Windows, keinen GarbageCollector haben bzw. dieser anders funktioniert. (Der GarbageCollector kümmert sich um die Speicherbereinigung und ist euer Freund, wenn es ums Aufräumen von nicht mehr gebrauchten Objekte und Variablen geht).


Update - Die Update-Methode ist eine der wichtigen Methoden in einem Spiel. In ihr laufen alle Berechnungen ab, z.B. für die aktuelle Position der Spielfigur oder der Objekte in der Welt.
Sie wird standardmäßig etwa alle 1/60s aufgerufen, was 60 Frames pro Sekunden (FPS) sind.
Diese Zahl der FPS kann erhöht werden, bringt aber keinen wirklichen Nutzen, da 60 FPS durchaus für flüssiges Spielen reichen.
Außerdem wird in Update auch der Status der Tastatur bzw des Gamepads abgefragt, um die Spielfigur steuern zu können usw.


Draw - In der Draw-Methode wird schließlich alles auf den Bildschirm gebracht, dabei stehen viele Hilfsmittel zur Verfügung.
Euch ist doch noch der Test von vorhin in Erinnerung und der blaue Hintergrund, den ihr da gesehen habt?
Dies geschieht genau hier in Draw, ausgelöst durch die Funktion "GraphicsDevice.Clear(Color.CornflowerBlue);"
Diese leert den BackBuffer (dort wird die Grafikausgabe vorbereitet, bevor sie auf dem Bildschirm erscheint) und füllt ihn mit einer Farbe, in diesem Fall CornflowerBlue.
Übrigens, bevor die Ausgabe auf dem Bildschrim erscheint, könnt ihr sie mittels Shader (kleine Programme, die auf der Grafikkarte laufen und Bilddaten manipulieren können) anders aussehen lassen oder einfärben, drehen, skalieren (vergrößern/verkleinern) usw.
Bei 2D Grafiken geschieht dies mittels des SpriteBatch, dessen Deklaration auch oben zu finden ist, über dem Konstruktor der Game-Klasse.
Dort findet sich auch der GraphicsDeviceManager, er verwaltet die Grafikkarte und erlaubt euch, Dinge zu ändern oder abzufragen, u.a die Größe (Auflösung) des Spielfensters, ob es im Vollbildmodus läuft usw.


Dies war soweit mal der Code, wenden wir uns nun der rechten Seite zu, dem Projektmappen-Explorer.
Wie ihr seht, enthält die Projektmappe schon zwei Projekte.
Das eine Projekt ist euer Spiel, das andere Projekt ist das so genannte Content-Projekt.
In diesem Projekt landet sämtlicher, von der Content-Pipeline unterstützter Content. (Die Funktionsweise der Content Pipeline erkläre ich später)
Die hier hinzugefügten Dinge landen später zusammen mit eurer Exe des Spiels im Projektordner, von dort aus werden sie dann geladen und genutzt.
Jedenfalls wird euch das Content-Projekt die ganze Entwicklungszeit über begleiten.


Dies war das erste Tutorial, eigentlich wollte ich noch etwas mehr reinbringen, allerdings haben wir jetzt schon über 1200 Wörter und somit ziemlich viele Dinge, daher wird es im nächsten Tutorial weitergehen mit den ersten Praxiserfahrungen und dieses Tutorial ist reine Theorie.
Ich hoffe, das Tutorial gefällt euch, ihr könnt ja den ein oder anderen Kommentar dazu hinterlassen.

Ebenfalls zu finden auf meinem Blog unter internetfreak.net und unter coding-cluster.net