Einführung in die Windows 8-Spieleentwicklung mit XNA und MonoGame

    Wie Sie wahrscheinlich bemerkt haben, wurde in unserem Blog eine Reihe von Materialien veröffentlicht, die die Grundlagen der Erstellung von WinRT-Anwendungsprogrammen für Windows 8 erläutern. In dieser Artikelserie wird erläutert, wie Sie WinRT-Spieleanwendungen in C # erstellen können.




    Wenn Sie an der Erstellung von Spielen für WinRT interessiert waren, wissen Sie wahrscheinlich, dass Visual Studio 2012 nur DirectX bietet. Dies ist eine sehr leistungsfähige Technologie, die C ++ - Kenntnisse erfordert und im Allgemeinen eher eine einfache API für die Arbeit mit intensiven Grafiken ist. Wenn Sie die ersten Schritte unternehmen, ist es viel einfacher, übergeordnete Bibliotheken zu verwenden. Aber aufgrund der Jugend der Plattform gibt es bisher nicht so viele Spiel- und physische Engines, dennoch wird ihre Liste wieder aufgefüllt. Hier sind einige von ihnen:



    Die letzten beiden - SharpDX und MonoGame - verdienen besondere Aufmerksamkeit. SharpDX ist ein Wrapper über DirectX und ermöglicht es Ihnen, mit dieser Technologie von .NET aus zu arbeiten und unterstützt auch WinRT. Noch interessanter ist, dass MonoGame, der plattformübergreifende Port der XNA-Bibliothek, auch unter WinRT läuft.
    XNA ist eine beliebte Bibliothek für Windows, Xbox360 und Windows Phone, mit der Tausende von Spielen erstellt wurden. Aufgrund der Tatsache, dass MonoGame die Hauptbereiche nicht geändert hat, sind für die Portierung von XNA keine großen Änderungen im vorhandenen Anwendungscode erforderlich.

    Konfigurieren Sie die Umgebung



    Um mit der Entwicklung von Spielen für WinRT auf MonoGame zu beginnen, müssen Sie Visual Studio 2012 konfigurieren und die erforderlichen Komponenten auf Ihrem Computer installieren, um das Projekt zu kompilieren. Natürlich können Sie bereits zusammengestellte Versionen von SharpDX und MonoGame herunterladen. Es ist jedoch besser, die Quelldateien dieser Bibliotheken herunterzuladen und lokal zu sammeln. Auf diese Weise können Sie detailliertere Fehlerbehebungen vornehmen und Ihr Verständnis für die Funktionsweise von MonoGame verbessern.

    Wenn Sie sich für den einfachen Weg entscheiden, finden Sie hier die Links: sharpdx.org/download (oder geben Sie in der Package Manager-Konsole Install-Package SharpDX ein) und monogame.codeplex.com/releases/view/96421

    Wenn Sie alles selbst zusammenbauen möchten
    :
    Erstellen Sie ein Verzeichnis, in dem die Quellbibliotheksdateien gespeichert werden. Zum BeispielD:\Gamedev

    1. Installieren Sie Git: msysgit.github.com
    2. Starten Sie Git Bash (Git-Konsole) und wechseln Sie in das Verzeichnis D:\Gamedev
    3. Wir bekommen die Quellen von SharpDX: git clone github.com/sharpdx/SharpDX
    4. Wir bekommen die Quellen von MonoGame: git clone github.com/mono/MonoGame
    5. Starten Sie die nativen Befehlszeilentools von Visual Studio 2012 x86 (suchen Sie, indem Sie im Startbildschirm nach dem Wort Native suchen).
    6. Wir gehen in das Verzeichnis cd D:\Gamedev\SharpDXund befehlen in MakeSharpDX.cmd win8 buildca. 3-4 Minuten, dass SharpDX zusammengebaut wird und dass sich D:\gamedev\sharpdx\Bin\Standard-winrt\Binär-Assemblies im Verzeichnis befinden
    7. Jetzt müssen wir das MonoGame-Projekt konfigurieren und kompilieren. Öffnen Sie dazu mit Visual Studio 2012. D:\gamedev\MonoGame\MonoGame.Framework.Windows8.slnMonoGame weiß nicht, wo sich die zusammengesetzten SharpDX-Assemblys befinden, und zeigt Fehler in den Referenzen an:

    8. Geben Sie in den Projekteigenschaften (Kontextmenü des Projekts, Eigenschaften ) im Abschnitt Referenzpfade den Pfad anD:\gamedev\sharpdx\Bin\Standard-winrt\
    9. Wir stellen das Projekt zusammen, woraufhin Sie eine Montage haben D:\gamedev\MonoGame\MonoGame.Framework\bin\Release\MonoGame.Framework.Windows8.dll
    10. Installieren Sie MonoGame-Projektvorlagen in Visual Studio. Kopieren Sie dazu die Dateien von Verzeichnis D:\gamedev\MonoGame\ProjectTemplates\VisualStudio2012\zu Verzeichnis, C:\Users\USERNAME\Documents\Visual Studio 2012\Templates\ProjectTemplates\Visual C#\Mono\starten Sie Visual Studio neu und erstellen Sie ein Projekt, das auf dieser Vorlage basiert:

    11. Vergessen Sie nicht, auch Referenzpfade für das neu erstellte Projekt anzugeben D:\gamedev\MonoGame\MonoGame.Framework\bin\Release\


    Kompilieren Sie dann das Projekt und führen Sie es aus. Herzlichen Glückwunsch, Sie haben Ihre erste MonoGame-Anwendung für WindowsRT erstellt. Obwohl es immer noch recht einfach aussieht, ein sauberer blauer Bildschirm, da es nichts tut und nichts außer dem Hintergrund zeichnet.
        public class Game1 : Game
        {
            GraphicsDeviceManager _graphics;
            SpriteBatch _spriteBatch;
            public Game1()
            {
                _graphics = new GraphicsDeviceManager(this);
                Content.RootDirectory = "Content";
            }
            ///Инициализация
            protected override void Initialize()
            {
                base.Initialize();
            }
            /// загрузка игровых ресурсов
            protected override void LoadContent()
            {
                _spriteBatch = new SpriteBatch(GraphicsDevice);
               //Content.Load...
            }
            protected override void UnloadContent()
            {
            }
            /// логика игры
            protected override void Update(GameTime gameTime)
            {
                base.Update(gameTime);
            }
            /// отрисовка игры
            protected override void Draw(GameTime gameTime)
            {
                GraphicsDevice.Clear(Color.CornflowerBlue);
                base.Draw(gameTime);
            }
        }
    


    Was weiter



    Wenn Sie mit XNA überhaupt nicht vertraut sind, durchsuchen Sie die Lernmaterialien zu XNA-Schlüsselwörtern im Internet. Es gibt viele Artikel, die die Grundlagen der Programmierung von Grafiken auf der Basis dieser Technologie erläutern. Sie können auch ein Beispiel des CastleX-Plattformspiels herunterladen , das unter Windows 8 ausgeführt wird .



    Dies ist ein klassischer Plattformspieler, in dem der Spieler springt, klettert und einige Dinge sammelt, die für die Handlung notwendig sind, und gleichzeitig versucht, sich vor allen möglichen Gefahren zu schützen.
    Bisher wird dieses Spiel von Windows 8 noch nicht vollständig unterstützt, da es keine wichtigen Komponenten enthält. Im Vergleich zu Windows wurden nur minimale Änderungen vorgenommen, die es ermöglichten, diese Anwendung unter WinRT auszuführen.
    Im KatalogAssetsCastle X-Spiele enthalten viele Dateien, die für die Arbeit erforderlich sind - dies sind Grafiken, Soundeffekte und Level. Viele dieser Dateien haben die ungewöhnliche XNB-Erweiterung.



    Eine der Schwierigkeiten, auf die Sie bei der Entwicklung von Spielen für MonoGame unweigerlich stoßen, ist die mangelnde Unterstützung für Content Pipeline. In XNA 4.0 und dem Add-On für Visual Studio 2010 gab es eine Reihe von Erweiterungen, die die Grafik- und Audioressourcen des Spiels in ein spezielles XNB-Datenformat packten. In Visual Studio 2012 gibt es keine solche Erweiterung, daher wird empfohlen, zusätzlich Visual Studio 2010 und XNA Game Studio 4.0 Refresh zu installieren. Stellen Sie außerdem sicher, dass Sie das Update für XNA Runtime für die Windows 8 Desktop-Plattform installieren .
    Als Nächstes können Sie Ressourcen in VS2010 sammeln oder das Drittanbieter-Dienstprogramm XNA Content Compiler verwenden

    Wie funktioniert das Spiel CastleX


    Die Programmlogik des Spiels beginnt mit dem Konzept der angezeigten Bildschirme. Es gibt verschiedene Arten von Bildschirmen (ihre Klassen befinden sich im Ordner / View / Screens /), z. B. einen Bildschirmschoner-Bildschirm, einen Demo-Wiedergabebildschirm, einen Level-Bildschirm, einen Spielemenü-Bildschirm und so weiter. Die Bildschirme werden von einer speziellen Klasse gesteuert, ScreenManagerdie von dem Typ geerbt DrawableGameComponent wird, der beim Starten der Anwendung registriert wird.

    Components.Add(screenManager);
    


    In der Aktualisierungsmethode der Hauptklasse des Spiels wird der Status des Bildschirmmanagers geändert, was sich in Abhängigkeit von den verarbeiteten Ereignissen auf das auswirkt, was der Spieler sieht.
    ScreenManager selbst zeigt sich in der Draw-Methode an, deren Logik sich aus dem Code ergibt:

            public override void Draw(GameTime gameTime)
            {
                ViewPort = GraphicsDevice.Viewport;
                foreach (GameScreen screen in screens)
                {
                    if (screen.ScreenState == ScreenState.Hidden)
                        continue;
                    try
                    {
                        SpriteBatch.Begin();
                    }
                    catch { }
                    screen.Draw(gameTime, SpriteBatch);
                    try
                    {
                        SpriteBatch.End();
                    }
                    catch { }
                }
            }
    


    Die Bildschirme selbst sind wiederum damit beschäftigt, Benutzereingaben in der Methode HandleInput und in ihrer eigenen Anzeige zu verarbeiten, abhängig von den Ereignissen, die verarbeitet wurden.

    Spiellevel-Bildschirm



    Der Hauptbildschirm der Spielebene enthält das Objekt "Aktuelle Ebene" in einer Variablen, die davon abhängt, levelwo sich der Spieler befindet. Ebenen werden dynamisch geladen. In der Methode des DrawBildschirms selbst wird der Anruf an die Methode Drawder Ebene selbst weitergeleitet ( leve.Draw) und ein Informationstafel mit der Anzahl der Leben und den gesammelten Schlüsseln wird angezeigt.DrawHud(gameTime, spriteBatch);

    Spiellevel


    Die Ebene selbst ist ein Array von Objekten Tile, die sich in verschiedenen Ebenen befinden können, wobei die Reihenfolge angegeben wird, in der sie angezeigt werden (was darüber liegt):

            private Tile[,] tiles;
            private Layer[] layers;
    


    Objekte Tilewiederum können alles sein - eine Tür, ein Stück Mauer, Wasser. Plättchen können auch transparent sein, und in der Tat sind solche Plättchen Auslöser, da ein Plättchen neben allem anderen auch Kollisionen behandelt - ein wichtiges Element des Spiels:

        public enum TileCollision
        {
            /// 
            /// Проходной тайл, который не мешает передвижению игрока
            /// 
            Passable = 0,
            /// 
            /// Не проходной тайл сквозь который нельзя пройти
            /// 
            Impassable = 1,
            /// 
            /// Тайл платформы, через который можно пройти со всех сторон кроме верха
            /// 
            Platform = 2,
            /// 
            /// лестница, особый случай
            /// 
            Ladder = 3
        }
    


    Die Kachel hat auch eine Textur - tatsächlich wird das, was auf dem Bildschirm angezeigt wird, durch die Methode geladen content.Load<>().
    Es gibt auch andere Objekte auf der Ebene, die mit den Kacheln und mit sich selbst interagieren - animierte Kacheln, Spielercharakter, Monster, Schlüssel, Münzen.

    Die Ebene selbst ist vollständig in einer Textdatei codiert. Unterschiedliche Symbole bedeuten unterschiedliche Arten von Kacheln und Objekten in ihrem Ausgangszustand: Zum Beispiel ist L eine Leiter, E ist ein gefährlicher Charakter, C ist eine Münze,! - unpassierbare Fliesen und so weiter. Alle Codes sind in der Methode zu finden, deren Status und Position in der Methode bearbeitet werden

    ####################
    X4001.................!..
    .x2..EG0102...............!X1003.
    \
    ##L.######..########
    ##L.........#C.C.C.C.C.C.X3003.
    ##L.......N..#C.C.C.C.C.Cx5..
    ##L.......EG0102..########
    ##L....N..#####......
    ##L...EG0102.......#.....X2003.
    ##L..####....#....x4..
    ##L..........#W....##
    ##L...N....N...#....##
    ##L...EG0102......i#www###
    #############www####
    wwwwwwwwwwwwwww#####
    X6001wwwwwwwwwwwwwww#####
    wx6wwwwwwwwwwwww######
    2!2!2!2!2!2!2!2!2!2!
    tit.Platforms and ghosts
    des.Face your first enemies inside the castle!
    Layer2.Bricks.Bricks.Bricks


    LoadTile(char tileType, int x, int y, String code)

    Level::Update. Zum Beispiel kann bei dieser Methode ein linker Tastendruck verarbeitet werden, das Objekt des Spielers wird auf das Plättchen der sich bewegenden Plattform verschoben, eine Kollision mit diesem Plättchen wird verarbeitet (die Eigenschaften des Objekts des Spielers ändern sich).
    
            private void UpdateMovingItems(GameTime gameTime)
            {
                if (MovingItemsAreActive)
                {
                    for (int i = 0; i < MovingItems.Count; ++i)
                    {
                        MovingItem movingItem = MovingItems[i];
                        movingItem.Update(gameTime);
                        if (movingItem.PlayerIsOn)
                        {
                            //двигаем персонаж игрока если он стоит на двигающейся платформе   
                            screenManager.Player.Position += movingItem.Velocity;
                        }
                    }
                }
            }  
    


    Das Spiel hat keine spezielle physische Engine, die Objekte, für die Sie die Physik berechnen müssen. Es gibt Methoden, die sich auf deren Eigenschaften auswirken (Koordinaten, Farbe usw.). Beispiel: Wie wird die Position eines herabfallenden Objekts berechnet?

           
            private void ApplyPhysics(GameTime gameTime)
            {
                float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
                if (isFalling)
                {
                    velocity.Y = MathHelper.Clamp(velocity.Y + GravityAcceleration * elapsed, -MaxFallSpeed, MaxFallSpeed);
                    Position += velocity * elapsed;
                }
            }
    


    Nachdem die gesamte Ereignisverarbeitung ausgeführt und die Eigenschaften der Objekte geändert wurden, wird der Moment angezeigt, in dem die Ebene in der Methode angezeigt wird, in der Draw()einfach alle Objekte gezeichnet werden, die sich auf der Ebene befinden:

    
                DrawTiles(spriteBatch);
                foreach (Item item in items)
                    item.Draw(gameTime, spriteBatch);
                foreach (MultipleStateItem item in multipleStateItems)
                    item.Draw(gameTime, spriteBatch);
                foreach (AnimatedItem item in animatedItems)
                    item.Draw(gameTime, spriteBatch);
                foreach (FallingTile FallingTile in FallingTiles)
                    FallingTile.Draw(gameTime, spriteBatch);
                foreach (Exit exit in exits)
                    exit.Draw(gameTime, spriteBatch);
                foreach (Boss boss in bosses)
                    boss.Draw(gameTime, spriteBatch);
    


    Im Allgemeinen sind der Spielcode und seine Logik ziemlich offensichtlich. Nachdem Sie viel Zeit verbracht haben, können Sie herausfinden, wie alles funktioniert.

    Was weiter



    Da der Spielcode im Vergleich zur Originalversion nur geringfügig geändert wurde, um die Kompatibilität mit WinRT und MonoGame sicherzustellen, sind in dieser Anwendung zusätzliche Änderungen erforderlich:

    • Unterstützung für das Speichern des Spielstatus im lokalen Anwendungsspeicher.
    • Subsystem zum Speichern von Dateien. Aus diesem Grund ist der Level-Editor jetzt deaktiviert
    • Unterstützung für Multitouch- und Touch-Steuerung
    • Obligatorische Datenschutzerklärung


    Diese Komponenten werden im nächsten Beitrag berücksichtigt und finalisiert.
    Verknüpfung mit dem Projekt unter Windows 8 und dem Originalspiel - falls Sie die XNB-Dateien (Grafiken und Sounds) ändern möchten.

    Jetzt auch beliebt: