空戰

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 = 20;
        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 nump1_wedgeps = 1;
        GameObject[] p1_wedges;
        Vector3 shipMinPosition = new Vector3(-2000.0f, 300.0f, -2000.0f);
        Vector3 shipMaxPosition = new Vector3(2000.0f, 300.0f, -2000.0f);
        const float shipMinVelocity = 0.0f;
        const float shipMaxVelocity = 50.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.2f;
            missileLauncherHead.model = Content.Load<Model>(
                "Models\\p1_wedge");
            missileLauncherHead.scale = 0.025f;
            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;
            }
            p1_wedges = new GameObject[nump1_wedgeps];
            for (int i = 0; i < nump1_wedgeps; i++)
            {
                p1_wedges[i] = new GameObject();
                p1_wedges[i].model = Content.Load<Model>(
                    "Models\\p1_wedge");
                p1_wedges[i].scale = 0.1f;
                p1_wedges[i].rotation = new Vector3(
                    0.0f, 0, 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();
            Updatep1_wedges();
            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 Updatep1_wedges()
        {
            foreach (GameObject ship in p1_wedges)
            {
                if (ship.alive)
                {
                    ship.position -= ship.velocity;
                    if (ship.position.Z < -6000.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,
                        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 p1_wedges)
            {
                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 p1_wedge in p1_wedges)
            {
                if (p1_wedge.alive)
                {
                    DrawGameObject(p1_wedge);
                }
            }
            // 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();
            }
        }
    }
}

旋轉的飛機

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 GoingBeyond1_Tutorial
{
    /// <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 = 20;
        GameObject[] missiles;
        GamePadState previousState;
        KeyboardState previousKeyboardState;
        const float launcherHeadMuzzleOffset = 20.0f;
        const float missilePower = 20.0f;
        Vector3 cameraLookAt = new Vector3(0.0f, 50.0f, 0.0f);
        Matrix cameraProjectionMatrix;
        Matrix cameraViewMatrix;
        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }
        protected override void Initialize()
        {
            base.Initialize();
        }
        // Set the 3D model to draw.
        Model myModel;
        // The aspect ratio determines how to scale 3d to 2d projection.
        float aspectRatio;
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);
            cameraViewMatrix = Matrix.CreateLookAt(
                cameraPosition,
                cameraLookAt,
                Vector3.Up);
            cameraProjectionMatrix = Matrix.CreatePerspectiveFieldOfView(
                MathHelper.ToRadians(45.0f),
                graphics.GraphicsDevice.Viewport.AspectRatio,
                1.0f,
                10000.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;
            }
           

            myModel = Content.Load<Model>("Models\\p1_wedge");
            aspectRatio = (float)graphics.GraphicsDevice.Viewport.Width /
            (float)graphics.GraphicsDevice.Viewport.Height;
        }
        protected override void UnloadContent()
        {
        }
      
        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;
          
            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;
            }
 
            if (keyboardState.IsKeyDown(Keys.Space) &&
                previousKeyboardState.IsKeyUp(Keys.Space))
            {
                FireMissile();
                modelRotation += (float)gameTime.ElapsedGameTime.TotalMilliseconds * MathHelper.ToRadians(0.1f);
            }
            previousKeyboardState = keyboardState;

           
            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);
        }
       
       
        // Set the position of the model in world space, and set the rotation.
        Vector3 modelPosition = Vector3.Zero;
        float modelRotation = 0.0f;
        // Set the position of the camera in world space, for our view matrix.
        Vector3 cameraPosition = new Vector3(0.0f, 50.0f, 1500.0f);
        protected override void Draw(GameTime gameTime)
        {
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

            // Copy any parent transforms.
            Matrix[] transforms = new Matrix[myModel.Bones.Count];
            myModel.CopyAbsoluteBoneTransformsTo(transforms);
            // Draw the model. A model can have multiple meshes, so loop.
            foreach (ModelMesh mesh in myModel.Meshes)
            {
                // This is where the mesh orientation is set, as well as our camera and projection.
                foreach (BasicEffect effect in mesh.Effects)
                {
                    effect.EnableDefaultLighting();
                    effect.World = transforms[mesh.ParentBone.Index] * Matrix.CreateRotationY(modelRotation)
                        * Matrix.CreateTranslation(modelPosition);
                    effect.View = Matrix.CreateLookAt(cameraPosition, Vector3.Zero, Vector3.Up);
                    effect.Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f),
                        aspectRatio, 1.0f, 10000.0f);
                }
                // Draw the mesh, using the effects set above.
                mesh.Draw();
            }
                base.Draw(gameTime);
        }
          
       
    }
}

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 = 1000;
        GameObject[] cannonBalls;
        GamePadState previousGamePadState = GamePad.GetState(PlayerIndex.One);
        KeyboardState previousKeyboardState = Keyboard.GetState();
        const int maxEnemies = 100;
        const int maxanemies = 5;
        const float maxEnemyHeight = 0.1f;
        const float minEnemyHeight = 0.5f;
        const float maxEnemyVelocity = 5.0f;
        const float minEnemyVelocity = 1.0f;
        const float maxanemyHeight = 0.1f;
        const float minanemyHeight = 0.5f;
        const float maxanemyVelocity = 5.0f;
        const float minanemyVelocity = 1.0f;
        Random random = new Random();
        GameObject[] enemies;
        GameObject[] anemies;
        int score;
        SpriteFont font;
        Vector2 scoreDrawPoint = new Vector2(0.7f, 0.9f);
        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\\background");
            cannon = new GameObject(Content.Load<Texture2D>("Sprites\\cannon"));
            cannon.position = new Vector2(250, graphics.GraphicsDevice.Viewport.Height - 300);
            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\\enemy"));
            }
            anemies = new GameObject[maxanemies];
            for (int i = 0; i < maxanemies; i++)
            {
                anemies[i] = new GameObject(
                    Content.Load<Texture2D>("Sprites\\anemy"));
            }
            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 += 10000;
                            break;
                        }
                    }
                    foreach (GameObject anemy in anemies)
                    {
                        Rectangle enemyRect = new Rectangle(
                            (int)anemy.position.X,
                            (int)anemy.position.Y,
                            anemy.sprite.Width,
                            anemy.sprite.Height);
                        if (cannonBallRect.Intersects(enemyRect))
                        {
                            ball.alive = true;
                            anemy.alive = false;
                            score += 10000;
                            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.5f;
            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.09f;
            }
            if(keyboardState.IsKeyDown(Keys.Right))
            {
                cannon.rotation += 0.09f;
            }
            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);
                }
            }
            foreach (GameObject anemy in enemies)
            {
                if (anemy.alive)
                {
                    anemy.position += anemy.velocity;
                    if (!viewportRect.Contains(new Point(
                        (int)anemy.position.X,
                        (int)anemy.position.Y)))
                    {
                        anemy.alive = false;
                    }
                }
                else
                {
                    anemy.alive = true;
                    anemy.position = new Vector2(
                        viewportRect.Right,
                        MathHelper.Lerp(
                        (float)viewportRect.Height * minEnemyHeight,
                        (float)viewportRect.Height * maxEnemyHeight,
                        (float)random.NextDouble()));
                    anemy.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)) * 1.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.Black);
                }
            }
            spriteBatch.Draw(cannon.sprite,
                cannon.position,
                null,
                Color.Red,
                cannon.rotation,
                cannon.center, 1.0f,
                SpriteEffects.None, 0);
          
            foreach (GameObject enemy in enemies)
            {
                if (enemy.alive)
                {
                    spriteBatch.Draw(enemy.sprite,
                        enemy.position, Color.Yellow);
                }
            }
            foreach (GameObject anemy in enemies)
            {
                if (anemy.alive)
                {
                    spriteBatch.Draw(anemy.sprite,
                        anemy.position, Color.Yellow);
                }
            }
            spriteBatch.DrawString(font,
                "Score: " + score.ToString(),
                new Vector2(scoreDrawPoint.X * viewportRect.Width,
                scoreDrawPoint.Y * viewportRect.Height),
                Color.Yellow);
            spriteBatch.End();
            base.Draw(gameTime);
        }
    }
}

free 3ds model

http://www.gfx-3d-model.blogspot.com/





http://www.sharecg.com/b/5/3D%20Models

魔術精靈

程式碼

紅綠燈

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication2
{
    public partial class Form1 : Form
    {
        int i,j;
        public Form1()
        {
            InitializeComponent();           
            i = 0;
            j = 0;
        }
        private void timer1_Tick(object sender, EventArgs e)
        {
            button1.Enabled = false;
            button2.Enabled = false;
            button3.Enabled = false;
            i++;
            i = i % 6;
            label1.Text = Convert.ToString(i);
            j++;
            j = j % 5;
            switch (j)
            {
                case 0:
                    button1.Enabled = true;
                    break;
                case 1:
                    button2.Enabled = true;
                    break;
                case 2:
                    button3.Enabled = true;
                    break;
                case 3:
                    button3.Enabled = true;
                    break;
                case 4:
                    button3.Enabled = true;
                    break;
                case 5:
                    button3.Enabled = true;
                    break;


            }
        }

     }

}

亂數產生

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        int[] arry = new int[9];
        public Form1()
        {
            InitializeComponent();
        }

        private void button10_Click(object sender, EventArgs e)
        {
            int rdno;
            int temp;
            arry[0] = 0;
            arry[1] = 1;
            arry[2] = 2;
            arry[3] = 3;
            arry[4] = 4;
            arry[5] = 5;
            arry[6] = 6;
            arry[7] = 7;
            arry[8] = 8;

            for (int i = 0; i < 9; i++)
            {
                Random rd = new Random();
                rdno = rd.Next(0, 9);
                button10.Text = Convert.ToString(rdno);
                temp = arry[rdno];
                arry[rdno] = arry[arry.Length - (i + 1)];
                arry[arry.Length - (i + 1)] = temp;
            }

            button1.Text = Convert.ToString(arry[0]);
            button2.Text = Convert.ToString(arry[1]);
            button3.Text = Convert.ToString(arry[2]);
            button4.Text = Convert.ToString(arry[3]);
            button5.Text = Convert.ToString(arry[4]);
            button6.Text = Convert.ToString(arry[5]);
            button7.Text = Convert.ToString(arry[6]);
            button8.Text = Convert.ToString(arry[7]);
            button9.Text = Convert.ToString(arry[8]);

        }
        private void Form1_Load(object sender, EventArgs e)
        {
            arry[0] = 0;
            arry[1] = 1;
            arry[2] = 2;
            arry[3] = 3;
            arry[4] = 4;
            arry[5] = 5;
            arry[6] = 6;
            arry[7] = 7;
            arry[8] = 8;
            button1.Text = Convert.ToString(arry[0]);
            button2.Text = Convert.ToString(arry[1]);
            button3.Text = Convert.ToString(arry[2]);
            button4.Text = Convert.ToString(arry[3]);
            button5.Text = Convert.ToString(arry[4]);
            button6.Text = Convert.ToString(arry[5]);
            button7.Text = Convert.ToString(arry[6]);
            button8.Text = Convert.ToString(arry[7]);
            button9.Text = Convert.ToString(arry[8]);

        }
    }
}