In this chapter, you built an example where two XNA logo images moved around the screen and bounced off the edges. Take the animated sprite example that you built at the end of this chapter and make the animated sprite move and bounce in a similar fashion—but in this case, make the animated sprite move in both X and Y directions and bounce off of all four edges of the screen.

This exercise is fairly straightforward, as it involves taking two examples from the chapter and merging pieces together. The animation aspect of the exercise is covered at the end of the chapter, and the movement and bouncing off screen edges is covered in the middle of the chapter.

One thing that might be tricky is moving in both X and Y directions at the same time. In the previous moving example, you used a float variable for the speed and added it to either the X or the Y coordinate, depending on which sprite you were moving (they both moved in only one direction).

Now I’d recommend using a Vector2 to represent speed. That way you can have different values for speed in the X direction and the Y direction. Also, you can add your Vector2 speed to your Vector2 position by simply adding the two together (you can add Vector2 objects just as you would add integer or float values).

The other catch to this exercise is that in the previous moving example you used the size of the Texture2D object to determine how far from the edge of the screen to bounce in the other direction, but now the size of your Texture2D object will be inaccurate because you’re using a sprite sheet. Instead, you’ll want to use the size of an individual frame within that sprite sheet to detect when the image has hit the edge of the screen.

Here is one possible solution for this exercise:

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;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

namespace AnimatedSprites
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        Texture2D texture;
        Point frameSize = new Point(75, 75);
        Point currentFrame = new Point(0, 0);
        Point sheetSize = new Point(6, 8);

        //Framerate stuff
        int timeSinceLastFrame = 0;
        int millisecondsPerFrame = 16;

        //Speed and movement
        Vector2 speed = new Vector2(5, 2);
        Vector2 position = Vector2.Zero;

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

        protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();
        }

        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            texture = Content.Load<Texture2D>(@"Images	hreerings");
        }

        protected override void UnloadContent()
        {
            // TODO: Unload any non-ContentManager content here
        }

        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back ==
              ButtonState.Pressed)
                this.Exit();

            //Update time since last frame and only
            //change animation if framerate expired
            timeSinceLastFrame += gameTime.ElapsedGameTime.Milliseconds;
            if (timeSinceLastFrame > millisecondsPerFrame)
            {
                timeSinceLastFrame -= millisecondsPerFrame;

                ++currentFrame.X;
                if (currentFrame.X >= sheetSize.X)
                {
                    currentFrame.X = 0;
                    ++currentFrame.Y;
                    if (currentFrame.Y >= sheetSize.Y)
                        currentFrame.Y = 0;
                }
            }

            //Move sprite
            position += speed;

            //If the sprite hit a wall, reverse direction
            if (position.X > Window.ClientBounds.Width - frameSize.X ||
                position.X < 0)
                speed.X *= -1;
            if (position.Y > Window.ClientBounds.Height - frameSize.Y ||
                position.Y < 0)
                speed.Y *= -1;

            base.Update(gameTime);
        }

        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.White);

            spriteBatch.Begin(SpriteSortMode.FrontToBack, BlendState.AlphaBlend);

            spriteBatch.Draw(texture, position,
                new Rectangle(currentFrame.X * frameSize.X,
                    currentFrame.Y * frameSize.Y,
                    frameSize.X,
                    frameSize.Y),
                    Color.White, 0, Vector2.Zero,
                    1, SpriteEffects.None, 0);

            spriteBatch.End();

            base.Draw(gameTime);
        }
    }
}

Let’s combine some aspects of this chapter and the previous one. Take the code where we left off at the end of this chapter and modify it to include another nonuser-controlled sprite (use the plus.png image, which is located with the source code for this chapter in the AnimatedSpritesAnimatedSpritesAnimatedSpritesContentImages folder). Add movement to both nonuser-controlled sprites, as you did in Chapter 3, so that each sprite moves in the X and Y directions and bounces off the edges of the screen. Add collision detection to the newly added sprite as well. The end result will be a game where you try to avoid two moving sprites. When you hit either sprite, the game ends.

For clarity in working with the plus.png image, the frame size of the sprite sheet is 75×75 pixels, and it has six columns and four rows (note that the rings and skull ball sprite sheets both had six columns and eight rows).

This exercise takes principles from Chapters 3 and 4 and combines them to create a very basic game where you try to avoid two sprites that move around the screen. The addition of a new animated sprite is a bit of a challenge, especially the way the code is currently written (in Chapter 5 you learned how to fine-tune the object-oriented design of the system you’re building). Other than that, collision detection and object movement and edge bouncing are handled the same way as in previous examples and should be fairly straightforward at this point. Here’s some sample code for this exercise:

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;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

namespace AnimatedSprites
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        //Rings variables
        Texture2D ringsTexture;
        Point ringsFrameSize = new Point(75, 75);
        Point ringsCurrentFrame = new Point(0, 0);
        Point ringsSheetSize = new Point(6, 8);
        int ringsTimeSinceLastFrame = 0;
        int ringsMillisecondsPerFrame = 50;


        //Skull variables
        Texture2D skullTexture;
        Point skullFrameSize = new Point(75, 75);
        Point skullCurrentFrame = new Point(0, 0);
        Point skullSheetSize = new Point(6, 8);
        int skullTimeSinceLastFrame = 0;
        const int skullMillisecondsPerFrame = 50;

        //Plus variables
        Texture2D plusTexture;
        Point plusFrameSize = new Point(75, 75);
        Point plusCurrentFrame = new Point(0, 0);
        Point plusSheetSize = new Point(6, 4);
        int plusTimeSinceLastFrame = 0;
        const int plusMillisecondsPerFrame = 50;

        //Rings movement
        Vector2 ringsPosition = Vector2.Zero;
        const float ringsSpeed = 6;
        MouseState prevMouseState;

        //Skull position
        Vector2 skullPosition = new Vector2(100, 100);
        Vector2 skullSpeed = new Vector2(4, 2);

        //Plus position
        Vector2 plusPosition = new Vector2(200, 200);
        Vector2 plusSpeed = new Vector2(2, 5);

        //Collision detection variables
        int ringsCollisionRectOffset = 10;
        int skullCollisionRectOffset = 10;
        int plusCollisionRectOffset = 10;


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

        protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();
        }

        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures
            spriteBatch = new SpriteBatch(GraphicsDevice);

            ringsTexture = Content.Load<Texture2D>(@"images 	hreerings");
            skullTexture = Content.Load<Texture2D>(@"imagesskullball");
            plusTexture = Content.Load<Texture2D>(@"imagesplus");
        }

        protected override void UnloadContent()
        {
            // TODO: Unload any non-ContentManager content here
        }

        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back ==
              ButtonState.Pressed)
                this.Exit();

            //Update time since last frame and only
            //change animation if framerate expired
            ringsTimeSinceLastFrame +=
                gameTime.ElapsedGameTime.Milliseconds;
            if (ringsTimeSinceLastFrame > ringsMillisecondsPerFrame)
            {
                ringsTimeSinceLastFrame -= ringsMillisecondsPerFrame;

                ++ringsCurrentFrame.X;
                if (ringsCurrentFrame.X >= ringsSheetSize.X)
                {
                    ringsCurrentFrame.X = 0;
                    ++ringsCurrentFrame.Y;
                    if (ringsCurrentFrame.Y >= ringsSheetSize.Y)
                        ringsCurrentFrame.Y = 0;
                }
            }

            //Then do the same to update the skull animation
            skullTimeSinceLastFrame +=
                gameTime.ElapsedGameTime.Milliseconds;
            if (skullTimeSinceLastFrame > skullMillisecondsPerFrame)
            {
                skullTimeSinceLastFrame -= skullMillisecondsPerFrame;

                ++skullCurrentFrame.X;
                if (skullCurrentFrame.X >= skullSheetSize.X)                {
                    skullCurrentFrame.X = 0;
                    ++skullCurrentFrame.Y;
                    if (skullCurrentFrame.Y >= skullSheetSize.Y)
                        skullCurrentFrame.Y = 0;
                }
            }

            //Then do the same to update the plus animation
            plusTimeSinceLastFrame +=
                gameTime.ElapsedGameTime.Milliseconds;
            if (plusTimeSinceLastFrame > plusMillisecondsPerFrame)
            {
                plusTimeSinceLastFrame -= plusMillisecondsPerFrame;

                ++plusCurrentFrame.X;
                if (plusCurrentFrame.X >= plusSheetSize.X)
                {
                    plusCurrentFrame.X = 0;
                    ++plusCurrentFrame.Y;
                    if (plusCurrentFrame.Y >= plusSheetSize.Y)
                        plusCurrentFrame.Y = 0;
                }
            }

            //Move position of rings based on keyboard input
            KeyboardState keyboardState = Keyboard.GetState();
            if (keyboardState.IsKeyDown(Keys.Left))
                ringsPosition.X -= ringsSpeed;
            if (keyboardState.IsKeyDown(Keys.Right))
                ringsPosition.X += ringsSpeed;
            if (keyboardState.IsKeyDown(Keys.Up))
                ringsPosition.Y -= ringsSpeed;
            if (keyboardState.IsKeyDown(Keys.Down))
                ringsPosition.Y += ringsSpeed;

            //Move the skull
            skullPosition += skullSpeed;
            if (skullPosition.X >
                Window.ClientBounds.Width - skullFrameSize.X ||
                skullPosition.X < 0)
                skullSpeed.X *= -1;
            if (skullPosition.Y >
                Window.ClientBounds.Height - skullFrameSize.Y ||
                skullPosition.Y < 0)
                skullSpeed.Y *= -1;

            //Move the plus
            plusPosition += plusSpeed;
            if (plusPosition.X >
                Window.ClientBounds.Width - plusFrameSize.X ||
                plusPosition.X < 0)
                plusSpeed.X *= -1;            if (plusPosition.Y >
                Window.ClientBounds.Height - plusFrameSize.Y ||
                plusPosition.Y < 0)
                plusSpeed.Y *= -1;

            //Move rings based on mouse movement
            MouseState mouseState = Mouse.GetState();
            if (mouseState.X != prevMouseState.X ||
            mouseState.Y != prevMouseState.Y)
                ringsPosition = new Vector2(mouseState.X, mouseState.Y);
            prevMouseState = mouseState;

            //Move rings based on gamepad input
            GamePadState gamepadState = GamePad.GetState(PlayerIndex.One);
            if (gamepadState.Buttons.A == ButtonState.Pressed)
            {
                //A is pressed, double speed and vibrate
                ringsPosition.X +=
                    ringsSpeed * 2 * gamepadState.ThumbSticks.Left.X;
                ringsPosition.Y -=
                    ringsSpeed * 2 * gamepadState.ThumbSticks.Left.Y;
                GamePad.SetVibration(PlayerIndex.One, 1f, 1f);
            }
            else
            {
                //A is not pressed, normal speed and stop vibration
                ringsPosition.X += ringsSpeed * gamepadState.ThumbSticks.Left.X;
                ringsPosition.Y -= ringsSpeed * gamepadState.ThumbSticks.Left.Y;
                GamePad.SetVibration(PlayerIndex.One, 0, 0);
            }

            //Adjust position of rings to keep it in the game window
            if (ringsPosition.X < 0)
                ringsPosition.X = 0;
            if (ringsPosition.Y < 0)
                ringsPosition.Y = 0;
            if (ringsPosition.X >
                Window.ClientBounds.Width - ringsFrameSize.X)
                ringsPosition.X =
                    Window.ClientBounds.Width - ringsFrameSize.X;
            if (ringsPosition.Y >
                Window.ClientBounds.Height - ringsFrameSize.Y)
                ringsPosition.Y =
                    Window.ClientBounds.Height - ringsFrameSize.Y;

            //If objects collide, exit the game
            if (Collide())
                Exit();

            base.Update(gameTime);
        }

        protected bool Collide()
        {
            Rectangle ringsRect = new Rectangle(
                (int)ringsPosition.X + ringsCollisionRectOffset,
                (int)ringsPosition.Y + ringsCollisionRectOffset,
                ringsFrameSize.X - (ringsCollisionRectOffset * 2),
                ringsFrameSize.Y - (ringsCollisionRectOffset * 2));

            Rectangle skullRect = new Rectangle(
                (int)skullPosition.X + skullCollisionRectOffset,
                (int)skullPosition.Y + skullCollisionRectOffset,
                skullFrameSize.X - (skullCollisionRectOffset * 2),
                skullFrameSize.Y - (skullCollisionRectOffset * 2));

            Rectangle plusRect = new Rectangle(
                (int)plusPosition.X + plusCollisionRectOffset,
                (int)plusPosition.Y + plusCollisionRectOffset,
                plusFrameSize.X - (plusCollisionRectOffset * 2),
                plusFrameSize.Y - (plusCollisionRectOffset * 2));

            return ringsRect.Intersects(skullRect) ||
                ringsRect.Intersects(plusRect);
        }

        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.White);

            spriteBatch.Begin(SpriteSortMode.FrontToBack, BlendState.AlphaBlend);


            //Draw the rings
            spriteBatch.Draw(ringsTexture, ringsPosition,
                new Rectangle(ringsCurrentFrame.X * ringsFrameSize.X,
                    ringsCurrentFrame.Y * ringsFrameSize.Y,
                    ringsFrameSize.X,
                    ringsFrameSize.Y),
                    Color.White, 0, Vector2.Zero,
                    1, SpriteEffects.None, 0);

            //Draw the skull
            spriteBatch.Draw(skullTexture, skullPosition,
                new Rectangle(skullCurrentFrame.X * skullFrameSize.X,
                    skullCurrentFrame.Y * skullFrameSize.Y,
                    skullFrameSize.X,
                    skullFrameSize.Y),
                    Color.White, 0, Vector2.Zero,
                    1, SpriteEffects.None, 0);

            //Draw the plus
            spriteBatch.Draw(plusTexture, plusPosition,
                new Rectangle(plusCurrentFrame.X * plusFrameSize.X,
                    plusCurrentFrame.Y * plusFrameSize.Y,
                    plusFrameSize.X,
                    plusFrameSize.Y),
                    Color.White, 0, Vector2.Zero,
                    1, SpriteEffects.None, 0);

            spriteBatch.End();

            base.Draw(gameTime);
        }
    }
}

Modify the code that you worked on this chapter to create four sprites which move and bounce off all four edges of the screen. To accomplish this, create a new class called BouncingSprite that derives from AutomatedSprite. BouncingSprite should do the same thing that AutomatedSprite does, with the exception that it will check during the Update method to determine whether the sprite has gone off the edge of the screen. If it has, reverse the direction of the sprite by multiplying the speed variable by −1.

Also, make two of the bouncing sprites use the skull image and two of them use the plus image (located with the source code for this chapter in the AnimatedSpritesAnimatedSpritesAnimatedSpritesContentImages directory).

Note that when running this game after making these changes, you’ll have four sprites moving around the screen and the game will exit when any of them collide with the user-controlled sprite. This could cause some issues in testing the game because the sprites may be colliding when the game first loads. Try moving your mouse to a far corner of the screen when loading the game to make sure your user-controlled sprite is out of the way to begin with.

Creating a bouncing sprite should be fairly straightforward at this point. You’ve already created a sprite that bounces off the edges of the game window in a previous chapter (more than once if you did the exercises for the previous chapters). All you’ll need to do is check in the Update method whether the sprite has gone off the edge of the game window and, if it has, reverse its direction. You’ll then need to update the code in your SpriteManager class that creates the automated sprites to have it create BouncingSprites with both the skullball and plus sprites.

Here’s the BouncingSprite class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace AnimatedSprites
{
    class BouncingSprite: AutomatedSprite
    {
        public BouncingSprite(Texture2D textureImage, Vector2 position,
            Point frameSize, int collisionOffset, Point currentFrame,
            Point sheetSize, Vector2 speed)
            : base(textureImage, position, frameSize, collisionOffset,
            currentFrame, sheetSize, speed)
        {
        }
        public BouncingSprite(Texture2D textureImage, Vector2 position,
            Point frameSize, int collisionOffset, Point currentFrame,
            Point sheetSize, Vector2 speed, int millisecondsPerFrame)
            : base(textureImage, position, frameSize, collisionOffset,
            currentFrame, sheetSize, speed, millisecondsPerFrame)
        {
        }

        public override void Update(GameTime gameTime, Rectangle clientBounds)
        {
            position += direction;

            //Reverse direction if hit a side
            if (position.X > clientBounds.Width - frameSize.X ||
                position.X < 0)
                speed.X *= −1;            if (position.Y > clientBounds.Height - frameSize.Y ||
                position.Y < 0)
                speed.Y *= −1;

            base.Update(gameTime, clientBounds);
        }
    }
    }

And you should update the code that creates your automated sprites in your SpriteManager class’s LoadContent method to look something like this:

//Load several different automated sprites into the list
spriteList.Add(new BouncingSprite(
    Game.Content.Load<Texture2D>(@"Images/skullball"),
    new Vector2(150, 150), new Point(75, 75), 10, new Point(0, 0),
    new Point(6, 8), new Vector2(1,1)));
spriteList.Add(new BouncingSprite(
    Game.Content.Load<Texture2D>(@"Images/plus"),
    new Vector2(300, 150), new Point(75, 75), 10, new Point(0, 0),
    new Point(6, 4), new Vector2(1,0)));
spriteList.Add(new BouncingSprite(
    Game.Content.Load<Texture2D>(@"Images/plus"),
    new Vector2(150, 300), new Point(75, 75), 10, new Point(0, 0),
    new Point(6, 4), new Vector2(0,1)));
spriteList.Add(new BouncingSprite(
    Game.Content.Load<Texture2D>(@"Images/skullball"),
    new Vector2(600, 400), new Point(75, 75), 10, new Point(0, 0),
    new Point(6, 8), new Vector2(-1,-1)));

Try experimenting with different sounds and sound settings in XNA using XACT. Find a few .wav files and plug them into the game. Experiment with different settings in XACT by grouping multiple sounds in a single cue.

There’s really no right or wrong answer to this exercise. Follow the steps from earlier in the chapter, add some different sounds, and play with the settings in XACT. It doesn’t need to sound pretty; just use this as a chance to become more familiar with XACT and all that it can do.

Take what you’ve learned in this chapter and make yet another type of sprite object, one that moves randomly around the screen. To do this, you’ll want to create a random timer that signifies when the object should change directions. When the timer expires, have the object move in a different direction, and then reset the random timer to a new random time at which the object will again shift its direction.

When dealing with a random object, you need to figure out when it will randomly change direction. Ideally, it will randomly change direction at random intervals. The actual values that are used to determine the thresholds of the random variables can be customized to get the desired functionality, but the underlying code is the same. Here is a randomly moving sprite class:

using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace AnimatedSprites
{
    class RandomSprite : Sprite
    {
        SpriteManager spriteManager;

        //Random variable to determine when to change directions
        int minChangeTime = 500;
        int maxChangeTime = 1000;
        int changeDirectionTimer;
        Random rnd;        public RandomSprite(Texture2D textureImage, Vector2 position,
            Point frameSize, int collisionOffset, Point currentFrame,
            Point sheetSize, Vector2 speed, string collisionCueName,
            SpriteManager spriteManager, Random rnd)
            : base(textureImage, position, frameSize, collisionOffset,
            currentFrame, sheetSize, speed, collisionCueName)
        {
            this.spriteManager = spriteManager;
            this.rnd = rnd;
            ResetTimer();
        }

        public RandomSprite(Texture2D textureImage, Vector2 position,
            Point frameSize, int collisionOffset, Point currentFrame,
            Point sheetSize, Vector2 speed, int millisecondsPerFrame,
            string collisionCueName, SpriteManager spriteManager,
            Random rnd)
            : base(textureImage, position, frameSize, collisionOffset,
            currentFrame, sheetSize, speed, millisecondsPerFrame,
            collisionCueName)
        {
            this.spriteManager = spriteManager;
            this.rnd = rnd;
            ResetTimer();
        }

        public override Vector2 direction
        {
            get { return speed; }
        }

        public override void Update(GameTime gameTime, Rectangle clientBounds)
        {
            //Move forward
            position += speed;
            Vector2 player = spriteManager.GetPlayerPosition();

            //Is it time to change directions?
            changeDirectionTimer −= gameTime.ElapsedGameTime.Milliseconds;
            if (changeDirectionTimer < 0)
            {
                //Pick a new random direction
                float Length = speed.Length();
                speed = new Vector2((float)rnd.NextDouble() - .5f,
                   (float)rnd.NextDouble() - .5f);
                speed.Normalize();
                speed *= Length;

                ResetTimer();
            }

            base.Update(gameTime, clientBounds);
        }

        private void ResetTimer()
        {
            changeDirectionTimer = rnd.Next(
                minChangeTime, maxChangeTime);
        }

    }
}

Change the behavior of the skull power-up (or power-down, if you prefer) to freeze the player for 2 seconds rather than reduce the player’s speed by 50% for 5 seconds. Use different power-up timers for the skull, bolt, and plus sprites.

There really isn’t anything too complicated involved in adding a new power-up (or power-down), now that you’ve fleshed out the core logic. You already have a built-in way to modify the speed of the player via a power-up (the bolt power-up increases the speed by 100%, and the skull currently slows the player by 50%). To freeze the player, all you’ll need to do is reduce the player’s speed to zero while the power-up is in effect. The other thing to think about is that this power-up will last only two seconds, whereas the others lasted five seconds. So, you’ll need to add a new variable to track when this freeze power-up expires.

The modified SpriteManager class is shown here:

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 AnimatedSprites
{
    /// <summary>
    /// This is a game component that implements IUpdateable.
    /// </summary>
    public class SpriteManager : Microsoft.Xna.Framework.DrawableGameComponent
    {
        // SpriteBatch for drawing
        SpriteBatch spriteBatch;

        // A sprite for the player and a list of automated sprites
        UserControlledSprite player;
        List<Sprite> spriteList = new List<Sprite>();

        // Variables for spawning new enemies
        int enemySpawnMinMilliseconds = 1000;
        int enemySpawnMaxMilliseconds = 2000;
        int enemyMinSpeed = 2;
        int enemyMaxSpeed = 6;
        int nextSpawnTime = 0;

        // Chance of spawning different enemies
        int likelihoodAutomated = 75;
        int likelihoodChasing = 20;
        int likelihoodEvading = 5;

        // Scoring
        int automatedSpritePointValue = 10;
        int chasingSpritePointValue = 20;
        int evadingSpritePointValue = 0;

        // Lives
        List<AutomatedSprite> livesList = new List<AutomatedSprite>();

        //Spawn time variables
        int nextSpawnTimeChange = 5000;
        int timeSinceLastSpawnTimeChange = 0;

        // Powerup stuff
        int powerUpExpiration = 0;
        int powerUpFreezeExpiration = 0;

        public SpriteManager(Game game)
            : base(game)
        {
            // TODO: Construct any child components here
        }

        /// <summary>
        /// Allows the game component to perform any initialization it 
        /// needs to before starting to run.  This is where it can query for 
        /// any required services and load content.
        /// </summary>
        public override void Initialize()
        {
            // Initialize spawn time
            ResetSpawnTime();

            base.Initialize();
        }

        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(Game.GraphicsDevice);

            player = new UserControlledSprite(
                Game.Content.Load<Texture2D>(@"Images/threerings"),
                new Vector2(Game.Window.ClientBounds.Width / 2,
                    Game.Window.ClientBounds.Height / 2),
                new Point(75, 75), 10, new Point(0, 0),
                new Point(6, 8), new Vector2(6, 6));


            // Load player lives list
            for (int i = 0; i < ((Game1)Game).NumberLivesRemaining; ++i)
            {
                int offset = 10 + i * 40;
                livesList.Add(new AutomatedSprite(
                    Game.Content.Load<Texture2D>(@"images	hreerings"),
                    new Vector2(offset, 35), new Point(75, 75), 10,
                    new Point(0, 0), new Point(6, 8), Vector2.Zero,
                    null, 0, .5f));
            }

            base.LoadContent();
        }

        /// <summary>
        /// Allows the game component to update itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        public override void Update(GameTime gameTime)
        {
            // Time to spawn enemy?
            nextSpawnTime -= gameTime.ElapsedGameTime.Milliseconds;
            if (nextSpawnTime < 0)
            {
                SpawnEnemy();

                // Reset spawn timer
                ResetSpawnTime();
            }

            UpdateSprites(gameTime);

            // Adjust sprite spawn times
            AdjustSpawnTimes(gameTime);

            // Expire Powerups?
            CheckPowerUpExpiration(gameTime);

            base.Update(gameTime);
        }

        protected void UpdateSprites(GameTime gameTime)
        {
            // Update player
            player.Update(gameTime, Game.Window.ClientBounds);

            // Update all nonplayer sprites
            for (int i = 0; i < spriteList.Count; ++i)
            {
                Sprite s = spriteList[i];

                s.Update(gameTime, Game.Window.ClientBounds);

                // Check for collisions
                if (s.collisionRect.Intersects(player.collisionRect))
                {
                    // Play collision sound
                    if (s.collisionCueName != null)
                        ((Game1)Game).PlayCue(s.collisionCueName);

                    // If collided with AutomatedSprite
                    // remove a life from the player
                    if (s is AutomatedSprite)
                    {
                        if (livesList.Count > 0)
                        {
                            livesList.RemoveAt(livesList.Count - 1);
                            --((Game1)Game).NumberLivesRemaining;
                        }
                    }
                    else if (s.collisionCueName == "pluscollision")
                    {
                        // Collided with plus - start plus power-up
                        powerUpExpiration = 5000;
                        player.ModifyScale(2);
                    }
                    else if (s.collisionCueName == "skullcollision")
                    {
                        // Collided with skull - start skull power-up
                        powerUpExpiration = 2000;
                        player.ModifySpeed(0f);
                    }
                    else if (s.collisionCueName == "boltcollision")
                    {
                        // Collided with bolt - start bolt power-up
                        powerUpExpiration = 5000;
                        player.ModifySpeed(2);
                    }

                    // Remove collided sprite from the game
                    spriteList.RemoveAt(i);
                    --i;
                }

                // Remove object if it is out of bounds
                if (s.IsOutOfBounds(Game.Window.ClientBounds))
                {
                    ((Game1)Game).AddScore(spriteList[i].scoreValue);
                    spriteList.RemoveAt(i);
                    --i;
                }

            }

            // Update lives-list sprites
            foreach (Sprite sprite in livesList)
                sprite.Update(gameTime, Game.Window.ClientBounds);
        }

        public override void Draw(GameTime gameTime)
        {
            spriteBatch.Begin(SpriteSortMode.FrontToBack, BlendState.AlphaBlend);

            // Draw the player
            player.Draw(gameTime, spriteBatch);

            // Draw all sprites
            foreach (Sprite s in spriteList)
                s.Draw(gameTime, spriteBatch);

            // Draw player lives
            foreach (Sprite sprite in livesList)
                sprite.Draw(gameTime, spriteBatch);

            spriteBatch.End();
            base.Draw(gameTime);
        }

        private void ResetSpawnTime()
        {
            // Set the next spawn time for an enemy
            nextSpawnTime = ((Game1)Game).rnd.Next(
                enemySpawnMinMilliseconds,
                enemySpawnMaxMilliseconds);
        }

        private void SpawnEnemy()
        {
            Vector2 speed = Vector2.Zero;
            Vector2 position = Vector2.Zero;

            // Default frame size
            Point frameSize = new Point(75, 75);

            // Randomly choose which side of the screen to place enemy,
            // then randomly create a position along that side of the screen
            // and randomly choose a speed for the enemy
            switch (((Game1)Game).rnd.Next(4))
            {
                case 0: // LEFT to RIGHT
                    position = new Vector2(
                        -frameSize.X, ((Game1)Game).rnd.Next(0,
                        Game.GraphicsDevice.PresentationParameters.
                        BackBufferHeight - frameSize.Y));
                    speed = new Vector2(((Game1)Game).rnd.Next(
                        enemyMinSpeed,
                        enemyMaxSpeed), 0);
                    break;
                case 1: // RIGHT to LEFT
                    position = new
                        Vector2(
                        Game.GraphicsDevice.PresentationParameters.
                        BackBufferWidth,
                        ((Game1)Game).rnd.Next(0,
                        Game.GraphicsDevice.PresentationParameters.
                        BackBufferHeight - frameSize.Y));

                    speed = new Vector2(-((Game1)Game).rnd.Next(
                        enemyMinSpeed, enemyMaxSpeed), 0);
                    break;
                case 2: // BOTTOM to TOP
                    position = new Vector2(((Game1)Game).rnd.Next(0,
                    Game.GraphicsDevice.PresentationParameters.
                        BackBufferWidth - frameSize.X),
                        Game.GraphicsDevice.PresentationParameters.
                        BackBufferHeight);

                    speed = new Vector2(0,
                        -((Game1)Game).rnd.Next(enemyMinSpeed,
                        enemyMaxSpeed));
                    break;
                case 3: // TOP to BOTTOM
                    position = new Vector2(((Game1)Game).rnd.Next(0,
                        Game.GraphicsDevice.PresentationParameters.BackBufferWidth
                        - frameSize.X), -frameSize.Y);

                    speed = new Vector2(0,
                        ((Game1)Game).rnd.Next(enemyMinSpeed,
                        enemyMaxSpeed));
                    break;
            }

            // Get random number between 0 and 99
            int random = ((Game1)Game).rnd.Next(100);
            if (random < likelihoodAutomated)
            {
                // Create an AutomatedSprite.
                // Get new random number to determine whether to
                // create a three-blade or four-blade sprite.
                if (((Game1)Game).rnd.Next(2) == 0)
                {
                    // Create a four-blade enemy
                    spriteList.Add(
                    new AutomatedSprite(
                        Game.Content.Load<Texture2D>(@"imagesfourblades"),
                        position, new Point(75, 75), 10, new Point(0, 0),
                        new Point(6, 8), speed, "fourbladescollision",
                        automatedSpritePointValue));
                }
                else
                {
                    // Create a three-blade enemy
                    spriteList.Add(
                    new AutomatedSprite(
                        Game.Content.Load<Texture2D>(@"images	hreeblades"),
                        position, new Point(75, 75), 10, new Point(0, 0),
                        new Point(6, 8), speed, "threebladescollision",
                        automatedSpritePointValue));
                }
            }
            else if (random < likelihoodAutomated +
            likelihoodChasing)
            {
                // Create a ChasingSprite.
                // Get new random number to determine whether
                // to create a skull or a plus sprite.
                if (((Game1)Game).rnd.Next(2) == 0)
                {
                    // Create a skull
                    spriteList.Add(
                    new ChasingSprite(
                        Game.Content.Load<Texture2D>(@"imagesskullball"),
                        position, new Point(75, 75), 10, new Point(0, 0),
                        new Point(6, 8), speed, "skullcollision", this,
                        chasingSpritePointValue));
                }
                else
                {                    // Create a plus
                    spriteList.Add(
                    new ChasingSprite(
                        Game.Content.Load<Texture2D>(@"imagesplus"),
                        position, new Point(75, 75), 10, new Point(0, 0),
                        new Point(6, 4), speed, "pluscollision", this,
                        chasingSpritePointValue));
                }
            }
            else
            {
                // Create an EvadingSprite
                spriteList.Add(
                new EvadingSprite(
                    Game.Content.Load<Texture2D>(@"imagesolt"),
                    position, new Point(75, 75), 10, new Point(0, 0),
                    new Point(6, 8), speed, "boltcollision", this,
                    .75f, 150, evadingSpritePointValue));
            }
        }

        // Return current position of the player sprite
        public Vector2 GetPlayerPosition()
        {
            return player.GetPosition;
        }

        protected void AdjustSpawnTimes(GameTime gameTime)
        {
            // If the spawn max time is > 500 milliseconds
            // decrease the spawn time if it is time to do
            // so based on the spawn-timer variables
            if (enemySpawnMaxMilliseconds > 500)
            {
                timeSinceLastSpawnTimeChange += 
                    gameTime.ElapsedGameTime.Milliseconds;
                if (timeSinceLastSpawnTimeChange > nextSpawnTimeChange)
                {
                    timeSinceLastSpawnTimeChange -= nextSpawnTimeChange;
                    if (enemySpawnMaxMilliseconds > 1000)
                    {
                        enemySpawnMaxMilliseconds -= 100;
                        enemySpawnMinMilliseconds -= 100;
                    }
                    else
                    {
                        enemySpawnMaxMilliseconds -= 10;
                        enemySpawnMinMilliseconds -= 10;
                    }
                }
            }
        }

        protected void CheckPowerUpExpiration(GameTime gameTime)
        {
            // Is a power-up active?
            if (powerUpExpiration > 0)
            {
                // Decrement power-up timer
                powerUpExpiration -= gameTime.ElapsedGameTime.Milliseconds;
                if (powerUpExpiration <= 0)
                {
                    // If power-up timer has expired, end all power-ups
                    powerUpExpiration = 0;
                    player.ResetScale();
                    player.ResetSpeed();
                }
            }

            // Is a freeze power-up active?
            if (powerUpFreezeExpiration > 0)
            {
                // Decrement power-up timer
                powerUpFreezeExpiration -= 
                    gameTime.ElapsedGameTime.Milliseconds;
                if (powerUpFreezeExpiration <= 0)
                {
                    // If power-up timer has expired, end all power-ups
                    powerUpFreezeExpiration = 0;
                    player.ResetSpeed();
                }
            }
        }
    }
}

Building on the code that you wrote in this chapter, create a six-sided cube with different textures on each side that rotates on multiple axes.

To create the six-sided cube with different textures on each side, first you’ll need to add five extra images to your project. Then, you’ll have to figure out the coordinates to draw 12 triangles: 2 for each side of the cube. Next, create vertices for the sides of the cube in your vertex array, and then draw each side in your Draw method. One thing to be aware of is that you’ll need to begin and end the effect for each side of the cube because you’ll need to reset the texture for each side (which must be done before BasicEffect.Begin is called).

The Game1 class is the only thing that changes in the solution. It’s listed here:

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 _3D_Madness
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        // Game camera
        Camera camera;

        // Vertex data
        VertexPositionTexture[] verts;
        VertexBuffer vertexBuffer;

        // Effect
        BasicEffect effect;

        // Movement and rotation stuff
        Matrix worldTranslation = Matrix.Identity;
        Matrix worldRotation = Matrix.Identity;

        // Texture info
        List<Texture2D> textureList = new List<Texture2D>();

        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 content. 
        /// </summary>
        protected override void Initialize()
        {
            // Initialize camera
            camera = new Camera(this, new Vector3(0, 0, 5),
                Vector3.Zero, Vector3.Up);
            Components.Add(camera);

            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);

            //initialize vertices
            verts = new VertexPositionTexture[24];
            //FRONT
            verts[0] = new VertexPositionTexture(
                new Vector3(-1, 1, 1), new Vector2(0, 0));
            verts[1] = new VertexPositionTexture(
                new Vector3(1, 1, 1), new Vector2(1, 0));
            verts[2] = new VertexPositionTexture(
                new Vector3(-1, -1, 1), new Vector2(0, 1));
            verts[3] = new VertexPositionTexture(
                new Vector3(1, -1, 1), new Vector2(1, 1));

            //BACK
            verts[4] = new VertexPositionTexture(
                new Vector3(1, 1, -1), new Vector2(0, 0));
            verts[5] = new VertexPositionTexture(
                new Vector3(-1, 1, -1), new Vector2(1, 0));
            verts[6] = new VertexPositionTexture(
                new Vector3(1, -1, -1), new Vector2(0, 1));
            verts[7] = new VertexPositionTexture(
                new Vector3(-1, -1, -1), new Vector2(1, 1));

            //LEFT
            verts[8] = new VertexPositionTexture(
                new Vector3(-1, 1, -1), new Vector2(0, 0));
            verts[9] = new VertexPositionTexture(
                new Vector3(-1, 1, 1), new Vector2(1, 0));
            verts[10] = new VertexPositionTexture(
                new Vector3(-1, -1, -1), new Vector2(0, 1));
            verts[11] = new VertexPositionTexture(
                new Vector3(-1, -1, 1), new Vector2(1, 1));

            //RIGHT
            verts[12] = new VertexPositionTexture(
                new Vector3(1, 1, 1), new Vector2(0, 0));            verts[13] = new VertexPositionTexture(
                new Vector3(1, 1, -1), new Vector2(1, 0));
            verts[14] = new VertexPositionTexture(
                new Vector3(1, -1, 1), new Vector2(0, 1));
            verts[15] = new VertexPositionTexture(
                new Vector3(1, -1, -1), new Vector2(1, 1));

            //TOP
            verts[16] = new VertexPositionTexture(
                new Vector3(-1, 1, -1), new Vector2(0, 0));
            verts[17] = new VertexPositionTexture(
                new Vector3(1, 1, -1), new Vector2(1, 0));
            verts[18] = new VertexPositionTexture(
                new Vector3(-1, 1, 1), new Vector2(0, 1));
            verts[19] = new VertexPositionTexture(
                new Vector3(1, 1, 1), new Vector2(1, 1));

            //BOTTOM
            verts[20] = new VertexPositionTexture(
                new Vector3(-1, -1, 1), new Vector2(0, 0));
            verts[21] = new VertexPositionTexture(
                new Vector3(1, -1, 1), new Vector2(1, 0));
            verts[22] = new VertexPositionTexture(
                new Vector3(-1, -1, -1), new Vector2(0, 1));
            verts[23] = new VertexPositionTexture(
                new Vector3(1, -1, -1), new Vector2(1, 1));


            // Set vertex data in VertexBuffer
            vertexBuffer = new VertexBuffer(GraphicsDevice, 
                typeof(VertexPositionTexture), verts.Length,
                BufferUsage.None);
            vertexBuffer.SetData(verts);

            // Initialize the BasicEffect
            effect = new BasicEffect(GraphicsDevice);

            //load all textures
            textureList.Add(Content.Load<Texture2D>(@"TexturesTrees"));
            textureList.Add(Content.Load<Texture2D>(@"Textures	1"));
            textureList.Add(Content.Load<Texture2D>(@"Textures	2"));
            textureList.Add(Content.Load<Texture2D>(@"Textures	3"));
            textureList.Add(Content.Load<Texture2D>(@"Textures	4"));
            textureList.Add(Content.Load<Texture2D>(@"Textures	5"));
           
        }

        /// <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();

            // Translation
            KeyboardState keyboardState = Keyboard.GetState();
            if (keyboardState.IsKeyDown(Keys.Left))
                worldTranslation *= Matrix.CreateTranslation(-.01f, 0, 0);
            if (keyboardState.IsKeyDown(Keys.Right))
                worldTranslation *= Matrix.CreateTranslation(.01f, 0, 0);

            // Rotation
            worldRotation *= Matrix.CreateFromYawPitchRoll(
                MathHelper.PiOver4 / 60,
                MathHelper.PiOver4 / 360,
                MathHelper.PiOver4 / 180);

            base.Update(gameTime);
        }

        /// <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)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            

            // Set the vertex buffer on the GraphicsDevice
            GraphicsDevice.SetVertexBuffer(vertexBuffer);

            //Set object and camera info
            effect.World = worldRotation * worldTranslation * worldRotation;
            effect.View = camera.view;
            effect.Projection = camera.projection;
            effect.TextureEnabled = true;

            // Draw front
            effect.Texture = textureList[0];
            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();

                GraphicsDevice.DrawUserPrimitives<VertexPositionTexture>
                    (PrimitiveType.TriangleStrip, verts, 0, 2);

            }

            //draw back 
            effect.Texture = textureList[1];
            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();

                GraphicsDevice.DrawUserPrimitives<VertexPositionTexture>
                    (PrimitiveType.TriangleStrip, verts, 4, 2);

            }


            //draw left
            effect.Texture = textureList[2];
            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();

                GraphicsDevice.DrawUserPrimitives<VertexPositionTexture>
                    (PrimitiveType.TriangleStrip, verts, 8, 2);

            }

            //draw right
            effect.Texture = textureList[3];
            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();

                GraphicsDevice.DrawUserPrimitives<VertexPositionTexture>
                    (PrimitiveType.TriangleStrip, verts, 12, 2);

            }

            //draw top
            effect.Texture = textureList[4];
            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();

                GraphicsDevice.DrawUserPrimitives<VertexPositionTexture>
                    (PrimitiveType.TriangleStrip, verts, 16, 2);

            }

            //draw bottom
            effect.Texture = textureList[5];
            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();

                GraphicsDevice.DrawUserPrimitives<VertexPositionTexture>
                    (PrimitiveType.TriangleStrip, verts, 20, 2);

            }


            base.Draw(gameTime);
        }
    }
}

Take the code from this chapter and create a new subclass of BasicModel in which the ship moves back and forth between (0, 0, 0) and (0, 0, −400). Make the ship turn appropriately to always face the direction in which it is going.

There are numerous solutions that will give you the effect described here. The following solution uses a variable to indicate how far the ship can go in the background and a direction Vector3 variable to indicate the ship’s current direction. When the ship reaches a point where it must turn around, the Direction’s Z value is multiplied by −1 and the ship is rotated on a 180 degree yaw to make it face the direction it is heading. The code for a subclass of BasicModel that solves this exercise is shown here (note that you’ll have to create this class and then also modify the ModelManager to create an object of this type rather than the SpinningEnemy type):

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;


namespace _3D_Game
{
    class FlyingShip : BasicModel
    {

        Matrix rotation = Matrix.CreateRotationY(MathHelper.Pi);
        Matrix translation = Matrix.Identity;

        float maxDistance = −400;
        Vector3 direction = new Vector3(0, 0, −1);

        public FlyingShip(Model m)
            : base(m)
        {
        }

        public override void Update()
        {
            //if the object has traveled past the max distance
            //or in front of the origin, reverse direction
            //and rotate ship 180 degrees
            if (translation.Translation.Z < maxDistance ||
                translation.Translation.Z > 0)
            {
                direction.Z *= −1;
                rotation *= Matrix.CreateRotationY(MathHelper.Pi);
            }

            translation *= Matrix.CreateTranslation(direction);
        }

        public override Matrix GetWorld()
        {
            return world * rotation * translation;
        }
    }
}

Remember that to move a 3D camera forward, you use the following code:

    cameraPosition += cameraDirection * speed;

There is a small problem with this method, however, when it’s applied to land-based cameras. Essentially, to eliminate the ability to “fly” when looking up, you remove the Y component of the cameraDirection vector prior to moving the camera with this line of code. This causes your camera to stay at the same Y value, which keeps the camera on the ground.

However, consequently the higher you pitch your camera, the slower you end up moving. For example, if your cameraDirection vector was (10, 2, 0) when you removed the Y component, you would end up with the vector (10, 0, 0) and you’d move at that speed. If your camera was pitched at a larger angle and your cameraDirection vector was (2, 10, 0), the resulting vector after removing the Y component would be (2, 0, 0) and you’d move forward at that speed.

Convert your 3D Flying Camera solution to a land-based camera and solve this problem so that when moving forward and backward your camera moves at the same speed, regardless of the pitch angle. Use the code you created in the first half of this chapter.

Hint: remember that Vector3.Normalize will take any Vector3 and give it a magnitude or length of 1.

The solution to this problem is fairly straightforward. First, you remove the Y component of the direction vector, and then you normalize the resulting vector, which gives the vector a magnitude (or length) of 1. Once you do this, you can multiply the vector by the speed of the camera and add it to your camera position. The code that moves the camera forward and backward is found in the Update method of the Camera class. The solution to the problem affects only that code and is shown here:

//Remove the Y component of the camera direction
Vector3 movementDirection = cameraDirection;
movementDirection.Y = 0;

//Normalize the vector to ensure constant speed
movementDirection.Normalize();

// Move forward/backward
if (Keyboard.GetState().IsKeyDown(Keys.W))
    cameraPosition += movementDirection * speed;
if (Keyboard.GetState().IsKeyDown(Keys.S))
    cameraPosition −= movementDirection * speed;

To familiarize yourself further with what was covered in this chapter, customize the shot firing mechanism by modifying the code to do the following:

Well, the first two problems here are easy: by changing the initial values for the variables representing the shot speed and the shot delay, you can solve each of those problems with minimal coding. To fire three shots in a spread, you’ll have to find the code where a single shot is fired and add two more shots to the model manager (one to the right of the original shot and one to the left).

The Game1 class is the only one that needs modification. Here is a sample solution:

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;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

namespace _3D_Game
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        public Camera camera { get; protected set; }
        ModelManager modelManager;

        //Randomness
        public Random rnd { get; protected set; }

        //Shots
        float shotSpeed = 5;
        int shotDelay = 150;
        int shotCountdown = 0;

        //Crosshair
        Texture2D crosshairTexture;

        //Audio
        AudioEngine audioEngine;
        WaveBank waveBank;
        SoundBank soundBank;
        Cue trackCue;

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

            graphics.PreferredBackBufferWidth = 1280;
            graphics.PreferredBackBufferHeight = 1024;
#if !DEBUG
            graphics.IsFullScreen = true;
#endif

            rnd = new Random();
        }

        protected override void Initialize()
        {
            //Initialize camera
            camera = new Camera(this, new Vector3(0, 0, 50),
                Vector3.Zero, Vector3.Up);
            Components.Add(camera);

            //Initialize model manager
            modelManager = new ModelManager(this);
            Components.Add(modelManager);

            base.Initialize();
        }

        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            //Load crosshair
            crosshairTexture = Content.Load<Texture2D>(@"textures
crosshair");

            // Load sounds and play initial sounds
            audioEngine = new AudioEngine(
                @"ContentAudioGameAudio.xgs");
            waveBank = new WaveBank(audioEngine,
                @"ContentAudioWave Bank.xwb");
            soundBank = new SoundBank(audioEngine,
                @"ContentAudioSound Bank.xsb");

            trackCue = soundBank.GetCue("Tracks");
            trackCue.Play();
        }

        protected override void UnloadContent()
        {
            // TODO: Unload any non-ContentManager content here
        }

        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back ==
                ButtonState.Pressed)
                this.Exit();            // See if the player has fired a shot
            FireShots(gameTime);

            base.Update(gameTime);
        }

        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.Black);

            // TODO: Add your drawing code here

            base.Draw(gameTime);

            //Draw crosshair
            spriteBatch.Begin();

            spriteBatch.Draw(crosshairTexture,
                new Vector2((Window.ClientBounds.Width / 2)
                    - (crosshairTexture.Width / 2),
                    (Window.ClientBounds.Height / 2)
                    - (crosshairTexture.Height / 2)),
                    Color.White);

            spriteBatch.End();
        }

        protected void FireShots(GameTime gameTime)
        {
            if (shotCountdown <= 0)
            {
                // Did player press space bar or left mouse button?
                if (Keyboard.GetState().IsKeyDown(Keys.Space) ||
                    Mouse.GetState().LeftButton == ButtonState.Pressed)
                {
                    // Add a shot to the model manager
                    modelManager.AddShot(
                        camera.cameraPosition + new Vector3(0, −5, 0),
                        camera.GetCameraDirection * shotSpeed);

                    //Add shot in spread to the right
                    Vector3 initialPosition = camera.cameraPosition +
                        Vector3.Cross(camera.GetCameraDirection,
                        camera.cameraUp) * 5;

                    modelManager.AddShot(
                        initialPosition + new Vector3(0, −5, 0),
                        camera.GetCameraDirection * shotSpeed);

                    //Add shot in spread to the left
                    initialPosition = camera.cameraPosition -
                        Vector3.Cross(camera.GetCameraDirection,
                        camera.cameraUp) * 5;

                    modelManager.AddShot(
                        initialPosition + new Vector3(0, −5, 0),
                        camera.GetCameraDirection * shotSpeed);


                    // Play shot audio
                    PlayCue("Shot");

                    // Reset the shot countdown
                    shotCountdown = shotDelay;
                }
            }
            else
                shotCountdown −= gameTime.ElapsedGameTime.Milliseconds;
        }

        public void PlayCue(string cue)
        {
            soundBank.PlayCue(cue);
        }
    }
}

Take the code you built in this chapter and draw a six-sided cube using the trees image provided as the texture for each side of the cube. One each side of the cube, use one of the four texture effects you built in this chapter (normal texture, burred texture, negative texture, grayscale texture). Use each of the four effects at least once on the cube.

This exercise is very similar to the one from Chapter 9 in which you built a six-sided cube with different textures on each side. The difference here is that you’ll be applying the same texture to each side of the cube and then applying different HLSL effects to those sides.

First, create the different effect files as shown in this chapter, and then use something similar to the following code to create the cube and apply the effects:

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 _3D_Madness
{
    /// <summary>
    /// This is the main type for your game.
    /// </summary>
    public class Game1 : Microsoft.Xna.Framework.Game
    {        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        // Game camera
        Camera camera;

        // Vertex data
        VertexPositionTexture[] verts;
        VertexBuffer vertexBuffer;

        // Effect
        Effect normalEffect;
        Effect blurEffect;
        Effect negativeEffect;
        Effect grayscaleEffect;

        // Movement and rotation stuff
        Matrix worldTranslation = Matrix.Identity;
        Matrix worldRotation = Matrix.Identity;

        // Texture info
        Texture2D texture;

        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 content.  
        /// </summary>
        protected override void Initialize()
        {
            // Initialize camera
            camera = new Camera(this, new Vector3(0, 0, 5),
                Vector3.Zero, Vector3.Up);
            Components.Add(camera);

            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);

            //initialize vertices
            verts = new VertexPositionTexture[24];
            //FRONT
            verts[0] = new VertexPositionTexture(
                new Vector3(-1, 1, 1), new Vector2(0, 0));
            verts[1] = new VertexPositionTexture(
                new Vector3(1, 1, 1), new Vector2(1, 0));
            verts[2] = new VertexPositionTexture(
                new Vector3(-1, -1, 1), new Vector2(0, 1));
            verts[3] = new VertexPositionTexture(
                new Vector3(1, -1, 1), new Vector2(1, 1));

            //BACK
            verts[4] = new VertexPositionTexture(
                new Vector3(1, 1, -1), new Vector2(0, 0));
            verts[5] = new VertexPositionTexture(
                new Vector3(-1, 1, -1), new Vector2(1, 0));
            verts[6] = new VertexPositionTexture(
                new Vector3(1, -1, -1), new Vector2(0, 1));
            verts[7] = new VertexPositionTexture(
                new Vector3(-1, -1, -1), new Vector2(1, 1));

            //LEFT
            verts[8] = new VertexPositionTexture(
                new Vector3(-1, 1, -1), new Vector2(0, 0));
            verts[9] = new VertexPositionTexture(
                new Vector3(-1, 1, 1), new Vector2(1, 0));
            verts[10] = new VertexPositionTexture(
                new Vector3(-1, -1, -1), new Vector2(0, 1));
            verts[11] = new VertexPositionTexture(
                new Vector3(-1, -1, 1), new Vector2(1, 1));

            //RIGHT
            verts[12] = new VertexPositionTexture(
                new Vector3(1, 1, 1), new Vector2(0, 0));
            verts[13] = new VertexPositionTexture(
                new Vector3(1, 1, -1), new Vector2(1, 0));
            verts[14] = new VertexPositionTexture(
                new Vector3(1, -1, 1), new Vector2(0, 1));
            verts[15] = new VertexPositionTexture(
                new Vector3(1, -1, -1), new Vector2(1, 1));

            //TOP
            verts[16] = new VertexPositionTexture(
                new Vector3(-1, 1, -1), new Vector2(0, 0));
            verts[17] = new VertexPositionTexture(
                new Vector3(1, 1, -1), new Vector2(1, 0));
            verts[18] = new VertexPositionTexture(
                new Vector3(-1, 1, 1), new Vector2(0, 1));
            verts[19] = new VertexPositionTexture(
                new Vector3(1, 1, 1), new Vector2(1, 1));

            //BOTTOM
            verts[20] = new VertexPositionTexture(
                new Vector3(-1, -1, 1), new Vector2(0, 0));
            verts[21] = new VertexPositionTexture(
                new Vector3(1, -1, 1), new Vector2(1, 0));
            verts[22] = new VertexPositionTexture(
                new Vector3(-1, -1, -1), new Vector2(0, 1));
            verts[23] = new VertexPositionTexture(
                new Vector3(1, -1, -1), new Vector2(1, 1));

            // Set vertex data in VertexBuffer
            vertexBuffer = new VertexBuffer(GraphicsDevice,
                typeof(VertexPositionTexture), verts.Length,
                BufferUsage.None);
            vertexBuffer.SetData(verts);

            //Load effect
            normalEffect = Content.Load<Effect>(@"effectsRed");
            grayscaleEffect = Content.Load<Effect>(@"effectsGrayscale");
            negativeEffect = Content.Load<Effect>(@"effectsNegative");
            blurEffect = Content.Load<Effect>(@"effectsBlur");

            // Load texture
            texture = Content.Load<Texture2D>(@"Textures	rees");
           
        }

        /// <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();

            // Translation
            KeyboardState keyboardState = Keyboard.GetState();
            if (keyboardState.IsKeyDown(Keys.Left))
                worldTranslation *= Matrix.CreateTranslation(-.01f, 0, 0);
            if (keyboardState.IsKeyDown(Keys.Right))
                worldTranslation *= Matrix.CreateTranslation(.01f, 0, 0);

            // Rotation
            worldRotation *= Matrix.CreateFromYawPitchRoll(
                MathHelper.PiOver4 / 60,
                0, 
                0);

            base.Update(gameTime);
        }

        /// <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)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            

            // Set the vertex buffer on the GraphicsDevice
            GraphicsDevice.SetVertexBuffer(vertexBuffer);

            //Draw front
            DrawVerts(normalEffect, 0, 2);
            //Draw back
            DrawVerts(blurEffect, 4, 2);
            //Draw left
            DrawVerts(grayscaleEffect, 8, 2);
            //Draw right
            DrawVerts(negativeEffect, 12, 2);
            //Draw top
            DrawVerts(blurEffect, 16, 2);
            //Draw bottom
            DrawVerts(grayscaleEffect, 20, 2);

            base.Draw(gameTime);
        }

        protected void DrawVerts(Effect effect, int start, int end)
        {
            effect.CurrentTechnique = effect.Techniques["Textured"];
            Matrix world = worldRotation * worldTranslation;
            effect.Parameters["xWorldViewProjection"].SetValue(
                world * camera.view * camera.projection);
            effect.Parameters["xColoredTexture"].SetValue(texture);

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();
                GraphicsDevice.DrawUserPrimitives<VertexPositionTexture>
                    (PrimitiveType.TriangleStrip, verts, start, end);
            }

        }
    }
}

Create a multishot power-up that, when active, will fire four shots instead of one. Instead of shooting one shot in the center of the camera, when multishot is active, shoot one shot from above and right of the camera, one from above and left, one from below and right, and one from below and left.

When the player shoots three ships in a row, the game will randomly choose which power-up to activate (rapid fire or multishot).

You have all the code fleshed out to create a power-up. Now you’ll need to take that code and add a new multishot power-up. Start with adding a new value to the PowerUps enum to represent multishot mode.

Once that’s done, there are really only two other steps: add code when a power-up is triggered that randomly picks the multishot or rapid fire mode, and add the code to fire multiple shots in multishot mode.

The difficult part will be in the FireShots method of the Game1 class, where you’ll need to add the code for multiple shots. Here is one possible solution for that part of the problem:

protected void FireShots(GameTime gameTime)
{
    if (shotCountdown <= 0)
    {
        // Did player press space bar or left mouse button?
        if (Keyboard.GetState().IsKeyDown(Keys.Space) ||
            Mouse.GetState().LeftButton == ButtonState.Pressed)
        {
            if (currentPowerUp != PowerUps.MULTI_SHOT)
            {
                //Normal mode - fire one shot

                // Add a shot to the model manager
                modelManager.AddShot(
                    camera.cameraPosition + new Vector3(0, −5, 0),
                    camera.GetCameraDirection * shotSpeed);
            }
            else
            {
                //Multi-shot mode!

                //Add shot in spread to the top right
                Vector3 initialPosition = camera.cameraPosition +
                    Vector3.Cross(camera.GetCameraDirection, camera.
                        cameraUp) * 5
                        + (camera.cameraUp * 5);
                modelManager.AddShot(
                    initialPosition + new Vector3(0, −5, 0),
                    camera.GetCameraDirection * shotSpeed);

                //Add shot in spread to the bottom right
                initialPosition = camera.cameraPosition +
                    Vector3.Cross(camera.GetCameraDirection, camera.
                        cameraUp) * 5
                        - (camera.cameraUp * 5);
                modelManager.AddShot(
                    initialPosition + new Vector3(0, −5, 0),
                    camera.GetCameraDirection * shotSpeed);

                //Add shot in spread top left
                initialPosition = camera.cameraPosition −
                    Vector3.Cross(camera.GetCameraDirection, camera.
                        cameraUp) * 5
                        + (camera.cameraUp * 5);
                modelManager.AddShot(
                    initialPosition + new Vector3(0, −5, 0),
                    camera.GetCameraDirection * shotSpeed);

                //Add shot in spread bottom left
                initialPosition = camera.cameraPosition −
                    Vector3.Cross(camera.GetCameraDirection, camera.
                        cameraUp) * 5
                        − (camera.cameraUp * 5);
                modelManager.AddShot(
                    initialPosition + new Vector3(0, −5, 0),
                    camera.GetCameraDirection * shotSpeed);
            }

            // Play shot audio
            PlayCue("Shot");

            // Reset the shot countdown
            shotCountdown = shotDelay;
        }
    }
    else
        shotCountdown −= gameTime.ElapsedGameTime.Milliseconds;
}