spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C#-Quelltext

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace SpaceJump_N_Run
{
    /// <summary>
    /// Dies ist der Haupttyp für Ihr Spiel
    /// </summary>
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        // Player Sprite
        // Variable für das Player Sprite 
        Texture2D playerTexture;
        // Startposition des Player Sprite
        Vector2 playerPos;
        // Animation des PlayerSprite
        // Das Sprite Sheet besteht aus 3 Spalten und 1 Zeile
        Point playerSheetSize = new Point(3,1);
        // Die Größe jedes Sprite auf dem Sprite Sheet ist 200 (Höhe) und 80 (Breite)
        Point playerSize = new Point (200,80);
        // Die Animation wird mit dem ersten Sprite gestartet
        Point currentSprite = new Point(0, 0);
        // Kollisionspuffer
        int playerCollison = 15;
        // Bewegeungsgeschwindigkeit des Player Sprite
        const float playerSpeed = 6;

        
        bool playerTreffer = false;

        // Gegner Sprite
        // Variable für das Gegner Sprite
        Texture2D enemyTexture;
        // Startposition des Gegner Sprite
        List<Vector2> enemyPos = new List<Vector2>();
        float enemySpawnProbability = 0.02f;
        // Bewegungsgeschwindigkeit des Enemy Sprite
        const int enemySpeed = 5;

        // Random Variable für das Erscheinen der Gegner
        Random random = new Random();

        // Hintergrund Sprite
        Texture2D bgTexture;
        Vector2 bgPos = new Vector2(0, 0);

        // Anpassung der Animationsgeschwindigkeit
        int timeSinceLastFrame = 0;
        int millisecondsPerFrame = 80;

        // Sound
        bool play = false;
        // Hintergrundmusik
        Song hintergrundMusik;
        // Sound-Effekt
        SoundEffect treffer;

        // Gamestates
        // Gamestate Variable mit mit Enumeration
        enum GameState { Start, Spiel, Ende }
        // Erster GameState
        GameState aktuellerGameState = GameState.Start;
        // Gamestate Variablen für die Darstellung der Textur
        // Gamestate Start
        Texture2D gameStateStart;
        // Gamestate Ende
        Texture2D gameStateEnde;
                      

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";

            graphics.PreferredBackBufferWidth = 1024;
            graphics.PreferredBackBufferHeight = 768;

            

        }

        /// <summary>
        /// Ermöglicht dem Spiel die Durchführung einer Initialisierung, die es benötigt, bevor es ausgeführt werden kann.
        /// Dort kann es erforderliche Dienste abfragen und nicht mit der Grafik
        /// verbundenen Content laden.  Bei Aufruf von base.Initialize werden alle Komponenten aufgezählt
        /// sowie initialisiert.
        /// </summary>
        protected override void Initialize()
        {
            // TODO: Fügen Sie Ihre Initialisierungslogik hier hinzu

            // Es wird eine Instanz der Position des Player Sprite erstellt.
            playerPos = new Vector2(GraphicsDevice.Viewport.X, GraphicsDevice.Viewport.Y + (GraphicsDevice.Viewport.Height / 2));
           
            base.Initialize();
        }

        /// <summary>
        /// LoadContent wird einmal pro Spiel aufgerufen und ist der Platz, wo
        /// Ihr gesamter Content geladen wird.
        /// </summary>
        protected override void LoadContent()
        {
            // Erstellen Sie einen neuen SpriteBatch, der zum Zeichnen von Texturen verwendet werden kann.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            // TODO: Verwenden Sie this.Content, um Ihren Spiel-Content hier zu laden

            // GameStates werden geladen
            gameStateStart = Content.Load<Texture2D>("GameStateStart");
            gameStateEnde = Content.Load<Texture2D>("GameStateEnde");
            
            // Das Player Sprite wird geladen
            playerTexture = Content.Load<Texture2D>("player");

            // Das Gegner Sprite wird geladen
            enemyTexture = Content.Load<Texture2D>("enemy");

            // Der Hintergrund wird geladen
            bgTexture = Content.Load<Texture2D>("background");

            // Der Soundeffekt wird geladen
            treffer = Content.Load<SoundEffect>("explosion");

            // Die Hintergrundmusik wird geladen
            hintergrundMusik = Content.Load<Song>("megaman");
            MediaPlayer.Play(hintergrundMusik);
        }

        /// <summary>
        /// UnloadContent wird einmal pro Spiel aufgerufen und ist der Ort, wo
        /// Ihr gesamter Content entladen wird.
        /// </summary>
        protected override void UnloadContent()
        {
            // TODO: Entladen Sie jeglichen Nicht-ContentManager-Content hier
        }

        /// <summary>
        /// Ermöglicht dem Spiel die Ausführung der Logik, wie zum Beispiel Aktualisierung der Welt,
        /// Überprüfung auf Kollisionen, Erfassung von Eingaben und Abspielen von Ton.
        /// </summary>
        /// <param name="gameTime">Bietet einen Schnappschuss der Timing-Werte.</param>
        protected override void Update(GameTime gameTime)
        {
            // Ermöglicht ein Beenden des Spiels
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            // TODO: Fügen Sie Ihre Aktualisierungslogik hier hinzu

            // GameStates
            
            switch (aktuellerGameState)
            { 
                case GameState.Start:
                    if (GamePad.GetState(PlayerIndex.One).Buttons.Start == ButtonState.Pressed)
                    {
                        aktuellerGameState = GameState.Spiel;
                    }
                    break;
                case GameState.Spiel:
                    if (Keyboard.GetState().IsKeyDown(Keys.Escape))
                    {
                        this.Exit();
                    }                           
                    break;

                case GameState.Ende:
                    if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                    {
                        this.Exit();
                    }
                    break;
            }


            switch (aktuellerGameState)
            {
                case GameState.Start:
                    if (Keyboard.GetState().IsKeyDown(Keys.S))
                    {
                        aktuellerGameState = GameState.Spiel;
                    }
                    break;
                case GameState.Spiel:
                    if (Keyboard.GetState().IsKeyDown(Keys.Escape))
                    {
                        this.Exit();
                    }
                    break;

                case GameState.Ende:
                    if (Keyboard.GetState().IsKeyDown(Keys.Escape))
                    {
                        this.Exit();
                    }
                    break;
            }
 
 

            // Das Player Sprite mit der Tastatur bewegen
            KeyboardState keyboardState = Keyboard.GetState();
            if (keyboardState.IsKeyDown(Keys.Left))
                playerPos.X -= playerSpeed;
            if (keyboardState.IsKeyDown(Keys.Right))
                playerPos.X += playerSpeed;
            if (keyboardState.IsKeyDown(Keys.Up))
                playerPos.Y -= playerSpeed;
            if (keyboardState.IsKeyDown(Keys.Down))
                playerPos.Y += playerSpeed;

            // Mit dem Gamepad bewegen
            GamePadState gamepadState = GamePad.GetState(PlayerIndex.One);
            playerPos.X += playerSpeed * gamepadState.ThumbSticks.Left.X;
            playerPos.Y -= playerSpeed * gamepadState.ThumbSticks.Left.Y;



            // Die Animationsgeschwindigkeit wird angepasst.
            timeSinceLastFrame += gameTime.ElapsedGameTime.Milliseconds;
            if (timeSinceLastFrame > millisecondsPerFrame)
            {
                timeSinceLastFrame -= millisecondsPerFrame;

                // Das Player Sprite Sheet wird animiert.
                ++currentSprite.X;
                if (currentSprite.X >= playerSheetSize.X)
                {
                    currentSprite.X = 0;

                    ++currentSprite.Y;
                    if (currentSprite.Y >= playerSheetSize.Y)
                        currentSprite.Y = 0;
                }
            }

            // Gegner werden gespawned
            if (random.NextDouble() < enemySpawnProbability)
            {
                float x = (float)random.NextDouble() *
                    (Window.ClientBounds.Height - enemyTexture.Height);
                enemyPos.Add(new Vector2(Window.ClientBounds.Width, x));
            }


            // Bounding Box Player
            Rectangle playerBB =
                new Rectangle((int)playerPos.X + playerCollison, (int)playerPos.Y + playerCollison,
                playerSize.X - (playerCollison *2), playerSize.Y - (playerCollison * 2));

            playerTreffer = false;
            for (int i = 0; i < enemyPos.Count; i++)
            {
                // Gegner kommt von Rechts nach Links
                enemyPos[i] =
                    new Vector2(enemyPos[i].X - enemySpeed,
                                enemyPos[i].Y);

                // Bounding Box Gegner
                Rectangle enemyBB =
                    new Rectangle((int)enemyPos[i].X, (int)enemyPos[i].Y,
                    enemyTexture.Width, enemyTexture.Height);

                // Kollisionsabfrage
                if (playerBB.Intersects(enemyBB))
                    playerTreffer = true;

                // Gegner verschwinden wenn ausserhalb des Spielfensters
                if (enemyPos[i].X > Window.ClientBounds.Width)
                {
                    enemyPos.RemoveAt(i);
                                        
                    i--;
                }
            }


            if (playerTreffer)
            {
                if (!play)
                {
                    treffer.Play();
                    play = true;
                    
                    aktuellerGameState = GameState.Ende;   
                                                                                     
                }
                
            }
            else if (play)
            {
                play = false;
            }
          

            base.Update(gameTime);
        }

        /// <summary>
        /// Dies wird aufgerufen, wenn das Spiel selbst zeichnen soll.
        /// </summary>
        /// <param name="gameTime">Bietet einen Schnappschuss der Timing-Werte.</param>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.Black);

            // TODO: Fügen Sie Ihren Zeichnungscode hier hinzu

            

            switch (aktuellerGameState)
            {
                case GameState.Start:

                    GraphicsDevice.Clear(Color.Black);
                    spriteBatch.Begin();
                    spriteBatch.Draw(gameStateStart, Vector2.Zero, Color.White);
                    spriteBatch.End();

                    break;

                case GameState.Spiel:

                    GraphicsDevice.Clear(Color.Black);
                    spriteBatch.Begin(SpriteSortMode.FrontToBack, BlendState.AlphaBlend);
                    // Die Sprites zeichnen
                    // Den Hintergrund zeichnen
                    spriteBatch.Draw(bgTexture, bgPos, null, Color.White, 0, Vector2.Zero, 1, SpriteEffects.None, 0);
                    // Das Player Sprite zeichnen
                    spriteBatch.Draw(playerTexture, playerPos, new Rectangle(currentSprite.X * playerSize.X, currentSprite.Y * playerSize.Y, playerSize.X, playerSize.Y),
                    Color.White, 0, Vector2.Zero, 1, SpriteEffects.None, 1);
                    // Das Gegner Sprite zeichnen
                    foreach (Vector2 enemyPositions in enemyPos)
                        spriteBatch.Draw(enemyTexture, enemyPositions, null, Color.White, 0, Vector2.Zero, 1, SpriteEffects.None, 1);
                    spriteBatch.End();

                    break;

                case GameState.Ende:

                    GraphicsDevice.Clear(Color.Black);
                    spriteBatch.Begin();
                    spriteBatch.Draw(gameStateEnde, Vector2.Zero, Color.White);
                    spriteBatch.End();

                    break;
            }
                              

            base.Draw(gameTime);
        }
    }
}