Freitag, 25. Oktober 2013

Das eigentliche Spiel angefangen

Hallo zusammen,

wie der Titel schon sagt, haben Hendrik und ich das eigentliche Spiel angefangen. Es stehen zwar erst ein paar Zeilen Code, aber die funktionieren wenigstens schon ;)

Beginnen tun wir mit dem Hauptmenü, da wir damit dann schon wichtige Klassen ( ScreenManager ( s.u. ), WindowManager ( s.u. ), etc. ) gleich mit einbringen können.
Danach machen wir dann das laden der Map und die einzelnen Menüs ( Einstellungen, Laden, Neues Spiel, etc. ). Hendrik arbeitet während dessen am Hauptmenü selbst. Ich habe soweit schon mal den ScreenManager ( s.u. ) gemacht und hänge mich momentan hinter den WindowManager ( s.u. ).

ScreenManager???
Der ScreenManager sorgt dafür, dass immer passende "Fenster" im Spiel gezeichnet werden. So sorgt er z.B. dafür, dass, wenn man auf "Spiel laden" im Hauptmenü klickt, nicht mehr das Hauptmenü gezeichnet wird, sondern dann der passende Dialog zum laden eines Speicherstandes.
Hier ein Beispiel-Code, wie das ganze funktioniert:
( Achtung, der Code ist unvollständig und somit nicht lauffähig! )


namespace Arengu
{
 public class Arengu : Microsoft.Xna.Framework.Game
 {
  public ScreenManager Screen;
  
  public Arengu()
  {
   Screen = new MainMenu();
   Screen.game = this;
   Screen.graphics = graphics;
   Screen.Content = Content;
  }
  protected override void Initialize()
  {
   Screen.Initialize();
  }
  protected override void LoadContent()
  {
   Screen.spriteBatch = spriteBatch;
   Screen.LoadContent();
  }
  protected override void UnloadContent() { }
  protected override void Update(GameTime gameTime)
  {
   Screen.Update(gameTime);
   base.Update(gameTime);
  }
  protected override void Draw(GameTime gameTime)
  {
   Screen.Draw(gameTime);
   base.Draw(gameTime);
  }
 }
 public class ScreenManager
 {
  public Game game;
  public GraphicsDeviceManager graphics;
  public SpriteBatch spriteBatch;
  public ContentManager Content;
  public int width, height;

  public virtual void Initialize() { }
  public virtual void LoadContent() { }
  public virtual void UnloadContent() { }
  public virtual void Update(GameTime gameTime) { }
  public virtual void Draw(GameTime gameTime) { }
 }
 public class MainMenu : ScreenManager
 {
  public MainMenu() { } // Konstruktor Stuff
  public override void Initialize()
  {
   base.Initialize();
  }
  public override void LoadContent() { } // Lädt benötigte Objekte   
  public override void UnloadContent() { }
  public override void Update(GameTime gameTime) // Abfragen, etc.
  {
   base.Update(gameTime);
  }
  public override void Draw(GameTime gameTime) // Alles zeichnen
  {
   spriteBatch.Begin();
   spriteBatch.End();
  }
 }
}

WindowManager???
Der WindowManager sorgt dafür, dass einzelne Elemente eines Fensters bereitgestellt werden und gezeichnet, sowie abgefragt werden ( auf Tastendruck oder Mausklick ).
Geplante Elemente:
  • Buttons
  • Input-Felder
  • Checkboxen
  • Label
  • Evtl. Listen ( wahrscheinlich erst am Ende )

Das momentane Hauptmenü von Arengu.
Im Hintergrund sieht man eine der
vielen Nebelschwaden, die vorbeifliegen

Eine herunter zu ladende Version wird es dann geben, wenn man die ersten Maps laden kann, was jedoch noch ein wenig dauern könnte. Bis dahin, werde ich euch auf dem laufenden halten, was die Funktionen etc. angeht.

mfg
Hauke

4 Kommentare:

  1. passt, btw wenns dann mal ein bissel weiter ist könnt ihr euch monogame ansehen (-> Quasi XNA-Source Kompatibel, läuft auf Windows Phone, Linux, Mac, Android, (zukünftig PS4) , ...)
    Und wenn ich euch einen Tipp geben darf: welches system ihr auch immer verwendet um sachen zu zeichnen usw, trennt den eigentlichen Spielcode vom Oberflächencode. Wenn ihr das Spiel z.B: mal später auf das WindowsPhone portieren wollt, habt ihr zwar die XNA Klassen wie Vektoren und so, aber die Oberfläche (da andere Auflösung) sowie der Input (Touch ...) ,müssen wohl neu geschrieben werden

    AntwortenLöschen
    Antworten
    1. Monogame kenne ich, habe ich auch schon mit gearbeitet, wenn wir eine lauffähige Version haben, werde ich versuchen das ganze zu portieren. Wenn es jedoch zu viel Arbeit wird, müsstet ihr vorerst darauf verzichten, jedoch versuche ich mein bestes ;)
      Was genau meinst du mit trennen? In verschiedene Klassen/Methoden?
      Wir werden eh alle Zeichen-Sachen variabel machen, sodass auf jeder Auflösung ( auch 731x337 oder so^^ ) alle Sachen ihre richtige Position haben und man somit alles bedienen kann. Wie die Eingabe bei WindowsPhone in Bezug auf XNA ist habe ich noch nicht ausprobiert, vorerst haben wir aber auch nicht vor das ganze für WPhone zu portieren.

      mfg
      Hauke

      Löschen
  2. hey, was mir aufgefallen ist: Die Initialize Methode wird ja nur ein mal aufgerufen, was so ziemlich bedeuted das nur der erste Screen im ganzen Spiel Inizialize aufgerufen bekommt. Was er oben wohl gemeint hat: Einfach in verschiedene Klassen.

    AntwortenLöschen
    Antworten
    1. Ja, das stimmt, aber wenn du einen neuen Screen mittels ScreenManager newScreen = IrgendeinMenu(); erstellst, dann kannst du ja mit newScreen.Initialize(); die Initialize Methode aufrufen. Nur die Erstellung des neuen Screens kann ja irgendwo im Code passieren, lediglich der erste ( halt der Menü-Screen ) wird in der Initialize Methode der Klasse Arengu aufgerufen. Ich muss mal sehn, ob ich die Initialize-Methode nicht weglasse, da ich eh alles in der LoadContent() lade, aber mal sehn, vielleicht brauche ich sie ja noch ...

      mfg
      Hauke

      Löschen