99/12/24 飛機打飛機(由BG 3D改的)

飛機打飛機
-------------------------------------------------------------------------------------------------------------
using System;
using System.Collections.Generic;
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.Net;
using Microsoft.Xna.Framework.Storage;
namespace BG_3D
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        GameObject terrain = new GameObject();
        GameObject missileLauncherBase = new GameObject();
        GameObject missileLauncherHead = new GameObject();
        const int numMissiles = 200;
        GameObject[] missiles;
        GamePadState previousState;
#if !XBOX
        KeyboardState previousKeyboardState;
#endif
        const float launcherHeadMuzzleOffset = 20.0f;
        const float missilePower = 20.0f;
        AudioEngine audioEngine;
        SoundBank soundBank;
        WaveBank waveBank;
        Random r = new Random();
        const int numEnemyShips = 1;
        GameObject[] enemyShips;
        Vector3 shipMinPosition = new Vector3(-2000.0f, 300.0f, -4000.0f);
        Vector3 shipMaxPosition = new Vector3(2000.0f, 800.0f, -6000.0f);
        /*
        Vector3 shipMinPosition = new Vector3(-2000.0f, 300.0f, -6000.0f);
        Vector3 shipMaxPosition = new Vector3(2000.0f, 800.0f, -4000.0f);
        */
        const float shipMinVelocity = 5.0f;
        const float shipMaxVelocity = 10.0f;
        Vector3 cameraPosition = new Vector3(0.0f, 60.0f, 160.0f);
        Vector3 cameraLookAt = new Vector3(0.0f, 50.0f, 0.0f);
        Matrix cameraProjectionMatrix;
        Matrix cameraViewMatrix;
        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }
        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here
            base.Initialize();
        }
        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);
            audioEngine = new AudioEngine("Content\\Audio\\TutorialAudio.xgs");
            waveBank = new WaveBank(audioEngine, "Content\\Audio\\Wave Bank.xwb");
            soundBank = new SoundBank(audioEngine, "Content\\Audio\\Sound Bank.xsb");
            cameraViewMatrix = Matrix.CreateLookAt(
                cameraPosition,
                cameraLookAt,
                Vector3.Up);
            cameraProjectionMatrix = Matrix.CreatePerspectiveFieldOfView(
                MathHelper.ToRadians(45.0f),
                graphics.GraphicsDevice.Viewport.AspectRatio,
                1.0f,
                10000.0f);
            terrain.model = Content.Load<Model>(
                "Models\\terrain");
            missileLauncherBase.model = Content.Load<Model>(
                "Models\\launcher_base");
            missileLauncherBase.scale = 0.0000002f;/*missileLauncherBase.scale = 0.2f;*/
            missileLauncherHead.model = Content.Load<Model>(
                "Models\\p1_wedge");
            missileLauncherHead.scale = 0.02f;
            missileLauncherHead.position = missileLauncherBase.position +
                new Vector3(0.0f, 20.0f, 0.0f);
            missiles = new GameObject[numMissiles];
            for (int i = 0; i < numMissiles; i++)
            {
                missiles[i] = new GameObject();
                missiles[i].model =
                    Content.Load<Model>("Models\\missile");
                missiles[i].scale = 3.0f;
            }
            enemyShips = new GameObject[numEnemyShips];
            for (int i = 0; i < numEnemyShips; i++)
            {
                enemyShips[i] = new GameObject();
                enemyShips[i].model = Content.Load<Model>(
                    "Models\\p1_wedge");
                enemyShips[i].scale = 0.1f;
                enemyShips[i].rotation = new Vector3(
                    -600.0f, MathHelper.Pi, 600.0f);
                /*enemyShips[i].rotation = new Vector3(
                    0.0f, MathHelper.Pi, 0.0f);*/
            }
            // TODO: use this.Content to load your game content here
        }
        /// <summary>
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        /// </summary>
        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }
        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();
            GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);
            missileLauncherHead.rotation.Y -=
                gamePadState.ThumbSticks.Left.X * 0.1f;
            missileLauncherHead.rotation.X +=
                gamePadState.ThumbSticks.Left.Y * 0.1f;
#if !XBOX
            KeyboardState keyboardState = Keyboard.GetState();
            if(keyboardState.IsKeyDown(Keys.Left))
            {
                missileLauncherHead.rotation.Y += 0.05f;
            }
            if(keyboardState.IsKeyDown(Keys.Right))
            {
                missileLauncherHead.rotation.Y -= 0.05f;
            }
            if(keyboardState.IsKeyDown(Keys.Up))
            {
                missileLauncherHead.rotation.X += 0.05f;
            }
            if(keyboardState.IsKeyDown(Keys.Down))
            {
                missileLauncherHead.rotation.X -= 0.05f;
            }
#endif
            missileLauncherHead.rotation.Y = MathHelper.Clamp(
                missileLauncherHead.rotation.Y,
                -MathHelper.PiOver4, MathHelper.PiOver4);
            missileLauncherHead.rotation.X = MathHelper.Clamp(
                missileLauncherHead.rotation.X,
                0, MathHelper.PiOver4);
            if (gamePadState.Buttons.A == ButtonState.Pressed &&
                previousState.Buttons.A == ButtonState.Released)
            {
                FireMissile();
            }
#if !XBOX
            if(keyboardState.IsKeyDown(Keys.Space) &&
                previousKeyboardState.IsKeyUp(Keys.Space))
            {
                FireMissile();
            }
#endif
            UpdateMissiles();
            audioEngine.Update();
            UpdateEnemyShips();
            previousState = gamePadState;
#if !XBOX
            previousKeyboardState = keyboardState;
#endif
            // TODO: Add your update logic here
            base.Update(gameTime);
        }
        void FireMissile()
        {
            foreach (GameObject missile in missiles)
            {
                if (!missile.alive)
                {
                    soundBank.PlayCue("missilelaunch");
                    missile.velocity = GetMissileMuzzleVelocity();
                    missile.position = GetMissileMuzzlePosition();
                    missile.rotation = missileLauncherHead.rotation;
                    missile.alive = true;
                    break;
                }
            }
        }
        Vector3 GetMissileMuzzleVelocity()
        {
            Matrix rotationMatrix =
                Matrix.CreateFromYawPitchRoll(
                missileLauncherHead.rotation.Y,
                missileLauncherHead.rotation.X,
                0);
            return Vector3.Normalize(
                Vector3.Transform(Vector3.Forward,
                rotationMatrix)) * missilePower;
        }
        Vector3 GetMissileMuzzlePosition()
        {
            return missileLauncherHead.position +
                (Vector3.Normalize(
                GetMissileMuzzleVelocity()) *
                launcherHeadMuzzleOffset);
        }
        void UpdateMissiles()
        {
            foreach (GameObject missile in missiles)
            {
                if (missile.alive)
                {
                    missile.position += missile.velocity;
                    if (missile.position.Z < -6000.0f)
                    {
                        missile.alive = false;
                    }
                    else
                    {
                        TestCollision(missile);
                    }
                }
            }
        }
        void UpdateEnemyShips()
        {
            foreach (GameObject ship in enemyShips)
            {
                if (ship.alive)
                {
                    ship.position -= ship.velocity;
                    if (ship.position.Z < -5000.0f)/*if (ship.position.Z > 500.0f)*/
                    {
                        ship.alive = false;
                    }
                }
                else
                {
                    ship.alive = true;
                    ship.position = new Vector3(
                        MathHelper.Lerp(
                        shipMinPosition.X,
                        shipMaxPosition.X,
                        (float)r.NextDouble()),
                        MathHelper.Lerp(
                        shipMinPosition.Y,
                        shipMaxPosition.Y,
                        (float)r.NextDouble()),
                        MathHelper.Lerp(
                        shipMinPosition.Z,
                        shipMaxPosition.Z,
                        (float)r.NextDouble()));
                        ship.velocity = new Vector3(
                        0.0f,
                        5.0f,
                        MathHelper.Lerp(shipMinVelocity,
                        shipMaxVelocity, (float)r.NextDouble()));
                    /*ship.velocity = new Vector3(
                        0.0f,
                        0.0f,
                        MathHelper.Lerp(shipMinVelocity,
                        shipMaxVelocity, (float)r.NextDouble()));
                     */
              }
            }
        }
        void TestCollision(GameObject missile)
        {
            BoundingSphere missilesphere =
                missile.model.Meshes[0].BoundingSphere;
            missilesphere.Center = missile.position;
            missilesphere.Radius *= missile.scale;
            foreach (GameObject ship in enemyShips)
            {
                if (ship.alive)
                {
                    BoundingSphere shipsphere =
                        ship.model.Meshes[0].BoundingSphere;
                    shipsphere.Center = ship.position;
                    shipsphere.Radius *= ship.scale;
                    if (shipsphere.Intersects(missilesphere))
                    {
                        soundBank.PlayCue("explosion");
                        missile.alive = false;
                        ship.alive = false;
                        break;
                    }
                }
            }
        }
        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
            DrawGameObject(terrain);
            DrawGameObject(missileLauncherBase);
            DrawGameObject(missileLauncherHead);
            foreach (GameObject missile in missiles)
            {
                if (missile.alive)
                {
                    DrawGameObject(missile);
                }
            }
            foreach (GameObject enemyship in enemyShips)
            {
                if (enemyship.alive)
                {
                    DrawGameObject(enemyship);
                }
            }
            // TODO: Add your drawing code here
            base.Draw(gameTime);
        }
        void DrawGameObject(GameObject gameobject)
        {
            foreach (ModelMesh mesh in gameobject.model.Meshes)
            {
                foreach (BasicEffect effect in mesh.Effects)
                {
                    effect.EnableDefaultLighting();
                    effect.PreferPerPixelLighting = true;
                    effect.World =
                        Matrix.CreateFromYawPitchRoll(
                        gameobject.rotation.Y,
                        gameobject.rotation.X,
                        gameobject.rotation.Z) *
                        Matrix.CreateScale(gameobject.scale) *
                        Matrix.CreateTranslation(gameobject.position);
                    effect.Projection = cameraProjectionMatrix;
                    effect.View = cameraViewMatrix;
                }
                mesh.Draw();
            }
        }
    }
}

99/12/17 XNA旋轉飛機

旋轉飛機

99/12/10 2D射擊遊戲

連結
-------------------------------------------------------------------------------------------------------------
#region File Description
//-----------------------------------------------------------------------------
// Game1.cs
//
// Microsoft XNA Community Game Platform
// Copyright (C) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#endregion
#region Using Statements
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;
#endregion
namespace BeginnersGuide_2DGame_Windows
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        Texture2D backgroundTexture;
        Rectangle viewportRect;
        SpriteBatch spriteBatch;
        GameObject cannon;
        const int maxCannonBalls = 50;
        GameObject[] cannonBalls;
        GamePadState previousGamePadState = GamePad.GetState(PlayerIndex.One);
        KeyboardState previousKeyboardState = Keyboard.GetState();
        const int maxEnemies = 10;
        const float maxEnemyHeight = 0.1f;
        const float minEnemyHeight = 0.5f;
        const float maxEnemyVelocity = 5.0f;
        const float minEnemyVelocity = 1.0f;
        Random random = new Random();
        GameObject[] enemies;
        int score;
        SpriteFont font;
        Vector2 scoreDrawPoint = new Vector2(0.1f, 0.1f);
        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }

        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            base.Initialize();
        }
        /// <summary>
        /// Load your graphics content
        /// </summary>
        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(graphics.GraphicsDevice);
            backgroundTexture =
                   Content.Load<Texture2D>("Sprites\\bk");
            cannon = new GameObject(Content.Load<Texture2D>("Sprites\\cannon"));
            cannon.position = new Vector2(520, graphics.GraphicsDevice.Viewport.Height - 80);
            cannonBalls = new GameObject[maxCannonBalls];
            for (int i = 0; i < maxCannonBalls; i++)
            {
                cannonBalls[i] = new GameObject(Content.Load<Texture2D>(
                    "Sprites\\cannonball"));
            }
            enemies = new GameObject[maxEnemies];
            for (int i = 0; i < maxEnemies; i++)
            {
                enemies[i] = new GameObject(
                    Content.Load<Texture2D>("Sprites\\f"));
            }
            font = Content.Load<SpriteFont>("Fonts\\GameFont");
            //drawable area of the game screen.
            viewportRect = new Rectangle(0, 0,
                graphics.GraphicsDevice.Viewport.Width,
                graphics.GraphicsDevice.Viewport.Height);
            base.LoadContent();
        }
        public void UpdateCannonBalls()
        {
            foreach (GameObject ball in cannonBalls)
            {
                if (ball.alive)
                {
                    ball.position += ball.velocity;
                    if (!viewportRect.Contains(new Point(
                        (int)ball.position.X,
                        (int)ball.position.Y)))
                    {
                        ball.alive = false;
                        continue;
                    }
                    Rectangle cannonBallRect = new Rectangle(
                        (int)ball.position.X,
                        (int)ball.position.Y,
                        ball.sprite.Width,
                        ball.sprite.Height);
                    foreach (GameObject enemy in enemies)
                    {
                        Rectangle enemyRect = new Rectangle(
                            (int)enemy.position.X,
                            (int)enemy.position.Y,
                            enemy.sprite.Width,
                            enemy.sprite.Height);
                        if (cannonBallRect.Intersects(enemyRect))
                        {
                            ball.alive = true;
                            enemy.alive = false;
                            score += 10;
                            break;
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Unload any content not managed by the Content Manager
        /// </summary>
        protected override void UnloadContent()
        {
            base.UnloadContent();
        }
        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();
            GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);
            cannon.rotation += gamePadState.ThumbSticks.Left.X * 0.1f;
            if (gamePadState.Buttons.A == ButtonState.Pressed &&
                previousGamePadState.Buttons.A == ButtonState.Released)
            {
                FireCannonBall();
            }
#if !XBOX
            KeyboardState keyboardState = Keyboard.GetState();
            if(keyboardState.IsKeyDown(Keys.Left))
            {
                cannon.rotation -= 0.1f;
            }
            if(keyboardState.IsKeyDown(Keys.Right))
            {
                cannon.rotation += 0.1f;
            }
            if (keyboardState.IsKeyDown(Keys.Space) &&
                previousKeyboardState.IsKeyUp(Keys.Space))
            {
                FireCannonBall();
            }
#endif
            cannon.rotation = MathHelper.Clamp(cannon.rotation, -MathHelper.PiOver2, 0);
            UpdateCannonBalls();
            UpdateEnemies();
            // TODO: Add your update logic here
            previousGamePadState = gamePadState;
#if !XBOX
            previousKeyboardState = keyboardState;
#endif
            base.Update(gameTime);
        }
        public void UpdateEnemies()
        {
            foreach (GameObject enemy in enemies)
            {
                if (enemy.alive)
                {
                    enemy.position += enemy.velocity;
                    if (!viewportRect.Contains(new Point(
                        (int)enemy.position.X,
                        (int)enemy.position.Y)))
                    {
                        enemy.alive = false;
                    }
                }
                else
                {
                    enemy.alive = true;
                    enemy.position = new Vector2(
                        viewportRect.Right,
                        MathHelper.Lerp(
                        (float)viewportRect.Height * minEnemyHeight,
                        (float)viewportRect.Height * maxEnemyHeight,
                        (float)random.NextDouble()));
                    enemy.velocity = new Vector2(
                        MathHelper.Lerp(
                        -minEnemyVelocity,
                        -maxEnemyVelocity,
                        (float)random.NextDouble()), 0);
                }
            }
        }
        public void FireCannonBall()
        {
            foreach (GameObject ball in cannonBalls)
            {
                if (!ball.alive)
                {
                    ball.alive = true;
                    ball.position = cannon.position - ball.center;
                    ball.velocity = new Vector2(
                        (float)Math.Cos(cannon.rotation),
                        (float)Math.Sin(cannon.rotation)) * 50.0f;
                    return;
                }
            }
        }
       
        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
            spriteBatch.Begin(SpriteBlendMode.AlphaBlend);
            //Draw the backgroundTexture sized to the width
            //and height of the screen.
            spriteBatch.Draw(backgroundTexture, viewportRect,
                Color.White);
            foreach (GameObject ball in cannonBalls)
            {
                if (ball.alive)
                {
                    spriteBatch.Draw(ball.sprite,
                        ball.position, Color.White);
                }
            }
            spriteBatch.Draw(cannon.sprite,
                cannon.position,
                null,
                Color.Green,
                cannon.rotation,
                cannon.center, 1.7f,
                SpriteEffects.None, 0);
          
            foreach (GameObject enemy in enemies)
            {
                if (enemy.alive)
                {
                    spriteBatch.Draw(enemy.sprite,
                        enemy.position, Color.White);
                }
            }
            spriteBatch.DrawString(font,
                "Score: " + score.ToString(),
                new Vector2(scoreDrawPoint.X * viewportRect.Width,
                scoreDrawPoint.Y * viewportRect.Height),
                Color.White);
            spriteBatch.End();
            base.Draw(gameTime);
        }
    }
}