Programmieren von Spielen in C # mit SDL.NET Tutorial One

Eines der Probleme mit Open Source ist, dass Projekte manchmal auf der Strecke bleiben oder verwirrende Wendungen nehmen. Nehmen Sie SDL.NET. Wenn man die zum Verkauf stehende Website ignoriert, zeigt eine Suche im Internet, dass cs-sdl.sourceforge.net ein Projekt ist, das anscheinend im November 2010 gestoppt wurde.

Wenn Sie C # nicht kennen, müssen Sie zunächst lernen, wie man in C # programmiert. Woanders stießen wir auf das auf der Mono-Website verlinkte Tao-Framework, das anscheinend denselben Bereich abdeckt und Unterstützung für Sound usw. hinzufügt. Bei SourceForge (wieder!) Wurde es von OpenTK abgelöst, aber der Fokus liegt dort auf OpenGL. Es enthält jedoch auch OpenAL, so dass die Installation der beiden (cs-sdl und OpenTK) der richtige Weg zu sein schien.

Ein Teil der OpenTk-Installation ist fehlgeschlagen. der NS (Shader) weil wir kein VS 2008 installiert haben! Der Rest war jedoch in Ordnung. Wir haben ein C # -Konsolenprojekt erstellt und begonnen, mit SDL.NET zu spielen. Die Online-Dokumentation finden Sie hier.

Rückblickend können wir feststellen, dass das OpenTK-Framework als solches nicht benötigt wurde, dass SDL.NET alles installiert hat, aber das war zu diesem Zeitpunkt nicht klar. Es verwendet immer noch das Tao Framework, obwohl dessen Entwicklung von OpenTK abgelöst wurde. Es ist etwas verwirrend und wir hoffen, dass das SDL.NET-Team in Zukunft eine OpenTk-kompatible Version herausbringen wird.

Was genau ist SDL.NET?

Wie wir dachten, handelt es sich nicht nur um einen dünnen Wrapper für SDL, sondern um eine erhebliche zusätzliche Funktionalität. Es gibt eine Reihe von Klassen, um Folgendes bereitzustellen:

• Timer
• Bietet Sprites, einschließlich Animation und Text
• Bietet Oberflächen für 2D und OpenGl
• Bietet Unterstützung für das Laden und Abspielen von Filmen
• Bietet Unterstützung für Audio
• Bietet Bezier-, Polygon- (und Textur-), Quadrat-, Kreis-, Linien- und Kreiszeichnung
• Bietet Partikelunterstützung mit Emittern, Sprites und Manipulatoren.
• Bietet eine Schnittstelle zu Windows-Formularen über eine gemeinsam genutzte PictureBox mit Oberfläche.

Vorbereitungen

Es gibt verschiedene Dinge, die Sie tun müssen, um es einzurichten. Hier sind sie:

Suchen Sie die beiden SDL.NET-DLLs (SdlDotNet.dll und Tao.Sdl.dll) sowie die OpenTK-DLLs, und fügen Sie sie den Projektreferenzen hinzu. Nach der Installation befinden sich die DLLs unter Programme \ SdlDotNet \ bin (unter 32-Bit-Windows und Programme (x86) \ SdlDotNet \ bin unter 64-Bit-Windows). Klicken Sie mit der rechten Maustaste auf den Abschnitt Verweise im Projektmappen-Explorer, und wählen Sie Verweis hinzufügen aus Klicken Sie auf die Registerkarte Durchsuchen, um einen Explorer-Dialog zu öffnen, und wählen Sie dann nach dem Auffinden der DLLs OK aus.

SDL.NET verwendet die SDL-DLLs und installiert sie im Ordner lib. Lösche sie nicht!

Klicken Sie zum Schluss auf Ansicht \ Eigenschaften, um die Eigenschaftenseiten zu öffnen, und klicken Sie auf die erste Registerkarte (Anwendung). Ändern Sie den Ausgabetyp von Konsolenanwendung in Windows-Anwendung. Wenn Sie dies nicht tun, wenn das Programm zum ersten Mal ausgeführt und das SDL-Hauptfenster geöffnet wird, wird auch ein Konsolenfenster geöffnet.

Wir sind jetzt bereit zu beginnen und ich habe eine kurze Anwendung unten erstellt. Dadurch werden Rechtecke und Kreise in zufälliger Größe mit 1.700 Bildern pro Sekunde und einer Bildrate von 50 Bildern pro Sekunde auf der Fensteroberfläche platziert.

Diese 1.700 ergeben sich aus der Einstellung der pro Bild gezogenen Zahl auf 17 und der Anzeige der Bilder pro Sekunde in der Fenstertitel mit Video.WindowCaption. Jeder Rahmen zeichnet 17 gefüllte Kreise und Rechtecke, 17 x 2 x 50 = 1.700. Diese Zahl hängt von der Grafikkarte, der CPU usw. ab. Es ist eine beeindruckende Geschwindigkeit.

// Von David Bolton, http://cplus.about.com
using System;
using System.Drawing;
using SdlDotNet.Graphics;
using SdlDotNet.Core;
using SdlDotNet.Graphics.Primitives;
public class ex1

private const int wwidth = 1024;
private const int wheight = 768;
privater statischer Oberflächenschirm;
private static Random r = new Random ();
public static void Main (string [] args)

Screen = Video.SetVideoMode (wwidth, wheight, 32, false, false, false, true);
Events.TargetFps = 50;
Events.Quit + = (QuitEventHandler);
Events.Tick + = (TickEventHandler);
Events.Run ();

private static void QuitEventHandler (Objektabsender, QuitEventArgs-Argumente)

Events.QuitApplication ();

private static void TickEventHandler (Objektabsender, TickEventArgs-Argumente)

für (var i = 0; i < 17; i++)

var rect = new Rectangle (neuer Punkt (r.Next (Breite-100), r.Next (Höhe-100)),
neue Größe (10 + r.Next (Breite - 90), 10 + r.Next (Höhe - 90));
var Col = Color.FromArgb (r.Next (255), r.Next (255), r.Next (255));
var CircCol = Color.FromArgb (r.Next (255), r.Next (255), r.Next (255));
kurzer Radius = (kurz) (10 + r.Next (wheight - 90));
var Circ = neuer Kreis (neuer Punkt (r.Next (Breite-100), r.Next (Höhe-100)), Radius);
Screen.Fill (rect, Col);
Circ.Draw (Screen, CircCol, false, true);
Screen.Update ();
Video.WindowCaption = Events.Fps.ToString ();

Objektorientierte Entwicklung

SDL.NET ist sehr objektorientiert und es gibt zwei vordefinierte Objekte, die in jeder SDL.NET-Anwendung verwendet werden.

Video bietet Methoden zum Festlegen des Videomodus, Erstellen von Videooberflächen, Ausblenden und Anzeigen des Mauszeigers und Interagieren mit OpenGL. Nicht, dass wir noch eine Weile OpenGL machen würden.

Die Events-Klasse enthält Ereignisse, die angehängt werden können, um Benutzereingaben und andere verschiedene Ereignisse zu lesen.

Hier wird das Video-Objekt verwendet, um die Größe und Auflösung des Spielfensters festzulegen (Vollbild ist eine Option). Mit den Parametern für SetVideoMode können Sie diese ändern, und 13 Überladungen sorgen für Abwechslung. Im doc-Ordner befindet sich eine CHM-Datei (Windows-HTML-Hilfeformat), in der alle Klassen und Mitglieder dokumentiert sind.

Das Events-Objekt verfügt über einen Quit-Ereignishandler, mit dem Sie eine Beendigungslogik hinzufügen können, und Sie sollten Events.QuitApplication () aufrufen, damit es auf den Benutzer reagiert, der die Anwendung schließt. Der Events.Tick ist möglicherweise der wichtigste Event-Handler. Es ruft den angegebenen Ereignishandler für jeden Frame auf. Dies ist das Modell für alle SDL.NET-Entwicklungen.

Sie können Ihre gewünschte Bildrate einstellen und die Schleife auf 5 reduzieren und die Zielgeschwindigkeit auf 150 ändern. Wir haben sie mit 164 Bildern pro Sekunde laufen lassen. TargetFps ist eine Baseballfigur. Es kommt zu Verzögerungen, um Sie an diese Zahl heranzuführen, aber Events.Fps wird bereitgestellt.

Oberflächen

Wie die ursprüngliche Nicht-Windows-Version von SDL verwendet SDL.NET Oberflächen zum Rendern auf dem Bildschirm. Eine Oberfläche kann aus einer Grafikdatei erstellt werden. Es gibt eine große Anzahl von Eigenschaften und Methoden, die es ermöglichen, Pixel zu lesen oder zu schreiben sowie die Grafikprimitive zu zeichnen, andere Oberflächen zu glätten und sogar eine Oberfläche auf eine Festplattendatei zu kopieren, um Screenshots aufzunehmen.

SDL> NET bietet nahezu alles, was Sie zum Erstellen von Spielen benötigen. In den nächsten Tutorials werden wir uns die verschiedenen Funktionen ansehen und dann damit Spiele erstellen.