Tutorial 2: Das erste 2D Game: Benötigte Objekte und Variablen

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • Tutorial 2: Das erste 2D Game: Benötigte Objekte und Variablen

      Ich habe für diese tutorials ein Kleines ziel gesetzt: Ein 2D Spiel, man spielt einen zepelin und muss bomben auf ein bewegliches ziehl werfen.

      Fangen wir an:
      Nun Als erstes überlegt man sich das komplette konzept.
      Also der Spieler spielt einen bomber(in meinem fall ein zepelin)
      dieser zepelin wird über die pfeiltasten bewegt und mit leer werden bomben geworfen.
      die bomben sind zu erst ganz einfach und fallen nur in einer konstanten geschwindigkeit.
      Unten drunter auf dem Boden ein ziehl mit leben, dieses ziehl bewegt sich nach rechts und nach links und muss getroffen werden.
      Für den Player und den Gegner erstellen wir eine eigene Klasse oder struktur, da es ziemlich unübersichtlic wird das ganze in die game.cs zu schreiben

      Dann los:
      Wir erstellen ein neues Projekt, ein windows game (4.0)
      das nenne ich mal bomber.
      Wir öffnen die Game.cs, das ist die Klasse für das spiel

      Nun erstellen wir eine neue klasse für die variablen, diese nennen wir Objekte(Projekt->Klasse Hinzufügen und Objekte.cs nennen)

      Da müssen wir noch ein paar namespaces importieren, damit wir XNA verwenden können:

      Quellcode

      1. using Microsoft.Xna.Framework;
      2. using Microsoft.Xna.Framework.Audio;


      Dann löschen wir

      Quellcode

      1. class Objekte
      2. {
      3. }
      da wir das nicht brauchen
      Dann erstellen wir eine player struktur

      Quellcode

      1. public struct Player {
      3. }

      dann ändern wir die Namespace noch von Bomber in Bomber.Objekte um

      Quellcode

      1. namespace Bomber.Objekte
      2. {
      3. public struct Player {
      5. }
      6. }

      und importieren diese in die game.cs

      Quellcode

      1. using Bomber.Objekte;

      nun ist es in der Game.CS möglich variablen vom Typ Player zu erstellen
      (Klassen namen und Struktur namen groß schreiben, und die dazu gehörigen variablen klein)

      Quellcode

      1. public class Game1 : Microsoft.Xna.Framework.Game
      2. {
      3. [COLOR="red"]Player player;[/COLOR]
      4. GraphicsDeviceManager graphics;
      5. SpriteBatch spriteBatch;
      7. public Game1()


      Nun erstellen wir noch die einstellungen die wir für den player brauchen in der Objekte.cs
      Diese einstellungen kommen in die Player Struktur

      Quellcode

      1. /// <summary>
      2. /// Die Leben des Spielers
      3. /// </summary>
      4. public int lives { get; set; }
      5. /// <summary>
      6. /// Die Aktuelle Position als XNA Vector 2D
      7. /// </summary>
      8. public Vector2 pos { get; set; }
      9. /// <summary>
      10. /// Die geschwindigkeit als XNA Vector 2D
      11. /// </summary>
      12. public Vector2 speed { get; set; }
      13. /// <summary>
      14. /// Die Bomben die sich derzeit im spiel befinden
      15. /// </summary>
      16. public List<Bomb> Bombs { get; set; }
      17. /// <summary>
      18. /// Das Bild
      19. /// </summary>
      20. public Texture2D tex { get; set; }
      21. /// <summary>
      22. /// Das Bild der Leben
      23. /// </summary>
      24. public Texture2D liveTex;
      Alles anzeigen

      Ich denke Lives sollte klar sein,

      pos ist die aktuelle position in pixeln, dargestellt durch einen vector2(vergleichbar mit der klasse Point aus System.Drawing) Ein Vector2 kann einen x und einen y wert enthalten.

      Speed ist die geschwindigkeit die angibt um wie viele pixel pro sekunde sich das objekt bewegen soll, Die geschwindigkeit wird seperat als geschindigkeit x und als geschwindigkeit y betrachtet und nicht als allgemeine geschwindigkeit, d.h. wird ein Vector 2 verwendet

      Kamikaze gibt einfach nur an ob die letzte attacke eine Kamikaze(selbstmord) attacke war, sie wird verwendet um den schriftzug Kamikaze einblenden zu lassen

      Bombs ist ein Array der klasse/Struktur bomb, da es diese noch nicht gibt müssen wir die gleich schreiben. über diese variable werden alle bomben im spielfeld gehandelt

      tex ist die textur des Spielers, das Bild was auf den Bildschirm gezeichnet wird

      liveTex ist die textur der leben die auf den Bildschirm gezeichnet wird

      Nun erstellen wir eine Struktur Bomb für die Bomben

      Quellcode

      1. public struct Bomb {
      2. /// <summary>
      3. /// Die Instanz über die Der ExplosionsSound Abgespielt wird
      4. /// (jede bombe muss eine eigne haben, damit es zu keinem overflow kommt)
      5. /// </summary>
      6. public SoundEffectInstance boomInstance { get; set; }
      7. /// <summary>
      8. /// Die Geschwindigkeit
      9. /// </summary>
      10. public Vector2 speed { get; set; }
      11. /// <summary>
      12. /// Die aktuelle position
      13. /// </summary>
      14. public Vector2 pos { get; set; }
      15. /// <summary>
      16. /// Der Damage den die explosion verursacht
      17. /// </summary>
      18. public int damage { get; set; }
      19. /// <summary>
      20. /// Textur
      21. /// </summary>
      22. public Texture2D tex { get; set; }
      23. }
      Alles anzeigen

      Neu ist hier die boomInstance
      Das ist eine Sound instanz, über die der Sound abgespielt wird, um keine abgehackten töne oder overflows zu bekommen bekommt jede bombe ihre eigene instanz, dazu später mehr

      Nun können wir die player struktur kopieren und für den gegner verwenden also als Enemy wieder einfügen.

      Quellcode

      1. /// <summary>
      2. /// Gegner Klasse
      3. /// </summary>
      4. public struct Enemy
      5. {
      6. /// <summary>
      7. /// Die Leben des Gegners
      8. /// </summary>
      9. public int lives { get; set; }
      10. /// <summary>
      11. /// Die Aktuelle Position als XNA Vector 2D
      12. /// </summary>
      13. public Vector2 pos { get; set; }
      14. /// <summary>
      15. /// Die geschwindigkeit als XNA Vector 2D
      16. /// </summary>
      17. public Vector2 speed { get; set; }
      18. /// <summary>
      19. /// Die Bomben die sich derzeit im spiel befinden
      20. /// </summary>
      21. public List<Bomb> Bombs { get; set; }
      22. /// <summary>
      23. /// Das Bild
      24. /// </summary>
      25. public Texture2D tex { get; set; }
      26. /// <summary>
      27. /// Das Bild der Leben
      28. /// </summary>
      29. public Texture2D liveTex;
      30. }
      Alles anzeigen


      Eine Enemy Variable fügen wir auch in der Game.cs hinzu

      Quellcode

      1. Player player;
      2. [COLOR="red"]Enemy enemy;[/COLOR]
      3. GraphicsDeviceManager graphics;
      4. SpriteBatch spriteBatch;


      Was noch fehlt sind die allgemeinen variablen

      Quellcode

      1. public struct GameEnvironment {
      2. /// <summary>
      3. /// Hintergrund Musik
      4. /// </summary>
      5. public SoundEffect bgMusic { get; set; }
      6. /// <summary>
      7. /// Hintergrund Musik Instance
      8. /// </summary>
      9. public SoundEffectInstance bgMusicInstance { get; set; }
      10. /// <summary>
      11. /// Ob das Menü offen ist
      12. /// </summary>
      13. public bool isMenu { get; set; }
      14. /// <summary>
      15. /// Ob das Spiel Gewonnen ist
      16. /// </summary>
      17. public bool won { get; set; }
      18. /// <summary>
      19. /// Ob das Spiel Verloren ist
      20. /// </summary>
      21. public bool lost { get; set; }
      22. /// <summary>
      23. /// Die Hintergrund Farbe
      24. /// </summary>
      25. public Color bgColor { get; set; }
      26. /// <summary>
      27. /// Das bild des mauszeigers
      28. /// </summary>
      29. public Texture2D cursorTex { get; set; }
      30. /// <summary>
      31. /// die position des Mauscursors
      32. /// </summary>
      33. public Vector2 mousePos { get; set; }
      34. /// <summary>
      35. /// Die Breite
      36. /// </summary>
      37. public int windowWidth { get; set; }
      38. /// <summary>
      39. /// Die Höhe
      40. /// </summary>
      41. public int windowHeight { get; set; }
      42. }
      Alles anzeigen

      Da meine hintergrund musik als WAV vorlieg muss ein soundeffect verwendet werden

      Jetzt fehlt noch in der Game.cs die variable dafür

      Quellcode

      1. Player player;
      2. Enemy enemy;
      3. [COLOR="red"]GameEnvironment environment;[/COLOR]
      4. GraphicsDeviceManager graphics;
      5. SpriteBatch spriteBatch;




      Texturen und Sounds Laden:

      Mit XNA kann man über das Content system verschiedene formate in die xna formate importieren, ein sehr großer vorteil...
      Nun müssen die benötigten Texturen und Sounds in diese Content Pipline geladen werden:

      Das rote ist der Content.

      Auf den macht ihr jetzt rechtskick-> Hinzufügen->Vorhandenes Element hinzufügen und wählt die objekte aus
      Ich verwende folgende objekte: Sound für bomben explosion:
      Big Bomb Sounds | Effects | Sound Bites | Sound Clips from SoundBible.com
      Sound für laser(gegner waffe)
      Horror / SciFi / Magic: Download Laser sound effects
      (der 2te)

      Die folgenden habe ich schnell mit gimp hingeklatscht
      Die Bombe:

      Der Cursor:

      Die Lebensleiste des Gegners:

      Die Lebensleiste des Spielers

      Und der zepelin den der spieler spielt


      Als gegner könnt ihr was immer ihr wollt nehmen, größe bei mir ist 100px x 150px

      Klickt ihr diese Dateien im Projekt Mappen Explorer jetzt an so ist da eine Zeile Asset Name, über diesen wert werden später die Inhalte aufgerufen.

      So das war es erst mal für dieses tutorial, Beim nächsten wird gezeichnet

    • Werbung zur Unterstützung des Forums ( Bitte AddBlocker deaktivieren )

    • Erstmal, schon besser, wie das Tutorial im Vergleich zum anderen aussieht.
      Ich werde wohl später auch noch eins veröffentlichen, aber nicht in direkter Konkurrenz zu dir, hatte eig schon lange eins vor.
      Allerdings verstehe ich nicht wirklich, wieso du alles als Struktur implementierst.
      Die ganzen Objekte als Klasse zu nutzen wäre doch eigentlich mehr von Vorteil, da du so Update/Draw-Methoden einbauen kannst und diese am Ende nurnoch aufrufen musst.
      Außerdem wäre ich eher noch etwas mehr auf Grundlagen eingegangen sowie auf ein paar andere Dinge, zB wozu dient jedes Objekt genau, wie dieses GameEnvironment
      In Verbindung mit WAV und SoundEffect könntest du außerdem auf XACT eingehen, das ist bei sowas immer nützlich.
      Es wäre auch von Vorteil, bestimmte Dinge zu erklären, zB was ein Vector ist usw.
      Ansonsten mach mal weiter, ich seh ja, was noch draus wird.

    • Stimme da meinen lieben Internetfreak voll und ganz zu.
      Das Tutorial ist viel besser als vorherige. Auserdem etwas übersichtlicher.
      Was mich wunder ist, wiso du überall ein <summary></summary> gemacht hast.
      für ein Tutorial reicht doch ein ganz einfaches // Kommentar. Den ein summary bringt
      meistens viele Anfänger durcheinander, da es für sie dan komplezierter aussieht.

      Aufjedenfall ist es gut geworden das Tutorial.
      Das nächste mal erklärst du vll was Vector ist etc.

      Ich selber würde ja auch gerne ein paar kleine Tutorials dazu schreiben.
      Habe aber jetzt da ich mit XNA ein RPG Spiel Programmiere keine Zeit mehr.

      Mach aber weiter so!!

    • @Jok3r
      Er benutzt halt eben die XML-Kommentare^^

      @ichbinniemand
      Ich würde dir bei sowas trotzdem auch empfehlen, evtl doch auf Klassen umzusteigen, weils bei nem Spiel einfach sinn macht, die Sachen als Klasse einzubauen, falls du irgendwann mal einige Objekte gleichen Typs hast is das viel besser, wenn du nur pro Objekt eine Methode aufrufen musst statt das Update praktisch so vorzunehmen.
      Außerdem könnte es evtl ein kleines Problem geben, was die Lebenleiste angeht, XNA resized automatisch, zumindest unter verwendung eines Rechtecks.
      Du musst aber ja eig die Lebensleiste stück für Stück ausblenden.
      Daher wäre es gut, wenn du da evtl im nächsten Tut drauf eingehst, denn ich wüsste so jetzt auch keinen Ansatz für, das zu bewerksteilligen.
      Evtl weiß ichs schon, aber es fällt mir zumindest nichts ein atm.

    • Hallo Leute,
      ich bin neu beim Programmieren mit Xna, und suche deshalb gute Tutorials zum lernen. Und bei Google bin ich hierher gestoßen. Ich habe ein paar Sachen dazu zu sagen:
      1. Das nicht jede kleine Einzelheit beschrieben wurde, macht es für mich etwas einfacher, da ich schon einige Tuts durchgearbeitet habe, und 30 mal zu hören, was z.b. Vector2 bedeutet , kann irgendwan nerven...
      2. Finde ich die Idee, mit deiner Struktur zu arbeiten nicht schlimm, denn selbst wenn es nicht die beste Lösung ist, so kann es auch eine akzeptable Lösung sein, denn es gibt nicht die perfekte Lösung, und jeder weg hat seine Vorteile.
      3. Wenn du doch ne Struktur nutzt, warum willst du 2 Strukturen mit dem selben Inhalt erstellen, wenn du doch einfach eine Struktur mit verschiedenen Variablen erzeugst, kommt es doch auf das selbe hinaus...

      So das wars erstmal zu diesem Tut, doch ich habe noch andere Fragen, denn da ich gerade mit Xna angefangen habe, bräuchte ich mal tipps wie ich das am besten lernen und vertiefen kann... also an Programmierkenntnissen fehlt es mir nicht, da ich bereits ein halbes Jahr programmiere und somit muss nicht jede Kleinigkeit beschrieben werden.( ich kann c++, c#, und vb.net)


      Danke schonmal für die Antworten,
      M.f.G.
      Christian

    • zu 3: das stimmt schon aber da ist 1 sache mehr(das wäre auch eigentlich kein grund) aber vor allem für anfänger ist das wegen den 2 verschiedenen namen so leichter

      So das wars erstmal zu diesem Tut, doch ich habe noch andere Fragen, denn da ich gerade mit Xna angefangen habe, bräuchte ich mal tipps wie ich das am besten lernen und vertiefen kann...

      wie du am besten lernst, mit buch oder mit google oder sonst wie, liegt rein an dir

      also an Programmierkenntnissen fehlt es mir nicht, da ich bereits ein halbes Jahr programmiere und somit muss nicht jede Kleinigkeit beschrieben werden.( ich kann c++, c#, und vb.net)

      da stellt sich mir die frage: Wie zum teufel wisst du nach einem halben jahr .Net und CPP können? (.Net sage ich da vom befehlssatz sind C# und VB fast gleich, und ein wechseln benötigt normalerweise keine komplette umschulung)